swap, contracts, vendor: move to waiver-free simplestswap (ethersphere#1683)

* swap: use newer simple swap contract

* swap: check if cheque bounced

* swap: increase balance by honey on sendCheque

Author: ralph-pichler

contracts/swap/contract/code.go

@@ -29,13 +29,13 @@ import (
 	"github.com/ethereum/go-ethereum/accounts/abi/bind"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/types"
-	"github.com/ethersphere/swarm/contracts/swap/contract"
+	contract "github.com/ethersphere/go-sw3/contracts-v0-1-0/simpleswap"
 )
 
 var (
 	// ErrNotASwapContract is given when an address is verified not to have a SWAP contract based on its bytecode
 	ErrNotASwapContract = errors.New("not a swap contract")
-	// ErrTransactionReverted is given when the transaction that submits or cashes a cheque is reverted
+	// ErrTransactionReverted is given when the transaction that cashes a cheque is reverted
 	ErrTransactionReverted = errors.New("Transaction reverted")
 )
 
@@ -48,7 +48,7 @@ type Backend interface {
 // Deploy deploys an instance of the underlying contract and returns its `Contract` abstraction
 func Deploy(auth *bind.TransactOpts, backend bind.ContractBackend, owner common.Address, harddepositTimeout time.Duration) (common.Address, Contract, *types.Transaction, error) {
 	addr, tx, s, err := contract.DeploySimpleSwap(auth, backend, owner, big.NewInt(int64(harddepositTimeout)))
-	c := simpleContract{instance: s}
+	c := simpleContract{instance: s, address: addr}
 	return addr, c, tx, err
 }
 
@@ -57,30 +57,31 @@ func Deploy(auth *bind.TransactOpts, backend bind.ContractBackend, owner common.
 // This function is needed to communicate with remote Swap contracts (e.g. sending a cheque)
 func InstanceAt(address common.Address, backend bind.ContractBackend) (Contract, error) {
 	simple, err := contract.NewSimpleSwap(address, backend)
-	c := simpleContract{instance: simple}
+	c := simpleContract{instance: simple, address: address}
 	return c, err
 }
 
 // Contract interface defines the methods exported from the underlying go-bindings for the smart contract
 type Contract interface {
-	// SubmitChequeBeneficiary submits a cheque to a given beneficiary
-	SubmitChequeBeneficiary(opts *bind.TransactOpts, backend Backend, serial *big.Int, amount *big.Int, timeout *big.Int, ownerSig []byte) (*types.Receipt, error)
 	// CashChequeBeneficiary cashes the cheque by the beneficiary
-	CashChequeBeneficiary(auth *bind.TransactOpts, backend Backend, beneficiary common.Address, requestPayout *big.Int) (*types.Receipt, error)
+	CashChequeBeneficiary(auth *bind.TransactOpts, backend Backend, beneficiary common.Address, cumulativePayout *big.Int, ownerSig []byte) (*CashChequeResult, *types.Receipt, error)
 	// ContractParams returns contract info (e.g. deployed address)
 	ContractParams() *Params
 	// Issuer returns the contract owner from the blockchain
 	Issuer(opts *bind.CallOpts) (common.Address, error)
-	// Cheques returns the last cheque for the given address
-	Cheques(opts *bind.CallOpts, addr common.Address) (*ChequeResult, error)
+	// PaidOut returns the total paid out amount for the given address
+	PaidOut(opts *bind.CallOpts, addr common.Address) (*big.Int, error)
 }
 
-// ChequeResult is needed because the underlying `Cheques` method returns an untyped struct
-type ChequeResult struct {
-	Serial      *big.Int
-	Amount      *big.Int
-	PaidOut     *big.Int
-	CashTimeout *big.Int
+// CashChequeResult summarizes the result of a CashCheque or CashChequeBeneficiary call
+type CashChequeResult struct {
+	Beneficiary      common.Address // beneficiary of the cheque
+	Recipient        common.Address // address which received the funds
+	Caller           common.Address // caller of cashCheque
+	TotalPayout      *big.Int       // total amount that was paid out in this call
+	CumulativePayout *big.Int       // cumulative payout of the cheque that was cashed
+	CallerPayout     *big.Int       // payout for the caller of cashCheque
+	Bounced          bool           // indicates wether parts of the cheque bounced
 }
 
 // Params encapsulates some contract parameters (currently mostly informational)
@@ -95,7 +96,7 @@ func ValidateCode(ctx context.Context, b bind.ContractBackend, address common.Ad
 	if err != nil {
 		return err
 	}
-	referenceCode := common.FromHex(contract.ContractDeployedCode)
+	referenceCode := common.FromHex(contract.SimpleSwapDeployedCode)
 	if !bytes.Equal(codeReadFromAddress, referenceCode) {
 		return ErrNotASwapContract
 	}
@@ -122,6 +123,7 @@ func waitForTx(auth *bind.TransactOpts, backend Backend, tx *types.Transaction)
 
 type simpleContract struct {
 	instance *contract.SimpleSwap
+	address  common.Address
 }
 
 // ContractParams returns contract information
@@ -132,40 +134,46 @@ func (s simpleContract) ContractParams() *Params {
 	}
 }
 
-// Cheques returns the last cheque from the smart contract
-func (s simpleContract) Cheques(opts *bind.CallOpts, addr common.Address) (*ChequeResult, error) {
-	r, err := s.instance.Cheques(opts, addr)
-	if err != nil {
-		return nil, err
-	}
-	result := &ChequeResult{
-		Serial:      r.Serial,
-		Amount:      r.Amount,
-		PaidOut:     r.PaidOut,
-		CashTimeout: r.CashTimeout,
-	}
-	return result, nil
+// PaidOut returns the total paid out amount for the given address
+func (s simpleContract) PaidOut(opts *bind.CallOpts, addr common.Address) (*big.Int, error) {
+	return s.instance.PaidOut(opts, addr)
 }
 
 // Issuer returns the contract owner from the blockchain
 func (s simpleContract) Issuer(opts *bind.CallOpts) (common.Address, error) {
 	return s.instance.Issuer(opts)
 }
 
-// SubmitChequeBeneficiary prepares to send a call to submitChequeBeneficiary and blocks until the transaction is mined.
-func (s simpleContract) SubmitChequeBeneficiary(auth *bind.TransactOpts, backend Backend, serial *big.Int, amount *big.Int, timeout *big.Int, ownerSig []byte) (*types.Receipt, error) {
-	tx, err := s.instance.SubmitChequeBeneficiary(auth, serial, amount, timeout, ownerSig)
+// CashChequeBeneficiary cashes the cheque on the blockchain and blocks until the transaction is mined.
+func (s simpleContract) CashChequeBeneficiary(auth *bind.TransactOpts, backend Backend, beneficiary common.Address, cumulativePayout *big.Int, ownerSig []byte) (*CashChequeResult, *types.Receipt, error) {
+	tx, err := s.instance.CashChequeBeneficiary(auth, beneficiary, cumulativePayout, ownerSig)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
-	return WaitFunc(auth, backend, tx)
-}
-
-// CashChequeBeneficiary cashes the cheque.
-func (s simpleContract) CashChequeBeneficiary(auth *bind.TransactOpts, backend Backend, beneficiary common.Address, requestPayout *big.Int) (*types.Receipt, error) {
-	tx, err := s.instance.CashChequeBeneficiary(auth, beneficiary, requestPayout)
+	receipt, err := WaitFunc(auth, backend, tx)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
+	}
+
+	result := &CashChequeResult{
+		Bounced: false,
 	}
-	return WaitFunc(auth, backend, tx)
+
+	for _, log := range receipt.Logs {
+		if log.Address != s.address {
+			continue
+		}
+		if event, err := s.instance.ParseChequeCashed(*log); err == nil {
+			result.Beneficiary = event.Beneficiary
+			result.Caller = event.Caller
+			result.CallerPayout = event.CallerPayout
+			result.TotalPayout = event.TotalPayout
+			result.CumulativePayout = event.CumulativePayout
+			result.Recipient = event.Recipient
+		} else if _, err := s.instance.ParseChequeBounced(*log); err == nil {
+			result.Bounced = true
+		}
+	}
+
+	return result, receipt, nil
 }

contracts/swap/swap.go

@@ -26,6 +26,7 @@ require (
 	github.com/edsrzf/mmap-go v0.0.0-20160512033002-935e0e8a636c // indirect
 	github.com/elastic/gosigar v0.0.0-20180330100440-37f05ff46ffa // indirect
 	github.com/ethereum/go-ethereum v1.9.2
+	github.com/ethersphere/go-sw3 v0.1.0
 	github.com/fatih/color v1.7.0 // indirect
 	github.com/fjl/memsize v0.0.0-20180418122429-ca190fb6ffbc
 	github.com/gballet/go-libpcsclite v0.0.0-20190528105824-2fd9b619dd3c // indirect

go.mod

@@ -62,6 +62,8 @@ github.com/elastic/gosigar v0.0.0-20180330100440-37f05ff46ffa/go.mod h1:cdorVVzy
 github.com/elazarl/goproxy v0.0.0-20170405201442-c4fc26588b6e/go.mod h1:/Zj4wYkgs4iZTTu3o/KG3Itv/qCCa8VVMlb3i9OVuzc=
 github.com/ethereum/go-ethereum v1.9.2 h1:RMIHDO/diqXEgORSVzYx8xW9x2+S32PoAX5lQwya0Lw=
 github.com/ethereum/go-ethereum v1.9.2/go.mod h1:PwpWDrCLZrV+tfrhqqF6kPknbISMHaJv9Ln3kPCZLwY=
+github.com/ethersphere/go-sw3 v0.1.0 h1:XMaWxiBhFtrxfOel2tXmxuan3eCfFw/NcftV6sUVtIc=
+github.com/ethersphere/go-sw3 v0.1.0/go.mod h1:HukT0aZ6QdW/d7zuD/0g5xlw6ewu9QeqHojxLDsaERQ=
 github.com/evanphx/json-patch v4.2.0+incompatible/go.mod h1:50XU6AFN0ol/bzJsmQLiYLvXMP4fmwYFNcr97nuDLSk=
 github.com/fatih/color v1.7.0 h1:DkWD4oS2D8LGGgTQ6IvwJJXSL5Vp2ffcQg58nFV38Ys=
 github.com/fatih/color v1.7.0/go.mod h1:Zm6kSWBoL9eyXnKyktHP6abPY2pDugNf5KwzbycvMj4=

go.sum

@@ -26,28 +26,21 @@ import (
 	"github.com/ethereum/go-ethereum/crypto"
 )
 
-// encodeForSignature encodes the cheque in the format used in the signing procedure
-func (cheque *Cheque) encodeForSignature() []byte {
-	serialBytes := make([]byte, 32)
-	amountBytes := make([]byte, 32)
-	timeoutBytes := make([]byte, 32)
+// encodeForSignature encodes the cheque params in the format used in the signing procedure
+func (cheque *ChequeParams) encodeForSignature() []byte {
+	cumulativePayoutBytes := make([]byte, 32)
 	// we need to write the last 8 bytes as we write a uint64 into a 32-byte array
 	// encoded in BigEndian because EVM uses BigEndian encoding
-	binary.BigEndian.PutUint64(serialBytes[24:], cheque.Serial)
-	binary.BigEndian.PutUint64(amountBytes[24:], cheque.Amount)
-	binary.BigEndian.PutUint64(timeoutBytes[24:], cheque.Timeout)
+	binary.BigEndian.PutUint64(cumulativePayoutBytes[24:], cheque.CumulativePayout)
 	// construct the actual cheque
 	input := cheque.Contract.Bytes()
 	input = append(input, cheque.Beneficiary.Bytes()...)
-	input = append(input, serialBytes[:]...)
-	input = append(input, amountBytes[:]...)
-	input = append(input, timeoutBytes[:]...)
-
+	input = append(input, cumulativePayoutBytes[:]...)
 	return input
 }
 
-// sigHash hashes the cheque using the prefix that would be added by eth_Sign
-func (cheque *Cheque) sigHash() []byte {
+// sigHash hashes the cheque params using the prefix that would be added by eth_Sign
+func (cheque *ChequeParams) sigHash() []byte {
 	// we can ignore the error because it is always nil
 	encoded := cheque.encodeForSignature()
 	input := crypto.Keccak256(encoded)
@@ -84,7 +77,7 @@ func (cheque *Cheque) VerifySig(expectedSigner common.Address) error {
 }
 
 // Sign returns the cheque's signature with supplied private key
-func (cheque *Cheque) Sign(prv *ecdsa.PrivateKey) ([]byte, error) {
+func (cheque *ChequeParams) Sign(prv *ecdsa.PrivateKey) ([]byte, error) {
 	sig, err := crypto.Sign(cheque.sigHash(), prv)
 	if err != nil {
 		return nil, err
@@ -97,19 +90,11 @@ func (cheque *Cheque) Sign(prv *ecdsa.PrivateKey) ([]byte, error) {
 
 // Equal checks if other has the same fields
 func (cheque *Cheque) Equal(other *Cheque) bool {
-	if cheque.Serial != other.Serial {
-		return false
-	}
-
 	if cheque.Beneficiary != other.Beneficiary {
 		return false
 	}
 
-	if cheque.Amount != other.Amount {
-		return false
-	}
-
-	if cheque.Timeout != other.Timeout {
+	if cheque.CumulativePayout != other.CumulativePayout {
 		return false
 	}
 
@@ -140,29 +125,20 @@ func (cheque *Cheque) verifyChequeProperties(p *Peer, expectedBeneficiary common
 		return fmt.Errorf("wrong cheque parameters: expected beneficiary: %x, was: %x", expectedBeneficiary, cheque.Beneficiary)
 	}
 
-	if cheque.Timeout != 0 {
-		return fmt.Errorf("wrong cheque parameters: expected timeout to be 0, was: %d", cheque.Timeout)
-	}
-
 	return nil
 }
 
-// verifyChequeAgainstLast verifies that serial and amount are higher than in the previous cheque
-// furthermore it cheques that the increase in amount is as expected
+// verifyChequeAgainstLast verifies that the amount is higher than in the previous cheque and the increase is as expected
 // returns the actual amount received in this cheque
 func (cheque *Cheque) verifyChequeAgainstLast(lastCheque *Cheque, expectedAmount uint64) (uint64, error) {
-	actualAmount := cheque.Amount
+	actualAmount := cheque.CumulativePayout
 
 	if lastCheque != nil {
-		if cheque.Serial <= lastCheque.Serial {
-			return 0, fmt.Errorf("wrong cheque parameters: expected serial larger than %d, was: %d", lastCheque.Serial, cheque.Serial)
-		}
-
-		if cheque.Amount <= lastCheque.Amount {
-			return 0, fmt.Errorf("wrong cheque parameters: expected amount larger than %d, was: %d", lastCheque.Amount, cheque.Amount)
+		if cheque.CumulativePayout <= lastCheque.CumulativePayout {
+			return 0, fmt.Errorf("wrong cheque parameters: expected cumulative payout larger than %d, was: %d", lastCheque.CumulativePayout, cheque.CumulativePayout)
 		}
 
-		actualAmount -= lastCheque.Amount
+		actualAmount -= lastCheque.CumulativePayout
 	}
 
 	if expectedAmount != actualAmount {

swap/cheque.go

@@ -30,8 +30,6 @@ const (
 	deployRetries               = 5
 	// delay between retries
 	deployDelay = 1 * time.Second
-	// Should be non-zero once we implement waivers
-	defaultCashInDelay = uint64(0)
 	// This is the amount of time in seconds which an issuer has to wait to decrease the harddeposit of a beneficiary.
 	// The smart-contract allows for setting this variable differently per beneficiary
 	defaultHarddepositTimeoutDuration = 24 * time.Hour

swap/config.go

@@ -146,12 +146,11 @@ func TestEmitCheque(t *testing.T) {
 	log.Debug("create a cheque")
 	cheque := &Cheque{
 		ChequeParams: ChequeParams{
-			Contract:    debitorSwap.owner.Contract,
-			Beneficiary: creditorSwap.owner.address,
-			Amount:      42,
-			Honey:       42,
-			Timeout:     0,
+			Contract:         debitorSwap.owner.Contract,
+			Beneficiary:      creditorSwap.owner.address,
+			CumulativePayout: 42,
 		},
+		Honey: 42,
 	}
 	cheque.Signature, err = cheque.Sign(debitorSwap.owner.privateKey)
 	if err != nil {
@@ -166,17 +165,17 @@ func TestEmitCheque(t *testing.T) {
 	defer cleanup()
 
 	// now we need to create the channel...
-	testBackend.submitDone = make(chan struct{})
+	testBackend.cashDone = make(chan struct{})
 	err = creditorSwap.handleEmitChequeMsg(ctx, debitor, emitMsg)
 	if err != nil {
 		t.Fatal(err)
 	}
-	// ...on which we wait until the submitChequeAndCash is actually terminated (ensures proper nounce count)
+	// ...on which we wait until the cashCheque is actually terminated (ensures proper nounce count)
 	select {
-	case <-testBackend.submitDone:
-		log.Debug("submit and cash transactions completed and committed")
+	case <-testBackend.cashDone:
+		log.Debug("cash transaction completed and committed")
 	case <-time.After(4 * time.Second):
-		t.Fatalf("Timeout waiting for submit and cash transactions to complete")
+		t.Fatalf("Timeout waiting for cash transaction to complete")
 	}
 	log.Debug("balance", "balance", creditorSwap.balances[debitor.ID()])
 	// check that the balance has been reset
@@ -235,10 +234,23 @@ func TestTriggerPaymentThreshold(t *testing.T) {
 	}
 	cheque := debitorSwap.cheques[creditor.ID()]
 	expectedAmount := uint64(overDraft) + DefaultPaymentThreshold
-	if cheque.Amount != expectedAmount {
-		t.Fatalf("Expected cheque amount to be %d, but is %d", expectedAmount, cheque.Amount)
+	if cheque.CumulativePayout != expectedAmount {
+		t.Fatalf("Expected cheque cumulative payout to be %d, but is %d", expectedAmount, cheque.CumulativePayout)
 	}
 
+	// because no other accounting took place in the meantime the balance should be exactly 0
+	if debitorSwap.balances[creditor.ID()] != 0 {
+		t.Fatalf("Expected debitorSwap balance to be 0, but is %d", debitorSwap.balances[creditor.ID()])
+	}
+
+	// do some accounting again to trigger a second cheque
+	if err = debitorSwap.Add(int64(-DefaultPaymentThreshold), creditor.Peer); err != nil {
+		t.Fatal(err)
+	}
+
+	if debitorSwap.balances[creditor.ID()] != 0 {
+		t.Fatalf("Expected debitorSwap balance to be 0, but is %d", debitorSwap.balances[creditor.ID()])
+	}
 }
 
 // TestTriggerDisconnectThreshold is to test that no further accounting takes place