harness: Update eth to work with geth 1.14 and up.

Author: JoeGruffins

client/asset/eth/chaincfg.go

@@ -11,7 +11,6 @@ import (
 	"strings"
 
 	"decred.org/dcrdex/dex"
-	dexeth "decred.org/dcrdex/dex/networks/eth"
 	"github.com/ethereum/go-ethereum/common"
 	ethcore "github.com/ethereum/go-ethereum/core"
 	"github.com/ethereum/go-ethereum/eth/ethconfig"
@@ -65,7 +64,7 @@ func NetworkCompatibilityData(net dex.Network) (c CompatibilityData, err error)
 	addr := common.HexToAddress("18d65fb8d60c1199bb1ad381be47aa692b482605")
 	var (
 		tTxHashFile    = filepath.Join(tDir, "test_tx_hash.txt")
-		tBlockHashFile = filepath.Join(tDir, "test_block10_hash.txt")
+		tBlockHashFile = filepath.Join(tDir, "test_block1_hash.txt")
 		tContractFile  = filepath.Join(tDir, "test_usdc_contract_address.txt")
 	)
 	readIt := func(path string) string {
@@ -103,10 +102,8 @@ func ETHConfig(net dex.Network) (c ethconfig.Config, err error) {
 	case dex.Testnet:
 		c.Genesis = ethcore.DefaultSepoliaGenesisBlock()
 	case dex.Simnet:
-		c.Genesis, err = readSimnetGenesisFile()
-		if err != nil {
-			return c, fmt.Errorf("readSimnetGenesisFile error: %w", err)
-		}
+		// Args are gasLimit, faucet address.
+		c.Genesis = ethcore.DeveloperGenesisBlock(30000000, nil)
 	default:
 		return c, fmt.Errorf("unknown network %d", net)
 
@@ -123,19 +120,3 @@ func ChainConfig(net dex.Network) (c *params.ChainConfig, err error) {
 	}
 	return cfg.Genesis.Config, nil
 }
-
-// readSimnetGenesisFile reads the simnet genesis file.
-func readSimnetGenesisFile() (*ethcore.Genesis, error) {
-	dataDir, err := simnetDataDir()
-	if err != nil {
-		return nil, err
-	}
-
-	genesisFile := filepath.Join(dataDir, "genesis.json")
-	genesisCfg, err := dexeth.LoadGenesisFile(genesisFile)
-	if err != nil {
-		return nil, fmt.Errorf("error reading genesis file: %v", err)
-	}
-
-	return genesisCfg, nil
-}

client/asset/eth/eth_test.go

@@ -4927,11 +4927,11 @@ func testMaxSwapRedeemLots(t *testing.T, assetID uint32) {
 			t.Fatalf("expected 63 for max redemptions but got %d", info.MaxRedeemsInTx)
 		}
 	} else {
-		if info.MaxSwapsInTx != 20 {
-			t.Fatalf("expected 20 for max swaps but got %d", info.MaxSwapsInTx)
+		if info.MaxSwapsInTx != 24 {
+			t.Fatalf("expected 24 for max swaps but got %d", info.MaxSwapsInTx)
 		}
-		if info.MaxRedeemsInTx != 45 {
-			t.Fatalf("expected 45 for max redemptions but got %d", info.MaxRedeemsInTx)
+		if info.MaxRedeemsInTx != 55 {
+			t.Fatalf("expected 55 for max redemptions but got %d", info.MaxRedeemsInTx)
 		}
 	}
 }

client/asset/eth/nodeclient_harness_test.go

@@ -72,9 +72,7 @@ var (
 	testnetParticipantWalletDir string
 
 	alphaNodeDir               = filepath.Join(homeDir, "dextest", "eth", "alpha", "node")
-	alphaIPCFile               = filepath.Join(alphaNodeDir, "geth.ipc")
-	betaNodeDir                = filepath.Join(homeDir, "dextest", "eth", "beta", "node")
-	betaIPCFile                = filepath.Join(betaNodeDir, "geth.ipc")
+	alphaWSEndpoint            = "ws://127.0.0.1:38557"
 	ctx                        context.Context
 	tLogger                    = dex.StdOutLogger("ETHTEST", dex.LevelWarn)
 	simnetWalletSeed           = "0812f5244004217452059e2fd11603a511b5d0870ead753df76c966ce3c71531"
@@ -208,23 +206,23 @@ func prepareRPCClient(name, dataDir string, providers []string, net dex.Network)
 	return c, c.creds.acct, nil
 }
 
-func rpcEndpoints(net dex.Network) ([]string, []string) {
+func rpcEndpoints(net dex.Network) []string {
 	if net == dex.Testnet {
-		return rpcProviders, rpcProviders
+		return rpcProviders
 	}
-	return []string{alphaIPCFile}, []string{betaIPCFile}
+	return []string{alphaWSEndpoint}
 }
 
 func prepareTestRPCClients(initiatorDir, participantDir string, net dex.Network) (err error) {
-	initiatorEndpoints, participantEndpoints := rpcEndpoints(net)
+	endpoints := rpcEndpoints(net)
 
-	ethClient, simnetAcct, err = prepareRPCClient("initiator", initiatorDir, initiatorEndpoints, net)
+	ethClient, simnetAcct, err = prepareRPCClient("initiator", initiatorDir, endpoints, net)
 	if err != nil {
 		return err
 	}
 	fmt.Println("initiator address is", ethClient.address())
 
-	participantEthClient, participantAcct, err = prepareRPCClient("participant", participantDir, participantEndpoints, net)
+	participantEthClient, participantAcct, err = prepareRPCClient("participant", participantDir, endpoints, net)
 	if err != nil {
 		ethClient.shutdown()
 		return err
@@ -258,14 +256,14 @@ func runSimnet(m *testing.M) (int, error) {
 
 	ethSwapContractAddr = dexeth.ContractAddresses[contractVer][dex.Simnet]
 
-	initiatorProviders, participantProviders := rpcEndpoints(dex.Simnet)
+	providers := rpcEndpoints(dex.Simnet)
 
-	err = setupWallet(simnetWalletDir, simnetWalletSeed, "localhost:30355", initiatorProviders, dex.Simnet)
+	err = setupWallet(simnetWalletDir, simnetWalletSeed, "localhost:30355", providers, dex.Simnet)
 	if err != nil {
 		return 1, err
 	}
 
-	err = setupWallet(participantWalletDir, participantWalletSeed, "localhost:30356", participantProviders, dex.Simnet)
+	err = setupWallet(participantWalletDir, participantWalletSeed, "localhost:30356", providers, dex.Simnet)
 	if err != nil {
 		return 1, err
 	}
@@ -390,13 +388,13 @@ func runTestnet(m *testing.M) (int, error) {
 	ethSwapContractAddr = dexeth.ContractAddresses[contractVer][dex.Testnet]
 	fmt.Printf("ETH swap contract address is %v\n", ethSwapContractAddr)
 
-	initiatorRPC, participantRPC := rpcEndpoints(dex.Testnet)
+	rpc := rpcEndpoints(dex.Testnet)
 
-	err = setupWallet(testnetWalletDir, testnetWalletSeed, "localhost:30355", initiatorRPC, dex.Testnet)
+	err = setupWallet(testnetWalletDir, testnetWalletSeed, "localhost:30355", rpc, dex.Testnet)
 	if err != nil {
 		return 1, err
 	}
-	err = setupWallet(testnetParticipantWalletDir, testnetParticipantWalletSeed, "localhost:30356", participantRPC, dex.Testnet)
+	err = setupWallet(testnetParticipantWalletDir, testnetParticipantWalletSeed, "localhost:30356", rpc, dex.Testnet)
 	if err != nil {
 		return 1, err
 	}

dex/networks/eth/params.go

@@ -32,8 +32,8 @@ const (
 // These are the chain IDs of the various Ethereum network supported.
 const (
 	MainnetChainID = 1
-	TestnetChainID = 5  // Görli
-	SimnetChainID  = 42 // see dex/testing/eth/harness.sh
+	TestnetChainID = 11155111 // Sepolia
+	SimnetChainID  = 1337     // see dex/testing/eth/harness.sh
 )
 
 var (

dex/networks/eth/tokens.go

@@ -168,13 +168,13 @@ var Tokens = map[uint32]*Token{
 					0: {
 						Address: common.Address{},
 						Gas: Gases{
-							Swap:      242_000,
-							SwapAdd:   146_400,
-							Redeem:    109_000,
-							RedeemAdd: 31_600,
-							Refund:    77_000,
-							Approve:   78_400,
-							Transfer:  85_100,
+							Swap:      203_317,
+							SwapAdd:   146_368,
+							Redeem:    90_775,
+							RedeemAdd: 41_117,
+							Refund:    65_448,
+							Approve:   32_303,
+							Transfer:  66_953,
 						}},
 				},
 			},
@@ -266,13 +266,13 @@ var Tokens = map[uint32]*Token{
 					0: {
 						Address: common.Address{},
 						Gas: Gases{
-							Swap:      242_000,
-							SwapAdd:   146_400,
-							Redeem:    109_000,
-							RedeemAdd: 31_600,
-							Refund:    77_000,
-							Approve:   78_400,
-							Transfer:  85_100,
+							Swap:      203_317,
+							SwapAdd:   146_368,
+							Redeem:    90_775,
+							RedeemAdd: 41_117,
+							Refund:    65_448,
+							Approve:   32_303,
+							Transfer:  66_953,
 						}},
 				},
 			},

dex/testing/eth/README.md

@@ -6,35 +6,32 @@ sandboxed environment for testing dex swap transactions.
 ## Dependencies
 
 The harness depends on [geth](https://github.com/ethereum/go-ethereum/tree/master/cmd/geth)
-to run. geth v1.13.4+ is recommended.
+to run. geth v1.14.12+ is recommended.
 
 It also requires tmux and bc.
 
 ## Using
 
 You must have `geth` in `PATH` to use the harness.
 
-The harness script will create four connected private nodes. Two, alpha and
-beta, have mining abilities and pre-funded addresses with syncmode set to
-"fast". They are meant to be used with server functions. Two more, gamma and
-delta, are "light" nodes without mining abilites and with addresses that have
-been sent funds. They are intenended to be used with client functions.
+The harness script will create one private node, alpha, running in --dev mode.
+alpha has scripts to send coins and tokens to any address. Blocks are mined
+every 10 seconds in the mining tmux session.
 
 ## Harness control scripts
 
 The `./harness.sh` script will drop you into a tmux window in a directory
 called `harness-ctl`. Inside of this directory are a number of scripts to
 allow you to perform RPC calls against each wallet.
 
-`./alpha`, `./beta`, `./gamma`, and `./delta` are just `geth` configured for
-their respective data directories.
+`./alpha` is just `geth` configured for its data directory.
 
 Try `./alpha attach`, for example. This will put you in an interactive console
 with the alpha node.
 
 `./quit` shuts down the nodes and closes the tmux session.
 
-`./mine-alpha n` and `./mine-beta n` will mine n blocks on the respective node.
+`./mine-alpha n` will mine about n blocks. It is not precise.
 
 ## Dev Stuff
 
@@ -46,4 +43,4 @@ change to the alpha node window. Examining the node output to look for errors
 is usually a good first debugging step.
 
 If you encouter a problem, the harness can be killed from another terminal with
-`tmux kill-session -t eth-harness`.
+`tmux kill-session -t eth-harness`. Nodes can be killed with `sudo pkill -9 geth`.

dex/testing/eth/create-node.sh

@@ -5,25 +5,14 @@ set -ex
 # The following are required script arguments.
 TMUX_WIN_ID=$1
 NAME=$2
-NODE_PORT=$3
-CHAIN_ADDRESS=$4
-CHAIN_PASSWORD=$5
-CHAIN_ADDRESS_JSON=$6
-CHAIN_ADDRESS_JSON_FILE_NAME=$7
-ADDRESS_JSON=$8
-ADDRESS_JSON_FILE_NAME=$9
-NODE_KEY=${10}
-SYNC_MODE=${11}
-AUTHRPC_PORT=${12}
-HTTP_PORT=${13}
-WS_PORT=${14}
-WS_MODULES=${15}
+AUTHRPC_PORT=${3}
+HTTP_PORT=${4}
+WS_PORT=${5}
+WS_MODULES=${6}
 
 GROUP_DIR="${NODES_ROOT}/${NAME}"
-MINE_JS="${GROUP_DIR}/mine.js"
 NODE_DIR="${GROUP_DIR}/node"
 mkdir -p "${NODE_DIR}"
-mkdir -p "${NODE_DIR}/keystore"
 mkdir -p "${NODE_DIR}/geth"
 
 # Write node ctl script.
@@ -33,114 +22,20 @@ geth --datadir="${NODE_DIR}" \$*
 EOF
 chmod +x "${NODES_ROOT}/harness-ctl/${NAME}"
 
-# Write mine script if CHAIN_ADDRESS is present.
-if [ "${CHAIN_ADDRESS}" != "_" ]; then
-  # The mining script may end up mining more or less blocks than specified.
-  cat > "${NODES_ROOT}/harness-ctl/mine-${NAME}" <<EOF
-#!/usr/bin/env bash
-  NUM=2
-  case \$1 in
-      ''|*[!0-9]*|[0-1])  ;;
-      *) NUM=\$1 ;;
-  esac
-  echo "Mining..."
-  BEFORE=\$("${NODES_ROOT}/harness-ctl/${NAME}" attach --exec 'eth.blockNumber')
-  "${NODES_ROOT}/harness-ctl/${NAME}" attach --exec 'miner.start()' > /dev/null
-  sleep \$(echo "\$NUM-1.8" | bc)
-  "${NODES_ROOT}/harness-ctl/${NAME}" attach --exec 'miner.stop()' > /dev/null
-  sleep 1
-  AFTER=\$("${NODES_ROOT}/harness-ctl/${NAME}" attach --exec 'eth.blockNumber')
-  DIFF=\$((AFTER-BEFORE))
-  echo "Mined \$DIFF blocks on ${NAME}. Their hashes:"
-  for i in \$(seq \$((BEFORE+1)) \$AFTER)
-  do
-    echo \$i
-    "${NODES_ROOT}/harness-ctl/${NAME}" attach --exec 'eth.getHeaderByNumber('\$i').hash'
-  done
-EOF
-  chmod +x "${NODES_ROOT}/harness-ctl/mine-${NAME}"
-
-  # Write password file to unlock accounts later.
-  cat > "${GROUP_DIR}/password" <<EOF
-$CHAIN_PASSWORD
-EOF
-
-fi
-
 cat > "${NODE_DIR}/eth.conf" <<EOF
-[Eth]
-NetworkId = 42
-SyncMode = "${SYNC_MODE}"
-
 [Node]
 DataDir = "${NODE_DIR}"
 AuthPort = ${AUTHRPC_PORT}
-
-[Node.P2P]
-NoDiscovery = true
-BootstrapNodes = []
-BootstrapNodesV5 = []
-ListenAddr = ":${NODE_PORT}"
-NetRestrict = [ "127.0.0.1/8", "::1/128" ]
 EOF
 
-# Add etherbase if mining.
-if [ "${CHAIN_ADDRESS}" != "_" ]; then
-  cat >> "${NODE_DIR}/eth.conf" <<EOF
-
-[Eth.Miner]
-Etherbase = "0x${CHAIN_ADDRESS}"
-GasFloor = 30000000
-GasCeil = 30000000
-EOF
-fi
-
 # Create a tmux window.
 tmux new-window -t "$TMUX_WIN_ID" -n "${NAME}" "${SHELL}"
 tmux send-keys -t "$TMUX_WIN_ID" "set +o history" C-m
 tmux send-keys -t "$TMUX_WIN_ID" "cd ${NODE_DIR}" C-m
 
-# Create and wait for a node initiated with a predefined genesis json.
-echo "Creating simnet ${NAME} node"
-tmux send-keys -t "$TMUX_WIN_ID" "${NODES_ROOT}/harness-ctl/${NAME} init "\
-	"$GENESIS_JSON_FILE_LOCATION; tmux wait-for -S ${NAME}" C-m
-tmux wait-for "${NAME}"
-
-# Create two accounts. The first is used to mine blocks. The second contains
-# funds.
-if [ "${CHAIN_ADDRESS}" != "_" ]; then
-  echo "Creating account"
-  cat > "${NODE_DIR}/keystore/$CHAIN_ADDRESS_JSON_FILE_NAME" <<EOF
-$CHAIN_ADDRESS_JSON
-EOF
-fi
-
-cat > "${NODE_DIR}/keystore/$ADDRESS_JSON_FILE_NAME" <<EOF
-$ADDRESS_JSON
-EOF
-
-# The node key lets us control the enode address value.
-echo "Setting node key"
-cat > "${NODE_DIR}/geth/nodekey" <<EOF
-$NODE_KEY
-EOF
-
 echo "Starting simnet ${NAME} node"
-if [ "${SYNC_MODE}" = "snap" ]; then
-  # Start the eth node with the chain account unlocked, listening restricted to
-  # localhost, and our custom configuration file.
-  tmux send-keys -t "$TMUX_WIN_ID" "${NODES_ROOT}/harness-ctl/${NAME} " \
-	  "--config ${NODE_DIR}/eth.conf --unlock ${CHAIN_ADDRESS} " \
-	  "--password ${GROUP_DIR}/password --light.serve 25 --datadir.ancient " \
-	  "${NODE_DIR}/geth-ancient --verbosity 5 --vmdebug --http --http.port " \
-	  "${HTTP_PORT} --ws --ws.port ${WS_PORT} --ws.api " \
-	  "${WS_MODULES} --allow-insecure-unlock --rpc.enabledeprecatedpersonal " \
-	  "2>&1 | tee ${NODE_DIR}/${NAME}.log" C-m
-
-else
-  # Start the eth node listening restricted to localhost and our custom
-  # configuration file.
-  tmux send-keys -t "$TMUX_WIN_ID" "${NODES_ROOT}/harness-ctl/${NAME} --allow-insecure-unlock --rpc.enabledeprecatedpersonal " \
-	  "--config ${NODE_DIR}/eth.conf --verbosity 5 ${HTTP_OPT} 2>&1 | tee " \
-	  "${NODE_DIR}/${NAME}.log" C-m
-fi
+# Start the eth node with our custom configuration file.
+tmux send-keys -t "$TMUX_WIN_ID" "${NODES_ROOT}/harness-ctl/${NAME} " \
+	"--config ${NODE_DIR}/eth.conf --verbosity 5 --vmdebug --http --http.port " \
+	"${HTTP_PORT} --ws --ws.port ${WS_PORT} --ws.api ${WS_MODULES} " \
+	"--dev --dev.period 10 2>&1 | tee ${NODE_DIR}/${NAME}.log" C-m