swap: use the SimpleSwapFactory for deployment and verification

api/config.go

@@ -60,6 +60,7 @@ type Config struct {
 	SwapInitialDeposit      uint64         // initial deposit amount to the chequebook
 	SwapLogPath             string         // dir to swap related audit logs
 	Contract                common.Address // address of the chequebook contract
+	SwapChequebookFactory   common.Address // address of the chequebook factory contract
 	// end of Swap configs
 
 	*network.HiveParams

cmd/swarm/config.go

@@ -65,6 +65,7 @@ const (
 	SwarmEnvPort                    = "SWARM_PORT"
 	SwarmEnvNetworkID               = "SWARM_NETWORK_ID"
 	SwarmEnvChequebookAddr          = "SWARM_CHEQUEBOOK_ADDR"
+	SwarmEnvChequebookFactoryAddr   = "SWARM_SWAP_CHEQUEBOOK_FACTORY_ADDR"
 	SwarmEnvInitialDeposit          = "SWARM_INITIAL_DEPOSIT"
 	SwarmEnvSwapEnable              = "SWARM_SWAP_ENABLE"
 	SwarmEnvSwapBackendURL          = "SWARM_SWAP_BACKEND_URL"
@@ -183,7 +184,9 @@ func flagsOverride(currentConfig *bzzapi.Config, ctx *cli.Context) *bzzapi.Confi
 	if chbookaddr := ctx.GlobalString(SwarmSwapChequebookAddrFlag.Name); chbookaddr != "" {
 		currentConfig.Contract = common.HexToAddress(chbookaddr)
 	}
-
+	if chequebookFactoryAddress := ctx.GlobalString(SwarmSwapChequebookFactoryFlag.Name); chequebookFactoryAddress != "" {
+		currentConfig.SwapChequebookFactory = common.HexToAddress(chequebookFactoryAddress)
+	}
 	networkid := ctx.GlobalUint64(SwarmNetworkIdFlag.Name)
 	if networkid != 0 && networkid != network.DefaultNetworkID {
 		currentConfig.NetworkID = networkid

cmd/swarm/flags.go

@@ -64,6 +64,11 @@ var (
 		Usage:  "SWAP chequebook contract address",
 		EnvVar: SwarmEnvChequebookAddr,
 	}
+	SwarmSwapChequebookFactoryFlag = cli.StringFlag{
+		Name:   "swap-chequebook-factory",
+		Usage:  "SWAP chequebook factory contract address",
+		EnvVar: SwarmEnvChequebookFactoryAddr,
+	}
 	SwarmSwapEnabledFlag = cli.BoolFlag{
 		Name:   "swap",
 		Usage:  "Swarm SWAP enabled (default false)",

cmd/swarm/main.go

@@ -184,6 +184,7 @@ func init() {
 		SwarmSwapPaymentThresholdFlag,
 		SwarmSwapLogPathFlag,
 		SwarmSwapChequebookAddrFlag,
+		SwarmSwapChequebookFactoryFlag,
 		SwarmSwapInitialDepositFlag,
 		// end of swap flags
 		SwarmSyncModeFlag,

contracts/swap/factory.go

@@ -0,0 +1,125 @@
+package swap
+
+import (
+	"bytes"
+	"context"
+	"errors"
+	"fmt"
+	"math/big"
+
+	"github.com/ethereum/go-ethereum/accounts/abi/bind"
+	"github.com/ethereum/go-ethereum/common"
+	chequebookFactory "github.com/ethersphere/go-sw3/contracts-v0-1-1/simpleswapfactory"
+)
+
+var (
+	// ErrNotDeployedByFactory is given when a contract was not deployed by the factory
+	ErrNotDeployedByFactory = errors.New("not deployed by factory")
+
+	// Deployments maps from network ids to deployed contract factories
+	Deployments = map[uint64]common.Address{
+		// Ropsten
+		3: common.HexToAddress("0x2e9C43E186eaF4fee10799d67e75f8CFc5BA3a0c"),
+	}
+)
+
+type simpleSwapFactory struct {
+	instance *chequebookFactory.SimpleSwapFactory
+	address  common.Address
+	backend  Backend
+}
+
+// SimpleSwapFactory interface defines the methods available for a factory contract for SimpleSwap
+type SimpleSwapFactory interface {
+	// DeploySimpleSwap deploys a new SimpleSwap contract from the factory and returns the ready to use Contract abstraction
+	DeploySimpleSwap(auth *bind.TransactOpts, issuer common.Address, defaultHardDepositTimeoutDuration *big.Int) (Contract, error)
+	// VerifyContract verifies that the supplied address was deployed by this factory
+	VerifyContract(address common.Address) error
+	// VerifySelf verifies that this is a valid factory on the network
+	VerifySelf() error
+}
+
+// FactoryAt creates a SimpleSwapFactory instance for the given address and backend
+func FactoryAt(address common.Address, backend Backend) (SimpleSwapFactory, error) {
+	simple, err := chequebookFactory.NewSimpleSwapFactory(address, backend)
+	if err != nil {
+		return nil, err
+	}
+	c := simpleSwapFactory{instance: simple, address: address, backend: backend}
+	return c, err
+}
+
+// FactoryAddressForNetwork gets the default factory address for a given network id
+func FactoryAddressForNetwork(networkID uint64) (common.Address, error) {
+	address, ok := Deployments[networkID]
+	if !ok {
+		return common.Address{}, fmt.Errorf("no known factory contract for ethereum network %d", networkID)
+	}
+	return address, nil
+}
+
+// VerifySelf verifies that this is a valid factory on the network
+func (sf simpleSwapFactory) VerifySelf() error {
+	code, err := sf.backend.CodeAt(context.Background(), sf.address, nil)
+	if err != nil {
+		return err
+	}
+
+	referenceCode := common.FromHex(chequebookFactory.SimpleSwapFactoryDeployedCode)
+	if !bytes.Equal(code, referenceCode) {
+		return errors.New("not a valid factory contract")
+	}
+
+	return nil
+}
+
+// DeploySimpleSwap deploys a new SimpleSwap contract from the factory and returns the ready to use Contract abstraction
+func (sf simpleSwapFactory) DeploySimpleSwap(auth *bind.TransactOpts, issuer common.Address, defaultHardDepositTimeoutDuration *big.Int) (Contract, error) {
+	// for some reason the automatic gas estimation is too low
+	// this value was determind by deploying through truffle and rounding up to the next 100000
+	// the deployment cost should always be constant
+	auth.GasLimit = 1700000
+	tx, err := sf.instance.DeploySimpleSwap(auth, issuer, defaultHardDepositTimeoutDuration)
+	if err != nil {
+		return nil, err
+	}
+
+	receipt, err := WaitFunc(auth, sf.backend, tx)
+	if err != nil {
+		return nil, err
+	}
+
+	// we iterate through the logs until we find the SimpleSwapDeployed event which contains the address of the new SimpleSwap contract
+	address := common.Address{}
+	for _, log := range receipt.Logs {
+		if log.Address != sf.address {
+			continue
+		}
+		if event, err := sf.instance.ParseSimpleSwapDeployed(*log); err == nil {
+			address = event.ContractAddress
+			break
+		}
+	}
+	if (address == common.Address{}) {
+		return nil, errors.New("contract deployment failed")
+	}
+
+	simpleSwap, err := InstanceAt(address, sf.backend)
+	if err != nil {
+		return nil, err
+	}
+
+	return simpleSwap, nil
+}
+
+// VerifyContract verifies that the supplied address was deployed by this factory
+func (sf simpleSwapFactory) VerifyContract(address common.Address) error {
+	isDeployed, err := sf.instance.DeployedContracts(&bind.CallOpts{}, address)
+	if err != nil {
+		return err
+	}
+	if !isDeployed {
+		return ErrNotDeployedByFactory
+	}
+	return nil
+}

contracts/swap/swap.go

@@ -20,7 +20,6 @@
 package swap
 
 import (
-	"bytes"
 	"context"
 	"errors"
 	"math/big"
@@ -29,12 +28,10 @@ import (
 	"github.com/ethereum/go-ethereum/accounts/abi/bind"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/types"
-	contract "github.com/ethersphere/go-sw3/contracts-v0-1-0/simpleswap"
+	contract "github.com/ethersphere/go-sw3/contracts-v0-1-1/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 cashes a cheque is reverted
 	ErrTransactionReverted = errors.New("Transaction reverted")
 )
@@ -48,7 +45,7 @@ type Backend interface {
 // 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
-	CashChequeBeneficiary(auth *bind.TransactOpts, backend Backend, beneficiary common.Address, cumulativePayout *big.Int, ownerSig []byte) (*CashChequeResult, *types.Receipt, error)
+	CashChequeBeneficiary(auth *bind.TransactOpts, 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
@@ -78,12 +75,13 @@ type Params struct {
 type simpleContract struct {
 	instance *contract.SimpleSwap
 	address  common.Address
+	backend  Backend
 }
 
 // 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) {
+func Deploy(auth *bind.TransactOpts, backend Backend, 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}
+	c := simpleContract{instance: instance, address: addr, backend: backend}
 	return c, tx, err
 }
 
@@ -95,17 +93,17 @@ func InstanceAt(address common.Address, backend Backend) (Contract, error) {
 	if err != nil {
 		return nil, err
 	}
-	c := simpleContract{instance: instance, address: address}
+	c := simpleContract{instance: instance, address: address, backend: backend}
 	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)
+func (s simpleContract) CashChequeBeneficiary(opts *bind.TransactOpts, beneficiary common.Address, cumulativePayout *big.Int, ownerSig []byte) (*CashChequeResult, *types.Receipt, error) {
+	tx, err := s.instance.CashChequeBeneficiary(opts, beneficiary, cumulativePayout, ownerSig)
 	if err != nil {
 		return nil, nil, err
 	}
-	receipt, err := WaitFunc(auth, backend, tx)
+	receipt, err := WaitFunc(opts, s.backend, tx)
 	if err != nil {
 		return nil, nil, err
 	}
@@ -152,20 +150,6 @@ func (s simpleContract) PaidOut(opts *bind.CallOpts, addr common.Address) (*big.
 	return s.instance.PaidOut(opts, addr)
 }
 
-// ValidateCode checks that the on-chain code at address matches the expected swap
-// contract code.
-func ValidateCode(ctx context.Context, b bind.ContractBackend, address common.Address) error {
-	codeReadFromAddress, err := b.CodeAt(ctx, address, nil)
-	if err != nil {
-		return err
-	}
-	referenceCode := common.FromHex(contract.SimpleSwapDeployedCode)
-	if !bytes.Equal(codeReadFromAddress, referenceCode) {
-		return ErrNotASwapContract
-	}
-	return nil
-}
-
 // WaitFunc is the default function to wait for transactions
 // We can overwrite this in tests so that we don't need to wait for mining
 var WaitFunc = waitForTx

go.mod

@@ -27,7 +27,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/ethersphere/go-sw3 v0.1.1
 	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.sum

@@ -64,8 +64,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/ethersphere/go-sw3 v0.1.1 h1:czLnLSU0/XJLJt/GyPiEAds9YYnIgZZzfy+OQyiYQtk=
+github.com/ethersphere/go-sw3 v0.1.1/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=

swap/protocol.go

@@ -97,7 +97,7 @@ func (s *Swap) verifyHandshake(msg interface{}) error {
 		return ErrEmptyAddressInSignature
 	}
 
-	return contract.ValidateCode(context.Background(), s.backend, handshake.ContractAddress)
+	return s.chequebookFactory.VerifyContract(handshake.ContractAddress)
 }
 
 // run is the actual swap protocol run method

swap/protocol_test.go

@@ -52,11 +52,8 @@ it expects a handshake to take place between the two nodes
 func TestHandshake(t *testing.T) {
 	var err error
 
-	testBackend := newTestBackend()
-	defer testBackend.Close()
-
 	// setup test swap object
-	swap, clean := newTestSwap(t, ownerKey, testBackend)
+	swap, clean := newTestSwap(t, ownerKey, nil)
 	defer clean()
 
 	ctx := context.Background()
@@ -214,11 +211,8 @@ func TestEmitCheque(t *testing.T) {
 // when we reach the payment threshold
 // It is the debitor who triggers cheques
 func TestTriggerPaymentThreshold(t *testing.T) {
-	testBackend := newTestBackend()
-	defer testBackend.Close()
-
 	log.Debug("create test swap")
-	debitorSwap, clean := newTestSwap(t, ownerKey, testBackend)
+	debitorSwap, clean := newTestSwap(t, ownerKey, nil)
 	defer clean()
 
 	ctx := context.Background()
@@ -281,11 +275,8 @@ func TestTriggerPaymentThreshold(t *testing.T) {
 // when we reach the disconnect threshold
 // It is the creditor who triggers the disconnect from a overdraft creditor
 func TestTriggerDisconnectThreshold(t *testing.T) {
-	testBackend := newTestBackend()
-	defer testBackend.Close()
-
 	log.Debug("create test swap")
-	creditorSwap, clean := newTestSwap(t, beneficiaryKey, testBackend)
+	creditorSwap, clean := newTestSwap(t, beneficiaryKey, nil)
 	defer clean()
 
 	// create a dummy pper

swap/simulations_test.go

@@ -28,6 +28,7 @@ import (
 	"testing"
 	"time"
 
+	"github.com/ethereum/go-ethereum/accounts/abi/bind"
 	"github.com/ethereum/go-ethereum/accounts/abi/bind/backends"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core"
@@ -40,6 +41,8 @@ import (
 	"github.com/ethereum/go-ethereum/p2p/simulations"
 	"github.com/ethereum/go-ethereum/p2p/simulations/adapters"
 	"github.com/ethereum/go-ethereum/rpc"
+	contractFactory "github.com/ethersphere/go-sw3/contracts-v0-1-1/simpleswapfactory"
+	cswap "github.com/ethersphere/swarm/contracts/swap"
 	"github.com/ethersphere/swarm/network/simulation"
 	"github.com/ethersphere/swarm/p2p/protocols"
 	"github.com/ethersphere/swarm/state"
@@ -195,7 +198,7 @@ func newSharedBackendSwaps(t *testing.T, nodeCount int) (*swapSimulationParams,
 		}
 		keys[i] = key
 		addrs[i] = crypto.PubkeyToAddress(key.PublicKey)
-		alloc[addrs[i]] = core.GenesisAccount{Balance: big.NewInt(10000000000)}
+		alloc[addrs[i]] = core.GenesisAccount{Balance: big.NewInt(10000 * int64(RetrieveRequestPrice))}
 		dir, err := ioutil.TempDir("", fmt.Sprintf("swap_test_store_%x", addrs[i].Hex()))
 		if err != nil {
 			return nil, err
@@ -210,13 +213,25 @@ func newSharedBackendSwaps(t *testing.T, nodeCount int) (*swapSimulationParams,
 	// then create the single SimulatedBackend
 	gasLimit := uint64(8000000000)
 	defaultBackend := backends.NewSimulatedBackend(alloc, gasLimit)
-	testBackend := &swapTestBackend{SimulatedBackend: defaultBackend}
+	defaultBackend.Commit()
+
+	factoryAddress, _, _, err := contractFactory.DeploySimpleSwapFactory(bind.NewKeyedTransactor(keys[0]), defaultBackend)
+	if err != nil {
+		t.Fatalf("Error while deploying factory: %v", err)
+	}
+	defaultBackend.Commit()
+
+	testBackend := &swapTestBackend{SimulatedBackend: defaultBackend, factoryAddress: factoryAddress}
 	// finally, create all Swap instances for each node, which share the same backend
 	var owner *Owner
 	defParams := newDefaultParams(t)
 	for i := 0; i < nodeCount; i++ {
 		owner = createOwner(keys[i])
-		params.swaps[i] = newSwapInstance(stores[i], owner, testBackend, defParams)
+		factory, err := cswap.FactoryAt(testBackend.factoryAddress, testBackend)
+		if err != nil {
+			t.Fatal(err)
+		}
+		params.swaps[i] = newSwapInstance(stores[i], owner, testBackend, defParams, factory)
 	}
 
 	params.backend = testBackend