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

@@ -62,6 +62,7 @@ type Swap struct {
 	backend          contract.Backend   // the backend (blockchain) used
 	owner            *Owner             // contract access
 	params           *Params            // economic and operational parameters
+	backendNetworkID uint64             // backend network ID used by SWAP to settle payments
 	contract         swap.Contract      // reference to the smart contract
 	honeyPriceOracle HoneyOracle        // oracle which resolves the price of honey (in Wei)
 }
@@ -75,10 +76,9 @@ type Owner struct {
 
 // Params encapsulates param
 type Params struct {
-	LogPath              string // optional audit log path
-	InitialDepositAmount uint64 // initial deposit amount for the chequebook
-	PaymentThreshold     int64  // honey amount at which a payment is triggered
-	DisconnectThreshold  int64  // honey amount at which a peer disconnects
+	LogPath             string // optional audit log path
+	PaymentThreshold    int64  // honey amount at which a payment is triggered
+	DisconnectThreshold int64  // honey amount at which a peer disconnects
 }
 
 // newLogger returns a new logger
@@ -120,14 +120,15 @@ func swapRotatingFileHandler(logdir string) (log.Handler, error) {
 }
 
 // new - swap constructor without integrity check
-func new(stateStore state.Store, prvkey *ecdsa.PrivateKey, backend contract.Backend, params *Params) *Swap {
+func new(stateStore state.Store, prvkey *ecdsa.PrivateKey, backend contract.Backend, params *Params, backendNetworkID uint64) *Swap {
 	auditLog = newLogger(params.LogPath)
 	return &Swap{
 		store:            stateStore,
 		peers:            make(map[enode.ID]*Peer),
 		backend:          backend,
 		owner:            createOwner(prvkey),
 		params:           params,
+		backendNetworkID: backendNetworkID,
 		honeyPriceOracle: NewHoneyPriceOracle(),
 	}
 }
@@ -142,50 +143,57 @@ func New(dbPath string, prvkey *ecdsa.PrivateKey, backendURL string, params *Par
 	// 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 params.DisconnectThreshold <= params.PaymentThreshold {
 		return nil, fmt.Errorf("swap init error: disconnect threshold lower or at payment threshold. DisconnectThreshold: %d, PaymentThreshold: %d", params.DisconnectThreshold, params.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)
 	}
-
-	// we may not need this check, and we could maybe even get rid of this constant completely
-	if params != nil && params.InitialDepositAmount == 0 {
-		// need to prompt user for initial deposit amount
-		// if 0, can not cash in cheques
-		prompter := console.Stdin
-
-		// ask user for input
-		input, err := prompter.PromptInput("Please provide the amount in Wei which will deposited to your chequebook upon deployment: ")
-		if err != nil {
-			return nil, err
-		}
-		// check input
-		val, err := strconv.ParseInt(input, 10, 64)
+	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 {
-			// maybe we should provide a fallback here? A bad input results in stopping the boot
-			return nil, fmt.Errorf("Conversion error while reading user input: %v", err)
+			return nil, fmt.Errorf("swap init error: error writing current backend networkID to statestore: %v", err)
 		}
-		log.Info("Chequebook initial deposit amount: ", "amount", val)
-		params.InitialDepositAmount = uint64(val)
+		log.Info("SWAP initialized on backend network ID", "ID", networkID.Uint64())
 	}
-
-	swap := new(
+	return new(
 		stateStore,
 		prvkey,
 		backend,
-		params)
-
-	return swap, nil
+		params,
+		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
@@ -217,11 +225,6 @@ func createOwner(prvkey *ecdsa.PrivateKey) *Owner {
 	}
 }
 
-// DeploySuccess is for convenience log output
-func (s *Swap) DeploySuccess() string {
-	return fmt.Sprintf("contract: %s, owner: %s, deposit: %v, signer: %x", s.GetParams().ContractAddress.Hex(), s.owner.address.Hex(), s.params.InitialDepositAmount, s.owner.publicKey)
-}
-
 // Add is the (sole) accounting function
 // Swap implements the protocols.Balance interface
 func (s *Swap) Add(amount int64, peer *protocols.Peer) (err error) {
@@ -457,51 +460,83 @@ 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
+func promptInitialDepositAmount() (uint64, error) {
+	// need to prompt user for initial deposit amount
+	// if 0, can not cash in cheques
+	prompter := console.Stdin
+
+	// ask user for input
+	input, err := prompter.PromptInput("Please provide the amount in Wei which will deposited to your chequebook upon deployment: ")
+	if err != nil {
+		return 0, err
+	}
+	// check input
+	val, err := strconv.ParseInt(input, 10, 64)
+	if err != nil {
+		// maybe we should provide a fallback here? A bad input results in stopping the boot
+		return 0, fmt.Errorf("Conversion error while reading user input: %v", err)
+	}
+	return uint64(val), nil
+}
+
+// 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, initialDepositAmount uint64) 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{}) {
+		var toDeposit = initialDepositAmount
+		if toDeposit == 0 {
+			toDeposit, err = promptInitialDepositAmount()
+			if err != nil {
+				return err
+			}
 		}
-		log.Info("Using the provided chequebook", "chequebookAddr", chequebookAddr)
-	} else {
-		if err := s.Deploy(context.Background()); err != nil {
-			return err
+		chequebook, err := s.Deploy(context.TODO(), toDeposit)
+		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
+	// 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, initialDepositAmount uint64) (common.Address, error) {
 	opts := bind.NewKeyedTransactor(s.owner.privateKey)
 	// initial topup value
-	opts.Value = big.NewInt(int64(s.params.InitialDepositAmount))
+	opts.Value = big.NewInt(int64(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(), "deposit", opts.Value)
+	return s.deployLoop(opts, s.owner.address, defaultHarddepositTimeoutDuration)
 }
 
 // deployLoop repeatedly tries to deploy the swap contract .
@@ -512,8 +547,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 {
@@ -524,3 +559,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)
+}