swap, swap/chain, contracts/swap: add transaction queue

contracts/swap/swap.go

@@ -22,7 +22,9 @@ package swap
 import (
 	"fmt"
 	"math/big"
+	"strings"
 
+	"github.com/ethereum/go-ethereum/accounts/abi"
 	"github.com/ethereum/go-ethereum/accounts/abi/bind"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/types"
@@ -37,8 +39,8 @@ type Contract interface {
 	Withdraw(auth *bind.TransactOpts, amount *big.Int) (*types.Receipt, error)
 	// Deposit sends a raw transaction to the chequebook, triggering the fallback—depositing amount
 	Deposit(auth *bind.TransactOpts, amout *big.Int) (*types.Receipt, error)
-	// CashChequeBeneficiaryStart sends the transaction to cash a cheque as the beneficiary
-	CashChequeBeneficiaryStart(opts *bind.TransactOpts, beneficiary common.Address, cumulativePayout *uint256.Uint256, ownerSig []byte) (*types.Transaction, error)
+	// CashChequeBeneficiaryRequest generates a TxRequest for a CashChequeBeneficiary transaction
+	CashChequeBeneficiaryRequest(beneficiary common.Address, cumulativePayout *uint256.Uint256, ownerSig []byte) (*chain.TxRequest, error)
 	// CashChequeBeneficiaryResult processes the receipt from a CashChequeBeneficiary transaction
 	CashChequeBeneficiaryResult(receipt *types.Receipt) *CashChequeResult
 	// LiquidBalance returns the LiquidBalance (total balance in ERC20-token - total hard deposits in ERC20-token) of the chequebook
@@ -75,19 +77,30 @@ type Params struct {
 
 type simpleContract struct {
 	instance *contract.ERC20SimpleSwap
+	abi      abi.ABI
 	address  common.Address
 	backend  chain.Backend
 }
 
 // InstanceAt creates a new instance of a contract at a specific address.
-// It assumes that there is an existing contract instance at the given address, or an error is returned
+// It assumes that there is an existing contract instance at the given address
 // This function is needed to communicate with remote Swap contracts (e.g. sending a cheque)
 func InstanceAt(address common.Address, backend chain.Backend) (Contract, error) {
 	instance, err := contract.NewERC20SimpleSwap(address, backend)
 	if err != nil {
 		return nil, err
 	}
-	c := simpleContract{instance: instance, address: address, backend: backend}
+
+	contractABI, err := abi.JSON(strings.NewReader(contract.ERC20SimpleSwapABI))
+	if err != nil {
+		return nil, err
+	}
+	c := simpleContract{
+		abi:      contractABI,
+		instance: instance,
+		address:  address,
+		backend:  backend,
+	}
 	return c, err
 }
 
@@ -130,15 +143,19 @@ func (s simpleContract) Deposit(auth *bind.TransactOpts, amount *big.Int) (*type
 	return chain.WaitMined(auth.Context, s.backend, tx.Hash())
 }
 
-// CashChequeBeneficiaryStart sends the transaction to cash a cheque as the beneficiary
-func (s simpleContract) CashChequeBeneficiaryStart(opts *bind.TransactOpts, beneficiary common.Address, cumulativePayout *uint256.Uint256, ownerSig []byte) (*types.Transaction, error) {
+// CashChequeBeneficiaryRequest generates a TxRequest for a CashChequeBeneficiary transaction
+func (s simpleContract) CashChequeBeneficiaryRequest(beneficiary common.Address, cumulativePayout *uint256.Uint256, ownerSig []byte) (*chain.TxRequest, error) {
 	payout := cumulativePayout.Value()
-	// send a copy of cumulativePayout to instance as it modifies the supplied big int internally
-	tx, err := s.instance.CashChequeBeneficiary(opts, beneficiary, big.NewInt(0).Set(&payout), ownerSig)
+	callData, err := s.abi.Pack("cashChequeBeneficiary", beneficiary, big.NewInt(0).Set(&payout), ownerSig)
 	if err != nil {
 		return nil, err
 	}
-	return tx, nil
+
+	return &chain.TxRequest{
+		To:    s.address,
+		Value: big.NewInt(0),
+		Data:  callData,
+	}, nil
 }
 
 // CashChequeBeneficiaryResult processes the receipt from a CashChequeBeneficiary transaction

swap/cashout.go

@@ -22,6 +22,7 @@ import (
 
 	"github.com/ethereum/go-ethereum/accounts/abi/bind"
 	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/metrics"
 	contract "github.com/ethersphere/swarm/contracts/swap"
 	"github.com/ethersphere/swarm/swap/chain"
@@ -31,58 +32,117 @@ import (
 // CashChequeBeneficiaryTransactionCost is the expected gas cost of a CashChequeBeneficiary transaction
 const CashChequeBeneficiaryTransactionCost = 50000
 
-// CashoutProcessor holds all relevant fields needed for processing cashouts
-type CashoutProcessor struct {
-	backend    chain.Backend     // ethereum backend to use
-	privateKey *ecdsa.PrivateKey // private key to use
-	Logger     Logger
-}
+// CashoutRequestHandlerID is the handlerID used by the CashoutProcessor for CashoutRequests
+const CashoutRequestHandlerID = "CashoutProcessor_CashoutRequest"
 
 // CashoutRequest represents a request for a cashout operation
 type CashoutRequest struct {
 	Cheque      Cheque         // cheque to be cashed
 	Destination common.Address // destination for the payout
-	Logger      Logger
 }
 
-// ActiveCashout stores the necessary information for a cashout in progess
-type ActiveCashout struct {
-	Request         CashoutRequest // the request that caused this cashout
-	TransactionHash common.Hash    // the hash of the current transaction for this request
-	Logger          Logger
+// CashoutProcessor holds all relevant fields needed for processing cashouts
+type CashoutProcessor struct {
+	backend              chain.Backend     // ethereum backend to use
+	txScheduler          chain.TxScheduler // transaction queue to use
+	cashoutResultHandler CashoutResultHandler
+	logger               Logger
+}
+
+// CashoutResultHandler is an interface which accepts CashChequeResults from a CashoutProcessor
+type CashoutResultHandler interface {
+	// Called by the CashoutProcessor when a CashoutRequest was successfully executed
+	// It will be called again if an error is returned
+	HandleCashoutResult(request *CashoutRequest, result *contract.CashChequeResult, receipt *types.Receipt) error
 }
 
 // newCashoutProcessor creates a new instance of CashoutProcessor
-func newCashoutProcessor(backend chain.Backend, privateKey *ecdsa.PrivateKey) *CashoutProcessor {
-	return &CashoutProcessor{
-		backend:    backend,
-		privateKey: privateKey,
+func newCashoutProcessor(txScheduler chain.TxScheduler, backend chain.Backend, privateKey *ecdsa.PrivateKey, cashoutResultHandler CashoutResultHandler, logger Logger) *CashoutProcessor {
+	c := &CashoutProcessor{
+		backend:              backend,
+		txScheduler:          txScheduler,
+		cashoutResultHandler: cashoutResultHandler,
+		logger:               logger,
 	}
-}
 
-// cashCheque tries to cash the cheque specified in the request
-// after the transaction is sent it waits on its success
-func (c *CashoutProcessor) cashCheque(ctx context.Context, request *CashoutRequest) error {
-	cheque := request.Cheque
-	opts := bind.NewKeyedTransactor(c.privateKey)
-	opts.Context = ctx
+	txScheduler.SetHandlers(CashoutRequestHandlerID, &chain.TxRequestHandlers{
+		NotifyReceipt: func(ctx context.Context, id uint64, notification *chain.TxReceiptNotification) error {
+			var request *CashoutRequest
+			err := c.txScheduler.GetExtraData(id, &request)
+			if err != nil {
+				return err
+			}
+
+			otherSwap, err := contract.InstanceAt(request.Cheque.Contract, c.backend)
+			if err != nil {
+				return err
+			}
+
+			receipt := &notification.Receipt
+			if receipt.Status == 0 {
+				c.logger.Error(CashChequeAction, "cheque cashing transaction reverted", "tx", receipt.TxHash)
+				return nil
+			}
+
+			result := otherSwap.CashChequeBeneficiaryResult(receipt)
+			return c.cashoutResultHandler.HandleCashoutResult(request, result, receipt)
+		},
+		NotifyPending: func(ctx context.Context, id uint64, notification *chain.TxPendingNotification) error {
+			c.logger.Debug(CashChequeAction, "cheque cashing transaction sent", "hash", notification.Transaction.Hash())
+			return nil
+		},
+		NotifyCancelled: func(ctx context.Context, id uint64, notification *chain.TxCancelledNotification) error {
+			c.logger.Warn(CashChequeAction, "cheque cashing transaction cancelled", "reason", notification.Reason)
+			return nil
+		},
+		NotifyStatusUnknown: func(ctx context.Context, id uint64, notification *chain.TxStatusUnknownNotification) error {
+			c.logger.Error(CashChequeAction, "cheque cashing transaction status unknown", "reason", notification.Reason)
+			return nil
+		},
+	})
+	return c
+}
 
-	otherSwap, err := contract.InstanceAt(cheque.Contract, c.backend)
+// submitCheque submits a cheque for cashout
+// the cheque might not be cashed if it is not deemed profitable
+func (c *CashoutProcessor) submitCheque(ctx context.Context, request *CashoutRequest) {
+	expectedPayout, transactionCosts, err := c.estimatePayout(ctx, &request.Cheque)
 	if err != nil {
-		return err
+		c.logger.Error(CashChequeAction, "could not estimate payout", "error", err)
+		return
 	}
 
-	tx, err := otherSwap.CashChequeBeneficiaryStart(opts, request.Destination, cheque.CumulativePayout, cheque.Signature)
+	costsMultiplier := uint256.FromUint64(2)
+	costThreshold, err := uint256.New().Mul(transactionCosts, costsMultiplier)
 	if err != nil {
-		return err
+		c.logger.Error(CashChequeAction, "overflow in transaction fee", "error", err)
+		return
 	}
 
-	// this blocks until the cashout has been successfully processed
-	return c.waitForAndProcessActiveCashout(&ActiveCashout{
-		Request:         *request,
-		TransactionHash: tx.Hash(),
-		Logger:          request.Logger,
-	})
+	// do a payout transaction if we get more than 2 times the gas costs
+	if expectedPayout.Cmp(costThreshold) == 1 {
+		c.logger.Info(CashChequeAction, "queueing cashout", "cheque", &request.Cheque)
+
+		cheque := request.Cheque
+		otherSwap, err := contract.InstanceAt(cheque.Contract, c.backend)
+		if err != nil {
+			c.logger.Error(CashChequeAction, "could not get swap instance", "error", err)
+			return
+		}
+
+		txRequest, err := otherSwap.CashChequeBeneficiaryRequest(cheque.Beneficiary, cheque.CumulativePayout, cheque.Signature)
+		if err != nil {
+			metrics.GetOrRegisterCounter("swap/cheques/cashed/errors", nil).Inc(1)
+			c.logger.Error(CashChequeAction, "cashing cheque:", "error", err)
+			return
+		}
+
+		_, err = c.txScheduler.ScheduleRequest(CashoutRequestHandlerID, *txRequest, request)
+		if err != nil {
+			metrics.GetOrRegisterCounter("swap/cheques/cashed/errors", nil).Inc(1)
+			c.logger.Error(CashChequeAction, "cashing cheque:", "error", err)
+		}
+	}
 }
 
 // estimatePayout estimates the payout for a given cheque as well as the transaction cost
@@ -128,31 +188,3 @@ func (c *CashoutProcessor) estimatePayout(ctx context.Context, cheque *Cheque) (
 
 	return expectedPayout, transactionCosts, nil
 }
-
-// waitForAndProcessActiveCashout waits for activeCashout to complete
-func (c *CashoutProcessor) waitForAndProcessActiveCashout(activeCashout *ActiveCashout) error {
-	ctx, cancel := context.WithTimeout(context.Background(), DefaultTransactionTimeout)
-	defer cancel()
-
-	receipt, err := chain.WaitMined(ctx, c.backend, activeCashout.TransactionHash)
-	if err != nil {
-		return err
-	}
-
-	otherSwap, err := contract.InstanceAt(activeCashout.Request.Cheque.Contract, c.backend)
-	if err != nil {
-		return err
-	}
-
-	result := otherSwap.CashChequeBeneficiaryResult(receipt)
-
-	metrics.GetOrRegisterCounter("swap/cheques/cashed/honey", nil).Inc(result.TotalPayout.Int64())
-
-	if result.Bounced {
-		metrics.GetOrRegisterCounter("swap/cheques/cashed/bounced", nil).Inc(1)
-		activeCashout.Logger.Warn(CashChequeAction, "cheque bounced", "tx", receipt.TxHash)
-	}
-
-	activeCashout.Logger.Info(CashChequeAction, "cheque cashed", "honey", activeCashout.Request.Cheque.Honey)
-	return nil
-}