swap: chequebook persistence

contracts/swap/swap.go

@@ -45,22 +45,6 @@ type Backend interface {
 	TransactionReceipt(ctx context.Context, txHash common.Hash) (*types.Receipt, error)
 }
 
-// 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) (Contract, *types.Transaction, error) {
-	addr, tx, s, err := contract.DeploySimpleSwap(auth, backend, owner, big.NewInt(int64(harddepositTimeout)))
-	c := simpleContract{instance: s, address: addr}
-	return c, tx, err
-}
-
-// 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
-// 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, address: address}
-	return c, err
-}
-
 // Contract interface defines the methods exported from the underlying go-bindings for the smart contract
 type Contract interface {
 	// CashChequeBeneficiary cashes the cheque by the beneficiary
@@ -96,6 +80,24 @@ type simpleContract struct {
 	address  common.Address
 }
 
+// Deploy deploys an instance of the underlying contract and returns its address
+func Deploy(auth *bind.TransactOpts, backend bind.ContractBackend, owner common.Address, harddepositTimeout time.Duration) (common.Address, *types.Transaction, *contract.SimpleSwap, error) {
+	addr, tx, simpleSwap, err := contract.DeploySimpleSwap(auth, backend, owner, big.NewInt(int64(harddepositTimeout)))
+	return addr, tx, simpleSwap, err
+}
+
+// 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
+// This function is needed to communicate with remote Swap contracts (e.g. sending a cheque)
+func InstanceAt(address common.Address, backend Backend) (Contract, error) {
+	simple, err := contract.NewSimpleSwap(address, backend)
+	if err != nil {
+		return nil, err
+	}
+	c := simpleContract{instance: simple, address: address}
+	return c, err
+}
+
 // 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)

swap/swap.go

@@ -64,6 +64,7 @@ type Swap struct {
 	honeyPriceOracle    HoneyOracle        // oracle which resolves the price of honey (in Wei)
 	paymentThreshold    int64              // honey amount at which a payment is triggered
 	disconnectThreshold int64              // honey amount at which a peer disconnects
+	backendNetworkID    uint64             // the backend network ID to which the node is connected
 }
 
 // Owner encapsulates information related to accessing the contract
@@ -119,7 +120,7 @@ func swapRotatingFileHandler(logdir string) (log.Handler, error) {
 }
 
 // new - swap constructor without integrity check
-func new(logpath string, stateStore state.Store, prvkey *ecdsa.PrivateKey, backend contract.Backend, disconnectThreshold uint64, paymentThreshold uint64) *Swap {
+func new(logpath string, stateStore state.Store, prvkey *ecdsa.PrivateKey, backend contract.Backend, disconnectThreshold uint64, paymentThreshold uint64, backendNetworkID uint64) *Swap {
 	auditLog = newLogger(logpath)
 	return &Swap{
 		store:               stateStore,
@@ -130,6 +131,7 @@ func new(logpath string, stateStore state.Store, prvkey *ecdsa.PrivateKey, backe
 		disconnectThreshold: int64(disconnectThreshold),
 		paymentThreshold:    int64(paymentThreshold),
 		honeyPriceOracle:    NewHoneyPriceOracle(),
+		backendNetworkID:    backendNetworkID,
 	}
 }
 
@@ -143,28 +145,60 @@ func New(logpath string, dbPath string, prvkey *ecdsa.PrivateKey, backendURL str
 	// initialize the balances store
 	stateStore, err := state.NewDBStore(filepath.Join(dbPath, "swap.db"))
 	if err != nil {
-		return nil, fmt.Errorf("swap init error: %s", err)
+		return nil, fmt.Errorf("swap init error: error initializing statestore: %v", err)
 	}
 	if disconnectThreshold <= paymentThreshold {
 		return nil, fmt.Errorf("swap init error: disconnect threshold lower or at payment threshold. DisconnectThreshold: %d, PaymentThreshold: %d", disconnectThreshold, paymentThreshold)
 	}
 	backend, err := ethclient.Dial(backendURL)
 	if err != nil {
-		return nil, fmt.Errorf("swap init error: error connecting to Ethereum API %s: %s", backendURL, err)
+		return nil, fmt.Errorf("swap init error: error connecting to Ethereum API %s: %v", backendURL, err)
 	}
+	networkID, err := backend.NetworkID(context.TODO())
+	if err != nil {
+		return nil, fmt.Errorf("swap init error: error retrieving networkID from backendURL: %v", err)
+	}
+	var usedBeforeAtNetwork uint64
+	var usedBefore bool
+	err = stateStore.Get(usedBeforeAtNetworkKey, &usedBeforeAtNetwork)
+	// error reading from database
+	if err != nil && err != state.ErrNotFound {
+		return nil, fmt.Errorf("swap init error: error querying usedBeforeAtNetwork from statestore: %v", err)
+	}
+	// read from database
+	if err == nil {
+		usedBefore = true
+	}
+	// if used before on a different network, abort
+	if usedBefore && usedBeforeAtNetwork != networkID.Uint64() {
+		return nil, fmt.Errorf("swap init error: statestore previously used on different backend network. Used before on network: %d, Attempting to connect on network %d", usedBeforeAtNetwork, networkID)
+	}
+	// put the networkID in the statestore
+	if !usedBefore {
+		err = stateStore.Put(usedBeforeAtNetworkKey, networkID.Uint64())
+		if err != nil {
+			return nil, fmt.Errorf("swap init error: error writing current backend networkID to statestore: %v", err)
+		}
+		log.Info("SWAP initialized on backend network ID", "ID", networkID.Uint64())
+	}
+
 	return new(
 		logpath,
 		stateStore,
 		prvkey,
 		backend,
 		disconnectThreshold,
-		paymentThreshold), nil
+		paymentThreshold,
+		networkID.Uint64(),
+	), nil
 }
 
 const (
-	balancePrefix        = "balance_"
-	sentChequePrefix     = "sent_cheque_"
-	receivedChequePrefix = "received_cheque_"
+	balancePrefix          = "balance_"
+	sentChequePrefix       = "sent_cheque_"
+	receivedChequePrefix   = "received_cheque_"
+	usedChequebookKey      = "used_chequebook"
+	usedBeforeAtNetworkKey = "used_before_at_network"
 )
 
 // returns the store key for retrieving a peer's balance
@@ -436,51 +470,58 @@ func (s *Swap) getContractOwner(ctx context.Context, address common.Address) (co
 	return contr.Issuer(nil)
 }
 
-// StartChequebook deploys a new instance of a chequebook if chequebookAddr is empty, otherwise it wil bind to an existing instance
-func (s *Swap) StartChequebook(chequebookAddr common.Address) error {
-	if chequebookAddr != (common.Address{}) {
-		if err := s.BindToContractAt(chequebookAddr); err != nil {
-			return err
-		}
-		log.Info("Using the provided chequebook", "chequebookAddr", chequebookAddr)
-	} else {
-		if err := s.Deploy(context.Background()); err != nil {
-			return err
+// StartChequebook start the chequebook, taking into account the chequebookAddress passed in by the user and the chequebook addresses saved on the node's database
+func (s *Swap) StartChequebook(chequebookAddrFlag common.Address) error {
+	chequebookToUse, err := s.loadChequebook()
+	// error reading from disk
+	if err != nil && err != state.ErrNotFound {
+		return fmt.Errorf("Error reading previously used chequebook: %s", err)
+	}
+	// nothing written to state disk before, no flag provided: deploying new chequebook
+	if err == state.ErrNotFound && chequebookAddrFlag == (common.Address{}) {
+		chequebook, err := s.Deploy(context.TODO())
+		if err != nil {
+			return fmt.Errorf("Error deploying chequebook: %v", err)
 		}
-		log.Info("New SWAP contract deployed", "contract info", s.DeploySuccess())
+		chequebookToUse = chequebook
 	}
-	return nil
-}
 
-// BindToContractAt binds an instance of an already existing chequebook contract at address and sets chequebookAddr
-func (s *Swap) BindToContractAt(address common.Address) (err error) {
+	// read from state, but provided flag is not the same
+	if err == nil && (chequebookAddrFlag != common.Address{} && chequebookAddrFlag != chequebookToUse) {
+		return fmt.Errorf("Attempting to connect to provided chequebook, but different chequebook used before")
+	}
+	if chequebookAddrFlag != (common.Address{}) {
+		chequebookToUse = chequebookAddrFlag
+	}
+	auditLog.Info("Using the chequebook", "chequebookAddr", chequebookToUse)
+	return s.bindToContractAt(chequebookToUse)
+}
 
+// BindToContractAt binds to an instance of an already existing chequebook contract at address
+func (s *Swap) bindToContractAt(address common.Address) (err error) {
+	// validate whether address is a chequebook
 	if err := contract.ValidateCode(context.Background(), s.backend, address); err != nil {
-		return fmt.Errorf("contract validation for %v failed: %v", address, err)
+		return fmt.Errorf("contract validation for %v failed: %v", address.Hex(), err)
 	}
+	// get the instance and save it on swap.contract
 	s.contract, err = contract.InstanceAt(address, s.backend)
 	if err != nil {
 		return err
 	}
-	return nil
+	auditLog.Info("Using the chequebook", "chequebookAddr", address, "networkID", s.backendNetworkID)
+	// saving chequebook
+	return s.saveChequebook(address)
 }
 
 // Deploy deploys the Swap contract and sets the contract address
-func (s *Swap) Deploy(ctx context.Context) error {
+func (s *Swap) Deploy(ctx context.Context) (common.Address, error) {
 	opts := bind.NewKeyedTransactor(s.owner.privateKey)
 	// initial topup value
 	opts.Value = big.NewInt(int64(s.params.InitialDepositAmount))
 	opts.Context = ctx
 
-	auditLog.Info("deploying new swap", "owner", opts.From.Hex())
-	address, err := s.deployLoop(opts, s.owner.address, defaultHarddepositTimeoutDuration)
-	if err != nil {
-		auditLog.Error("unable to deploy swap", "error", err)
-		return err
-	}
-	auditLog.Info("swap deployed", "address", address.Hex(), "owner", opts.From.Hex())
-
-	return err
+	log.Info("deploying new swap", "owner", opts.From.Hex())
+	return s.deployLoop(opts, s.owner.address, defaultHarddepositTimeoutDuration)
 }
 
 // deployLoop repeatedly tries to deploy the swap contract .
@@ -491,8 +532,8 @@ func (s *Swap) deployLoop(opts *bind.TransactOpts, owner common.Address, default
 			time.Sleep(deployDelay)
 		}
 
-		if s.contract, tx, err = contract.Deploy(opts, s.backend, owner, defaultHarddepositTimeoutDuration); err != nil {
-			auditLog.Warn("can't send chequebook deploy tx", "try", try, "error", err)
+		if addr, tx, _, err = contract.Deploy(opts, s.backend, owner, defaultHarddepositTimeoutDuration); err != nil {
+			log.Warn("can't send chequebook deploy tx", "try", try, "error", err)
 			continue
 		}
 		if addr, err = bind.WaitDeployed(opts.Context, s.backend, tx); err != nil {
@@ -503,3 +544,13 @@ func (s *Swap) deployLoop(opts *bind.TransactOpts, owner common.Address, default
 	}
 	return addr, err
 }
+
+func (s *Swap) loadChequebook() (common.Address, error) {
+	var chequebook common.Address
+	err := s.store.Get(usedChequebookKey, &chequebook)
+	return chequebook, err
+}
+
+func (s *Swap) saveChequebook(chequebook common.Address) error {
+	return s.store.Put(usedChequebookKey, chequebook)
+}