Swap available balance

contracts/swap/swap.go

@@ -22,6 +22,7 @@ package swap
 import (
 	"context"
 	"errors"
+	"fmt"
 	"math/big"
 	"time"
 
@@ -44,8 +45,14 @@ type Backend interface {
 
 // Contract interface defines the methods exported from the underlying go-bindings for the smart contract
 type Contract interface {
+	// Withdraw attempts to withdraw Wei from the chequebook
+	Withdraw(auth *bind.TransactOpts, backend Backend, amount *big.Int) (*types.Receipt, error)
+	// Deposit sends a raw transaction to the chequebook, triggering the fallback—depositing amount
+	Deposit(auth *bind.TransactOpts, backend Backend, amout *big.Int) (*types.Receipt, error)
 	// CashChequeBeneficiary cashes the cheque by the beneficiary
 	CashChequeBeneficiary(auth *bind.TransactOpts, beneficiary common.Address, cumulativePayout *big.Int, ownerSig []byte) (*CashChequeResult, *types.Receipt, error)
+	// LiquidBalance returns the LiquidBalance (total balance in Wei - total hard deposits in Wei) of the chequebook
+	LiquidBalance(auth *bind.CallOpts) (*big.Int, error)
 	// ContractParams returns contract info (e.g. deployed address)
 	ContractParams() *Params
 	// Issuer returns the contract owner from the blockchain
@@ -97,6 +104,32 @@ func InstanceAt(address common.Address, backend Backend) (Contract, error) {
 	return c, err
 }
 
+// Withdraw withdraws amount from the chequebook and blocks until the transaction is mined
+func (s simpleContract) Withdraw(auth *bind.TransactOpts, backend Backend, amount *big.Int) (*types.Receipt, error) {
+	tx, err := s.instance.Withdraw(auth, amount)
+	if err != nil {
+		return nil, err
+	}
+	return WaitFunc(auth, backend, tx)
+}
+
+// Deposit sends a transaction to the chequebook, which deposits the amount set in Auth.Value and blocks until the transaction is mined
+func (s simpleContract) Deposit(auth *bind.TransactOpts, backend Backend, amount *big.Int) (*types.Receipt, error) {
+	rawSimpleSwap := contract.SimpleSwapRaw{Contract: s.instance}
+	if auth.Value != big.NewInt(0) {
+		return nil, fmt.Errorf("Deposit value can only be set via amount parameter")
+	}
+	if amount == big.NewInt(0) {
+		return nil, fmt.Errorf("Deposit amount cannot be equal to zero")
+	}
+	auth.Value = amount
+	tx, err := rawSimpleSwap.Transfer(auth)
+	if err != nil {
+		return nil, err
+	}
+	return WaitFunc(auth, backend, tx)
+}
+
 // CashChequeBeneficiary cashes the cheque on the blockchain and blocks until the transaction is mined.
 func (s simpleContract) CashChequeBeneficiary(opts *bind.TransactOpts, beneficiary common.Address, cumulativePayout *big.Int, ownerSig []byte) (*CashChequeResult, *types.Receipt, error) {
 	tx, err := s.instance.CashChequeBeneficiary(opts, beneficiary, cumulativePayout, ownerSig)
@@ -131,6 +164,11 @@ func (s simpleContract) CashChequeBeneficiary(opts *bind.TransactOpts, beneficia
 	return result, receipt, nil
 }
 
+// LiquidBalance returns the LiquidBalance (total balance in Wei - total hard deposits in Wei) of the chequebook
+func (s simpleContract) LiquidBalance(opts *bind.CallOpts) (*big.Int, error) {
+	return s.instance.LiquidBalance(opts)
+}
+
 // ContractParams returns contract information
 func (s simpleContract) ContractParams() *Params {
 	return &Params{

swap/protocol.go

@@ -161,6 +161,7 @@ type swapAPI interface {
 	SentCheques() (map[enode.ID]*Cheque, error)
 	ReceivedCheque(peer enode.ID) (cheque *Cheque, err error)
 	ReceivedCheques() (map[enode.ID]*Cheque, error)
+	AvailableBalance() (uint64, error)
 }
 
 // API would be the API accessor for protocol methods

swap/swap.go

@@ -53,15 +53,15 @@ const swapLogLevel = 3 // swapLogLevel indicates filter level of log messages
 // A node maintains an individual balance with every peer
 // Only messages which have a price will be accounted for
 type Swap struct {
-	store             state.Store            // store is needed in order to keep balances and cheques across sessions
-	peers             map[enode.ID]*Peer     // map of all swap Peers
-	peersLock         sync.RWMutex           // lock for peers map
-	backend           contract.Backend       // the backend (blockchain) used
-	owner             *Owner                 // contract access
-	params            *Params                // economic and operational parameters
-	contract          swap.Contract          // reference to the smart contract
-	chequebookFactory swap.SimpleSwapFactory // the chequebook factory used
-	honeyPriceOracle  HoneyOracle            // oracle which resolves the price of honey (in Wei)
+	store             state.Store                // store is needed in order to keep balances and cheques across sessions
+	peers             map[enode.ID]*Peer         // map of all swap Peers
+	peersLock         sync.RWMutex               // lock for peers map
+	backend           contract.Backend           // the backend (blockchain) used
+	owner             *Owner                     // contract access
+	params            *Params                    // economic and operational parameters
+	contract          contract.Contract          // reference to the smart contract
+	chequebookFactory contract.SimpleSwapFactory // the chequebook factory used
+	honeyPriceOracle  HoneyOracle                // oracle which resolves the price of honey (in Wei)
 }
 
 // Owner encapsulates information related to accessing the contract
@@ -179,6 +179,7 @@ func New(dbPath string, prvkey *ecdsa.PrivateKey, backendURL string, params *Par
 		return nil, err
 	}
 	swapLog.Info("Using backend network ID", "ID", chainID.Uint64())
+
 	// create the owner of SWAP
 	owner := createOwner(prvkey)
 	// initialize the factory
@@ -199,6 +200,13 @@ func New(dbPath string, prvkey *ecdsa.PrivateKey, backendURL string, params *Par
 	if swap.contract, err = swap.StartChequebook(chequebookAddressFlag, initialDepositAmountFlag); err != nil {
 		return nil, err
 	}
+	availableBalance, err := swap.AvailableBalance()
+	if err != nil {
+		return nil, err
+	}
+
+	swapLog.Info("available balance", "balance", availableBalance)
+
 	return swap, nil
 }
 
@@ -461,6 +469,37 @@ func (s *Swap) Balances() (map[enode.ID]int64, error) {
 	return balances, nil
 }
 
+// AvailableBalance returns the total balance of the chequebook against which new cheques can be written
+func (s *Swap) AvailableBalance() (uint64, error) {
+	// get the LiquidBalance of the chequebook
+	liquidBalance, err := s.contract.LiquidBalance(nil)
+	if err != nil {
+		return 0, err
+	}
+
+	// get all sent Cheques
+	sentCheques, err := s.SentCheques()
+	if err != nil {
+		return 0, err
+	}
+
+	// Compute the total worth of cheques sent and how much of of this is cashed
+	var sentChequesWorth uint64
+	var cashedChequesWorth uint64
+	for _, ch := range sentCheques {
+		if ch == nil {
+			continue
+		}
+		sentChequesWorth += ch.ChequeParams.CumulativePayout
+		paidOut, err := s.contract.PaidOut(nil, ch.ChequeParams.Beneficiary)
+		if err != nil {
+			return 0, err
+		}
+		cashedChequesWorth += paidOut.Uint64()
+	}
+	return liquidBalance.Uint64() + cashedChequesWorth - sentChequesWorth, nil
+}
+
 // SentCheque returns the last sent cheque for a given peer
 func (s *Swap) SentCheque(peer enode.ID) (cheque *Cheque, err error) {
 	if swapPeer := s.getPeer(peer); swapPeer != nil {
@@ -594,7 +633,7 @@ func (s *Swap) Close() error {
 }
 
 // GetParams returns contract parameters (Bin, ABI, contractAddress) from the contract
-func (s *Swap) GetParams() *swap.Params {
+func (s *Swap) GetParams() *contract.Params {
 	return s.contract.ContractParams()
 }
 

swap/swap_test.go

@@ -1543,6 +1543,9 @@ func testWaitForTx(auth *bind.TransactOpts, backend cswap.Backend, tx *types.Tra
 	if err != nil {
 		return nil, err
 	}
+	if receipt.Status != types.ReceiptStatusSuccessful {
+		return nil, cswap.ErrTransactionReverted
+	}
 	return receipt, nil
 }
 
@@ -1902,6 +1905,75 @@ func TestPeerGetLastSentCumulativePayout(t *testing.T) {
 	}
 }
 
+func TestAvailableBalance(t *testing.T) {
+	testBackend := newTestBackend()
+	defer testBackend.Close()
+	swap, clean := newTestSwap(t, ownerKey, testBackend)
+	defer clean()
+	cleanup := setupContractTest()
+	defer cleanup()
+
+	// deploy a chequebook
+	err := testDeploy(context.TODO(), swap)
+	if err != nil {
+		t.Fatal(err)
+	}
+	// create a peer
+	peer, err := swap.addPeer(newDummyPeerWithSpec(Spec).Peer, swap.owner.address, swap.GetParams().ContractAddress)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// verify that available balance equals depositAmount (we deposit during deployment)
+	depositAmount := big.NewInt(9000 * int64(RetrieveRequestPrice))
+	availableBalance, err := swap.AvailableBalance()
+	if err != nil {
+		t.Fatal(err)
+	}
+	if availableBalance != depositAmount.Uint64() {
+		t.Fatalf("availableBalance not equal to deposited amount. availableBalance: %d, depositAmount: %d", availableBalance, depositAmount)
+	}
+	// withdraw 50
+	withdrawAmount := big.NewInt(50)
+	netDeposit := depositAmount.Uint64() - withdrawAmount.Uint64()
+	opts := bind.NewKeyedTransactor(swap.owner.privateKey)
+	opts.Context = context.TODO()
+	rec, err := swap.contract.Withdraw(opts, swap.backend, withdrawAmount)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if rec.Status != types.ReceiptStatusSuccessful {
+		t.Fatal("Transaction reverted")
+	}
+
+	// verify available balance
+	availableBalance, err = swap.AvailableBalance()
+	if err != nil {
+		t.Fatal(err)
+	}
+	if availableBalance != netDeposit {
+		t.Fatalf("availableBalance not equal to deposited minus withdraw. availableBalance: %d, deposit minus withdrawn: %d", availableBalance, depositAmount.Uint64()-withdrawAmount.Uint64())
+	}
+
+	// send a cheque worth 42
+	chequeAmount := int64(42)
+	// create a dummy peer. Note: the peer's contract address and the peers address are resp the swap contract and the swap owner
+	peer.setBalance(-chequeAmount)
+	if err = peer.sendCheque(); err != nil {
+		t.Fatal(err)
+	}
+
+	availableBalance, err = swap.AvailableBalance()
+	if err != nil {
+		t.Fatal(err)
+	}
+	// verify available balance
+	if availableBalance != (netDeposit - uint64(chequeAmount)) {
+		t.Fatalf("availableBalance not equal to deposited minus withdraw. availableBalance: %d, deposit minus withdrawn: %d", availableBalance, depositAmount.Uint64()-withdrawAmount.Uint64())
+	}
+
+}
+
 // dummyMsgRW implements MessageReader and MessageWriter
 // but doesn't do anything. Useful for dummy message sends
 type dummyMsgRW struct{}