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,25 @@ type simpleContract struct {
 	address  common.Address
 }
 
+// Deploy deploys an instance of the underlying contract and returns its instance and the transaction identifier
+func Deploy(auth *bind.TransactOpts, backend bind.ContractBackend, owner common.Address, harddepositTimeout time.Duration) (Contract, *types.Transaction, error) {
+	addr, tx, instance, err := contract.DeploySimpleSwap(auth, backend, owner, big.NewInt(int64(harddepositTimeout)))
+	c := simpleContract{instance: instance, 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 Backend) (Contract, error) {
+	instance, err := contract.NewSimpleSwap(address, backend)
+	if err != nil {
+		return nil, err
+	}
+	c := simpleContract{instance: instance, 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

@@ -75,10 +75,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,74 +119,97 @@ 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 {
-	auditLog = newLogger(params.LogPath)
+func new(stateStore state.Store, owner *Owner, backend contract.Backend, params *Params, contract contract.Contract) *Swap {
 	return &Swap{
 		store:            stateStore,
 		peers:            make(map[enode.ID]*Peer),
 		backend:          backend,
-		owner:            createOwner(prvkey),
+		owner:            owner,
 		params:           params,
+		contract:         contract,
 		honeyPriceOracle: NewHoneyPriceOracle(),
 	}
 }
 
-// New - swap constructor with integrity checks
-func New(dbPath string, prvkey *ecdsa.PrivateKey, backendURL string, params *Params) (*Swap, error) {
-	// we MUST have a backend
+// New prepares and creates all fields to create a swap instance:
+// - sets up a SWAP database;
+// - verifies whether the disconnect threshold is higher than the payment threshold;
+// - connects to the blockchain backend;
+// - verifies that we have not connected SWAP before on a different blockchain backend;
+// - starts the chequebook; creates the swap instance
+func New(dbPath string, prvkey *ecdsa.PrivateKey, backendURL string, params *Params, chequebookAddressFlag common.Address, initialDepositAmountFlag uint64) (swap *Swap, err error) {
+	// auditLog for swap-logging purposes
+	auditLog = newLogger(params.LogPath)
+	// verify that backendURL is not empty
 	if backendURL == "" {
-		return nil, errors.New("swap init error: no backend URL given")
+		return nil, errors.New("no backend URL given")
 	}
-	log.Info("connecting to SWAP API", "url", backendURL)
+	auditLog.Info("connecting to SWAP API", "url", backendURL)
 	// 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)
+	var stateStore state.Store
+	if stateStore, err = state.NewDBStore(filepath.Join(dbPath, "swap.db")); err != nil {
+		return nil, fmt.Errorf("error while 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)
+		return nil, fmt.Errorf("disconnect threshold lower or at payment threshold. DisconnectThreshold: %d, PaymentThreshold: %d", params.DisconnectThreshold, params.PaymentThreshold)
 	}
+	// connect to the backend
 	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("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)
-		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)
-		}
-		log.Info("Chequebook initial deposit amount: ", "amount", val)
-		params.InitialDepositAmount = uint64(val)
+	// get the networkID of the backend
+	var networkID *big.Int
+	if networkID, err = backend.NetworkID(context.TODO()); err != nil {
+		return nil, fmt.Errorf("error retrieving networkID from backendURL: %v", err)
 	}
-
-	swap := new(
+	// verify that we have not used SWAP before on a different networkID
+	if err := checkNetworkID(networkID.Uint64(), stateStore); err != nil {
+		return nil, err
+	}
+	auditLog.Info("SWAP initialized on backend network ID", "ID", networkID.Uint64())
+	// create the owner of SWAP
+	owner := createOwner(prvkey)
+	// start the chequebook
+	var contract contract.Contract
+	if contract, err = StartChequebook(chequebookAddressFlag, initialDepositAmountFlag, stateStore, owner, backend); err != nil {
+		return nil, err
+	}
+	// create the SWAP instance
+	return new(
 		stateStore,
-		prvkey,
+		owner,
 		backend,
-		params)
-
-	return swap, nil
+		params,
+		contract,
+	), nil
 }
 
 const (
-	balancePrefix        = "balance_"
-	sentChequePrefix     = "sent_cheque_"
-	receivedChequePrefix = "received_cheque_"
+	balancePrefix          = "balance_"
+	sentChequePrefix       = "sent_cheque_"
+	receivedChequePrefix   = "received_cheque_"
+	connectedChequebookKey = "connected_chequebook"
+	connectedBlockchainKey = "connected_blockchain"
 )
 
+// checkNetworkID verifies whether we have initialized SWAP before and ensures that we are on the same backendNetworkID if this is the case
+func checkNetworkID(currentNetworkID uint64, s state.Store) (err error) {
+	var connectedBlockchain uint64
+	err = s.Get(connectedBlockchainKey, &connectedBlockchain)
+	// error reading from database
+	if err != nil && err != state.ErrNotFound {
+		return fmt.Errorf("error querying usedBeforeAtNetwork from statestore: %v", err)
+	}
+	// initialized before, but on a different networkID
+	if connectedBlockchain != currentNetworkID {
+		return fmt.Errorf("statestore previously used on different backend network. Used before on network: %d, Attempting to connect on network %d", connectedBlockchain, currentNetworkID)
+	}
+	// not initialized before
+	return s.Put(connectedBlockchainKey, currentNetworkID)
+
+}
+
 // returns the store key for retrieving a peer's balance
 func balanceKey(peer enode.ID) string {
 	return balancePrefix + peer.String()
@@ -217,11 +239,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,70 +474,110 @@ 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 starts the chequebook, taking into account the chequebookAddress passed in by the user and the chequebook addresses saved on the node's database
+func StartChequebook(chequebookAddrFlag common.Address, initialDepositAmount uint64, s state.Store, owner *Owner, backend contract.Backend) (contract contract.Contract, err error) {
+	previouslyUsedChequebook, err := loadChequebook(s)
+	// error reading from disk
+	if err != nil && err != state.ErrNotFound {
+		return nil, fmt.Errorf("Error reading previously used chequebook: %s", err)
+	}
+	// read from state, but provided flag is not the same
+	if err == nil && (chequebookAddrFlag != common.Address{} && chequebookAddrFlag != previouslyUsedChequebook) {
+		return nil, fmt.Errorf("Attempting to connect to provided chequebook, but different chequebook used before")
+	}
+	// 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 nil, err
+			}
+		}
+		if contract, err = Deploy(context.TODO(), toDeposit, owner, backend); err != nil {
+			return nil, err
 		}
-		log.Info("Using the provided chequebook", "chequebookAddr", chequebookAddr)
-	} else {
-		if err := s.Deploy(context.Background()); err != nil {
-			return err
+		if err := saveChequebook(contract.ContractParams().ContractAddress, s); err != nil {
+			return nil, err
 		}
-		log.Info("New SWAP contract deployed", "contract info", s.DeploySuccess())
+		auditLog.Info("Deployed chequebook", "contract address", contract.ContractParams().ContractAddress.Hex(), "deposit", toDeposit, "owner", owner.address)
+		// first time connecting by deploying a new chequebook
+		return contract, nil
 	}
-	return nil
+	// first time connecting with a chequebookAddress passed in
+	if chequebookAddrFlag != (common.Address{}) {
+		return bindToContractAt(chequebookAddrFlag, backend)
+	}
+	// reconnecting with contract read from statestore
+	return bindToContractAt(previouslyUsedChequebook, backend)
 }
 
-// BindToContractAt binds an instance of an already existing chequebook contract at address and sets chequebookAddr
-func (s *Swap) BindToContractAt(address common.Address) (err error) {
-
-	if err := contract.ValidateCode(context.Background(), s.backend, address); err != nil {
-		return fmt.Errorf("contract validation for %v failed: %v", address, err)
-	}
-	s.contract, err = contract.InstanceAt(address, s.backend)
-	if err != nil {
-		return err
+// BindToContractAt binds to an instance of an already existing chequebook contract at address
+func bindToContractAt(address common.Address, backend contract.Backend) (contract.Contract, error) {
+	// validate whether address is a chequebook
+	if err := contract.ValidateCode(context.Background(), backend, address); err != nil {
+		return nil, fmt.Errorf("contract validation for %v failed: %v", address.Hex(), err)
 	}
-	return nil
+	auditLog.Info("bound to chequebook", "chequebookAddr", address)
+	// get the instance
+	return contract.InstanceAt(address, backend)
 }
 
-// Deploy deploys the Swap contract and sets the contract address
-func (s *Swap) Deploy(ctx context.Context) error {
-	opts := bind.NewKeyedTransactor(s.owner.privateKey)
+// Deploy deploys the Swap contract
+func Deploy(ctx context.Context, initialDepositAmount uint64, owner *Owner, backend contract.Backend) (contract.Contract, error) {
+	opts := bind.NewKeyedTransactor(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
+	auditLog.Info("Deploying new swap", "owner", opts.From.Hex(), "deposit", opts.Value)
+	return deployLoop(opts, defaultHarddepositTimeoutDuration, owner.address, backend)
 }
 
 // deployLoop repeatedly tries to deploy the swap contract .
-func (s *Swap) deployLoop(opts *bind.TransactOpts, owner common.Address, defaultHarddepositTimeoutDuration time.Duration) (addr common.Address, err error) {
+func deployLoop(opts *bind.TransactOpts, defaultHarddepositTimeoutDuration time.Duration, owner common.Address, backend contract.Backend) (instance contract.Contract, err error) {
 	var tx *types.Transaction
 	for try := 0; try < deployRetries; try++ {
 		if try > 0 {
 			time.Sleep(deployDelay)
 		}
-
-		if s.contract, tx, err = contract.Deploy(opts, s.backend, owner, defaultHarddepositTimeoutDuration); err != nil {
+		if instance, tx, err = contract.Deploy(opts, backend, owner, defaultHarddepositTimeoutDuration); err != nil {
 			auditLog.Warn("can't send chequebook deploy tx", "try", try, "error", err)
 			continue
 		}
-		if addr, err = bind.WaitDeployed(opts.Context, s.backend, tx); err != nil {
+		if _, err := bind.WaitDeployed(opts.Context, backend, tx); err != nil {
 			auditLog.Warn("chequebook deploy error", "try", try, "error", err)
 			continue
 		}
-		return addr, nil
+		return instance, nil
 	}
-	return addr, err
+	return nil, err
+}
+
+func loadChequebook(s state.Store) (common.Address, error) {
+	var chequebook common.Address
+	err := s.Get(connectedChequebookKey, &chequebook)
+	return chequebook, err
+}
+
+func saveChequebook(chequebook common.Address, s state.Store) error {
+	return s.Put(connectedChequebookKey, chequebook)
 }