fix: bootnode version RPC call (#467)

bootnode/bootnode.go

@@ -9,9 +9,9 @@ import (
  "context"
  "errors"
  "fmt"
- "math/big"
  "net/http"
 
+ "github.com/athanorlabs/atomic-swap/common"
  "github.com/athanorlabs/atomic-swap/net"
  "github.com/athanorlabs/atomic-swap/rpc"
 
@@ -23,26 +23,27 @@ var log = logging.Logger("bootnode")
 
 // Config provides the configuration for a bootnode.
 type Config struct {
- DataDir string
- Bootnodes []string
- HostListenIP string
- Libp2pPort uint16
- Libp2pKeyFile string
- RPCPort uint16
- EthereumChainID *big.Int
+ Env  common.Environment
+ DataDir string
+ Bootnodes  []string
+ HostListenIP string
+ Libp2pPort  uint16
+ Libp2pKeyFile string
+ RPCPort uint16
 }
 
 // RunBootnode assembles and runs a bootnode instance, blocking until the node is
 // shut down. Typically, shutdown happens because a signal handler cancels the
 // passed in context, or when the shutdown RPC method is called.
 func RunBootnode(ctx context.Context, cfg *Config) error {
+ chainID := common.ChainIDFromEnv(cfg.Env)
  host, err := net.NewHost(&net.Config{
  Ctx: ctx,
  DataDir: cfg.DataDir,
  Port: cfg.Libp2pPort,
  KeyFile: cfg.Libp2pKeyFile,
  Bootnodes: cfg.Bootnodes,
- ProtocolID: fmt.Sprintf("%s/%d", net.ProtocolID, cfg.EthereumChainID.Int64()),
+ ProtocolID: fmt.Sprintf("%s/%d", net.ProtocolID, chainID),
  ListenIP: cfg.HostListenIP,
  IsRelayer: false,
  IsBootnodeOnly: true,
@@ -61,9 +62,14 @@ func RunBootnode(ctx context.Context, cfg *Config) error {
  }
 
  rpcServer, err := rpc.NewServer(&rpc.Config{
- Ctx: ctx,
- Address: fmt.Sprintf("127.0.0.1:%d", cfg.RPCPort),
- Net: host,
+ Ctx: ctx,
+ Env: cfg.Env,
+ Address: fmt.Sprintf("127.0.0.1:%d", cfg.RPCPort),
+ Net: host,
+ XMRTaker: nil,
+ XMRMaker: nil,
+ ProtocolBackend: nil,
+ RecoveryDB: nil,
  Namespaces: map[string]struct{}{
  rpc.DaemonNamespace: {},
  rpc.NetNamespace: {},

cmd/bootnode/main.go

@@ -135,13 +135,13 @@ func runBootnode(c *cli.Context) error {
 
  rpcPort := uint16(c.Uint(flagRPCPort))
  return bootnode.RunBootnode(c.Context, &bootnode.Config{
- DataDir: config.DataDir,
- Bootnodes: config.Bootnodes,
- HostListenIP: hostListenIP,
- Libp2pPort:  libp2pPort,
- Libp2pKeyFile: libp2pKeyFile,
- RPCPort: rpcPort,
- EthereumChainID: config.EthereumChainID,
+ Env:  config.Env,
+ DataDir: config.DataDir,
+ Bootnodes:  config.Bootnodes,
+ HostListenIP: hostListenIP,
+ Libp2pPort:  libp2pPort,
+ Libp2pKeyFile: libp2pKeyFile,
+ RPCPort: rpcPort,
  })
 }
 

cmd/bootnode/main_test.go

@@ -0,0 +1,69 @@
+// Copyright 2023 The AthanorLabs/atomic-swap Authors
+// SPDX-License-Identifier: LGPL-3.0-only
+
+package main
+
+import (
+ "context"
+ "fmt"
+ "sync"
+ "testing"
+
+ "github.com/stretchr/testify/assert"
+ "github.com/stretchr/testify/require"
+
+ "github.com/athanorlabs/atomic-swap/cliutil"
+ "github.com/athanorlabs/atomic-swap/common"
+ "github.com/athanorlabs/atomic-swap/daemon"
+ "github.com/athanorlabs/atomic-swap/rpcclient"
+)
+
+func getFreePort(t *testing.T) uint16 {
+ port, err := common.GetFreeTCPPort()
+ require.NoError(t, err)
+ return uint16(port)
+}
+
+func TestBootnode(t *testing.T) {
+ ctx, cancel := context.WithCancel(context.Background())
+ defer cancel()
+ rpcPort := getFreePort(t)
+ dataDir := t.TempDir()
+
+ flags := []string{
+ "bootnode",
+ fmt.Sprintf("--%s=dev", flagEnv),
+ fmt.Sprintf("--%s=debug", cliutil.FlagLogLevel),
+ fmt.Sprintf("--%s=%s", flagDataDir, dataDir),
+ fmt.Sprintf("--%s=%d", flagRPCPort, rpcPort),
+ fmt.Sprintf("--%s=0", flagLibp2pPort),
+ }
+
+ var wg sync.WaitGroup
+ wg.Add(1)
+
+ go func() {
+ defer wg.Done()
+ err := cliApp().RunContext(ctx, flags)
+ // We may want to replace context.Cancelled with nil at some point in the code
+ assert.ErrorIs(t, context.Canceled, err)
+ }()
+
+ // Ensure the bootnode fully starts before some basic sanity checks
+ daemon.WaitForSwapdStart(t, rpcPort)
+
+ cli := rpcclient.NewClient(ctx, fmt.Sprintf("http://127.0.0.1:%d", rpcPort))
+ versionResp, err := cli.Version()
+ require.NoError(t, err)
+ require.NotEmpty(t, versionResp.P2PVersion)
+ t.Logf("Bootnode p2p version is: %s", versionResp.P2PVersion)
+ require.Nil(t, versionResp.SwapCreatorAddr) // bootnode does not know the address
+
+ addressResp, err := cli.Addresses()
+ require.NoError(t, err)
+ require.Greater(t, len(addressResp.Addrs), 1)
+
+ // We check the contract code below, but we don't need the daemon for that
+ cli.Shutdown()
+ wg.Wait()
+}

cmd/swapd/contract.go

@@ -7,37 +7,24 @@ import (
  "context"
  "crypto/ecdsa"
  "fmt"
- "os"
- "path"
- "path/filepath"
  "time"
 
  "github.com/athanorlabs/atomic-swap/common"
- "github.com/athanorlabs/atomic-swap/common/vjson"
  contracts "github.com/athanorlabs/atomic-swap/ethereum"
  "github.com/athanorlabs/atomic-swap/ethereum/extethclient"
 
  ethcommon "github.com/ethereum/go-ethereum/common"
  "github.com/ethereum/go-ethereum/ethclient"
 )
 
-const (
- contractAddressesFile = "contract-addresses.json"
-)
-
 var (
  errNoEthPrivateKey = fmt.Errorf("must provide --%s file for non-development environment", flagEthPrivKey)
 )
 
-type contractAddresses struct {
- SwapCreatorAddr ethcommon.Address `json:"swapCreatorAddr" validate:"required"`
-}
-
 func getOrDeploySwapCreator(
  ctx context.Context,
  swapCreatorAddr ethcommon.Address,
  env common.Environment,
- dataDir string,
  ec extethclient.EthClient,
 ) (ethcommon.Address, error) {
  var err error
@@ -47,7 +34,7 @@ func getOrDeploySwapCreator(
  time.Sleep(10 * time.Second)
  }
 
- swapCreatorAddr, err = deploySwapCreator(ctx, ec.Raw(), ec.PrivateKey(), dataDir)
+ swapCreatorAddr, err = deploySwapCreator(ctx, ec.Raw(), ec.PrivateKey())
  if err != nil {
  return ethcommon.Address{}, fmt.Errorf("failed to deploy swap creator: %w", err)
  }
@@ -68,7 +55,6 @@ func deploySwapCreator(
  ctx context.Context,
  ec *ethclient.Client,
  privkey *ecdsa.PrivateKey,
- dataDir string,
 ) (ethcommon.Address, error) {
  if privkey == nil {
  return ethcommon.Address{}, errNoEthPrivateKey
@@ -79,25 +65,5 @@ func deploySwapCreator(
  return ethcommon.Address{}, err
  }
 
- // store the contract addresses on disk
- err = writeContractAddressesToFile(
- path.Join(dataDir, contractAddressesFile),
- &contractAddresses{
- SwapCreatorAddr: swapCreatorAddr,
- },
- )
- if err != nil {
- return ethcommon.Address{}, fmt.Errorf("failed to write contract address to file: %w", err)
- }
-
  return swapCreatorAddr, nil
 }
-
-// writeContractAddressesToFile writes the contract addresses to the given file
-func writeContractAddressesToFile(filePath string, addresses *contractAddresses) error {
- jsonData, err := vjson.MarshalIndentStruct(addresses, "", " ")
- if err != nil {
- return err
- }
- return os.WriteFile(filepath.Clean(filePath), jsonData, 0600)
-}

cmd/swapd/contract_test.go

@@ -18,13 +18,11 @@ import (
 func TestGetOrDeploySwapCreator_Deploy(t *testing.T) {
  pk := tests.GetTakerTestKey(t)
  ec := extethclient.CreateTestClient(t, pk)
- tmpDir := t.TempDir()
 
  _, err := getOrDeploySwapCreator(
  context.Background(),
  ethcommon.Address{},
  common.Development,
- tmpDir,
  ec,
  )
  require.NoError(t, err)
@@ -33,14 +31,12 @@ func TestGetOrDeploySwapCreator_Deploy(t *testing.T) {
 func TestGetOrDeploySwapCreator_Get(t *testing.T) {
  pk := tests.GetTakerTestKey(t)
  ec := extethclient.CreateTestClient(t, pk)
- tmpDir := t.TempDir()
 
  // deploy and get address
  address, err := getOrDeploySwapCreator(
  context.Background(),
  ethcommon.Address{},
  common.Development,
- tmpDir,
  ec,
  )
  require.NoError(t, err)
@@ -49,7 +45,6 @@ func TestGetOrDeploySwapCreator_Get(t *testing.T) {
  context.Background(),
  address,
  common.Development,
- tmpDir,
  ec,
  )
  require.NoError(t, err)

cmd/swapd/main.go

@@ -368,7 +368,6 @@ func validateOrDeployContracts(c *cli.Context, envConf *common.Config, ec exteth
  c.Context,
  envConf.SwapCreatorAddr,
  envConf.Env,
- envConf.DataDir,
  ec,
  )
  if err != nil {

cmd/swapd/main_test.go

@@ -5,7 +5,6 @@ package main
 
 import (
  "context"
- "encoding/json"
  "fmt"
  "os"
  "path"
@@ -78,30 +77,24 @@ func TestDaemon_DevXMRTaker(t *testing.T) {
  assert.NoError(t, err)
  }()
 
- // Ensure the daemon fully started before we cancel the context
+ // Ensure the daemon fully before we query the contract address
  daemon.WaitForSwapdStart(t, rpcPort)
+
+ cli := rpcclient.NewClient(ctx, fmt.Sprintf("http://127.0.0.1:%d", rpcPort))
+ versionResp, err := cli.Version()
+ require.NoError(t, err)
+
+ // We check the contract code below, but we don't need the daemon for that
  cancel()
  wg.Wait()
 
  if t.Failed() {
  return
  }
 
- //
- // Validate that --deploy created a contract address file.
- // At some future point, we will ask the RPC endpoint
- // what the contract addresses are instead of using this file.
- //
- data, err := os.ReadFile(path.Join(dataDir, contractAddressesFile))
- require.NoError(t, err)
- m := make(map[string]string)
- require.NoError(t, json.Unmarshal(data, &m))
- swapCreatorAddr, ok := m["swapCreatorAddr"]
- require.True(t, ok)
-
  ec, _ := tests.NewEthClient(t)
  ecCtx := context.Background()
- err = contracts.CheckSwapCreatorContractCode(ecCtx, ec, ethcommon.HexToAddress(swapCreatorAddr))
+ err = contracts.CheckSwapCreatorContractCode(ecCtx, ec, *versionResp.SwapCreatorAddr)
  require.NoError(t, err)
 }
 
@@ -111,7 +104,7 @@ func TestDaemon_DevXMRMaker(t *testing.T) {
  ec, _ := tests.NewEthClient(t)
 
  // We tested --deploy with the taker, so test passing the contract address here
- swapCreatorAddr, err := deploySwapCreator(context.Background(), ec, key, t.TempDir())
+ swapCreatorAddr, err := deploySwapCreator(context.Background(), ec, key)
  require.NoError(t, err)
 
  flags := []string{
@@ -148,7 +141,7 @@ func TestDaemon_BadFlags(t *testing.T) {
  ec, _ := tests.NewEthClient(t)
  ctx, _ := newTestContext(t)
 
- swapCreatorAddr, err := deploySwapCreator(ctx, ec, key, t.TempDir())
+ swapCreatorAddr, err := deploySwapCreator(ctx, ec, key)
  require.NoError(t, err)
 
  baseFlags := []string{