[WIP] Special contracts test units

accounts/abi/bind/backends/simulated.go

@@ -638,9 +638,9 @@ func (b *SimulatedBackend) AdjustTime(adjustment time.Duration) error {
 	return nil
 }
 
-// Blockchain returns the underlying blockchain.
-func (b *SimulatedBackend) Blockchain() *core.BlockChain {
-	return b.blockchain
+// ChainID returns the underlying blockchain.
+func (b *SimulatedBackend) ChainID(ctx context.Context) (*big.Int, error) {
+	return b.blockchain.Config().ChainId, nil
 }
 
 // filterBackend implements filters.Backend to support filtering for logs without

contracts/blocksigner/blocksigner_test.go

@@ -40,7 +40,11 @@ func TestBlockSigner(t *testing.T) {
 			Balance: big.NewInt(10_000_000_000_000_000),
 		},
 	})
-	transactOpts, err := bind.NewKeyedTransactorWithChainID(key, contractBackend.Blockchain().Config().ChainId)
+	chainID, err := contractBackend.ChainID(context.Background())
+	if err != nil {
+		t.Fatalf("can't get chainID: %v", err)
+	}
+	transactOpts, err := bind.NewKeyedTransactorWithChainID(key, chainID)
 	if err != nil {
 		t.Fatalf("can't create TransactOpts: %v", err)
 	}

contracts/chequebook/cheque.go

@@ -36,10 +36,6 @@ import (
 	"sync"
 	"time"
 
-	"github.com/tomochain/tomochain/params"
-
-	"github.com/tomochain/tomochain/core"
-
 	"github.com/tomochain/tomochain/accounts/abi/bind"
 	"github.com/tomochain/tomochain/common"
 	"github.com/tomochain/tomochain/common/hexutil"
@@ -69,7 +65,7 @@ type Backend interface {
 	bind.ContractBackend
 	TransactionReceipt(ctx context.Context, txHash common.Hash) (*types.Receipt, error)
 	BalanceAt(ctx context.Context, address common.Address, blockNum *big.Int) (*big.Int, error)
-	Blockchain() *core.BlockChain
+	ChainID(ctx context.Context) (*big.Int, error)
 }
 
 // Cheque represents a payment promise to a single beneficiary.
@@ -127,7 +123,11 @@ func NewChequebook(path string, contractAddr common.Address, prvKey *ecdsa.Priva
 	if err != nil {
 		return nil, err
 	}
-	transactOpts, err := bind.NewKeyedTransactorWithChainID(prvKey, backend.Blockchain().Config().ChainId)
+	chainID, err := backend.ChainID(context.Background())
+	if err != nil {
+		return nil, err
+	}
+	transactOpts, err := bind.NewKeyedTransactorWithChainID(prvKey, chainID)
 	if err != nil {
 		return nil, err
 	}
@@ -453,15 +453,15 @@ type Inbox struct {
 
 // NewInbox creates an Inbox. An Inboxes is not persisted, the cumulative sum is updated
 // from blockchain when first cheque is received.
-func NewInbox(prvKey *ecdsa.PrivateKey, contractAddr, beneficiary common.Address, signer *ecdsa.PublicKey, abigen bind.ContractBackend, chainConfig *params.ChainConfig) (self *Inbox, err error) {
+func NewInbox(prvKey *ecdsa.PrivateKey, contractAddr, beneficiary common.Address, signer *ecdsa.PublicKey, abigen bind.ContractBackend, chainID *big.Int) (self *Inbox, err error) {
 	if signer == nil {
 		return nil, fmt.Errorf("signer is null")
 	}
 	chbook, err := contract.NewChequebook(contractAddr, abigen)
 	if err != nil {
 		return nil, err
 	}
-	transactOpts, err := bind.NewKeyedTransactorWithChainID(prvKey, chainConfig.ChainId)
+	transactOpts, err := bind.NewKeyedTransactorWithChainID(prvKey, chainID)
 	if err != nil {
 		return nil, err
 	}

contracts/chequebook/cheque_test.go

@@ -17,6 +17,7 @@
 package chequebook
 
 import (
+	"context"
 	"crypto/ecdsa"
 	"math/big"
 	"os"
@@ -50,7 +51,11 @@ func newTestBackend() *backends.SimulatedBackend {
 }
 
 func deploy(prvKey *ecdsa.PrivateKey, amount *big.Int, backend *backends.SimulatedBackend) (common.Address, error) {
-	deployTransactor, err := bind.NewKeyedTransactorWithChainID(prvKey, backend.Blockchain().Config().ChainId)
+	chainID, err := backend.ChainID(context.Background())
+	if err != nil {
+		return common.Address{}, err
+	}
+	deployTransactor, err := bind.NewKeyedTransactorWithChainID(prvKey, chainID)
 	if err != nil {
 		return common.Address{}, err
 	}
@@ -96,7 +101,11 @@ func TestIssueAndReceive(t *testing.T) {
 		t.Errorf("expected: %v, got %v", "0", chbook.Balance())
 	}
 
-	chbox, err := NewInbox(key1, addr0, addr1, &key0.PublicKey, backend, backend.Blockchain().Config())
+	chainID, err := backend.ChainID(context.Background())
+	if err != nil {
+		t.Fatalf("expected no error, got %v", err)
+	}
+	chbox, err := NewInbox(key1, addr0, addr1, &key0.PublicKey, backend, chainID)
 	if err != nil {
 		t.Fatalf("expected no error, got %v", err)
 	}
@@ -174,7 +183,11 @@ func TestVerifyErrors(t *testing.T) {
 		t.Fatalf("expected no error, got %v", err)
 	}
 
-	chbox, err := NewInbox(key1, contr0, addr1, &key0.PublicKey, backend, backend.Blockchain().Config())
+	chainID, err := backend.ChainID(context.Background())
+	if err != nil {
+		t.Fatalf("expected no error, got %v", err)
+	}
+	chbox, err := NewInbox(key1, contr0, addr1, &key0.PublicKey, backend, chainID)
 	if err != nil {
 		t.Fatalf("expected no error, got %v", err)
 	}
@@ -379,7 +392,12 @@ func TestCash(t *testing.T) {
 		t.Fatalf("expected no error, got %v", err)
 	}
 	backend.Commit()
-	chbox, err := NewInbox(key1, contr0, addr1, &key0.PublicKey, backend, backend.Blockchain().Config())
+
+	chainID, err := backend.ChainID(context.Background())
+	if err != nil {
+		t.Fatalf("expected no error, got %v", err)
+	}
+	chbox, err := NewInbox(key1, contr0, addr1, &key0.PublicKey, backend, chainID)
 	if err != nil {
 		t.Fatalf("expected no error, got %v", err)
 	}

contracts/ens/ens_test.go

@@ -17,6 +17,7 @@
 package ens
 
 import (
+	"context"
 	"math/big"
 	"testing"
 
@@ -36,7 +37,11 @@ var (
 
 func TestENS(t *testing.T) {
 	contractBackend := backends.NewSimulatedBackend(core.GenesisAlloc{addr: {Balance: big.NewInt(10_000_000_000_000_000)}})
-	transactOpts, err := bind.NewKeyedTransactorWithChainID(key, contractBackend.Blockchain().Config().ChainId)
+	chainID, err := contractBackend.ChainID(context.Background())
+	if err != nil {
+		t.Fatalf("can't get chainID: %v", err)
+	}
+	transactOpts, err := bind.NewKeyedTransactorWithChainID(key, chainID)
 	if err != nil {
 		t.Fatalf("can't create TransactOpts: %v", err)
 	}

contracts/randomize/randomize_test.go

@@ -46,7 +46,11 @@ func TestRandomize(t *testing.T) {
 			Balance: big.NewInt(10_000_000_000_000_000),
 		},
 	})
-	transactOpts, err := bind.NewKeyedTransactorWithChainID(key, contractBackend.Blockchain().Config().ChainId)
+	chainID, err := contractBackend.ChainID(context.Background())
+	if err != nil {
+		t.Fatalf("expected no error, got %v", err)
+	}
+	transactOpts, err := bind.NewKeyedTransactorWithChainID(key, chainID)
 	if err != nil {
 		t.Fatalf("can't create TransactOpts: %v", err)
 	}
@@ -81,10 +85,14 @@ func TestSendTxRandomizeSecretAndOpening(t *testing.T) {
 	genesis := core.GenesisAlloc{acc1Addr: {Balance: big.NewInt(100_000_000_000_000_000)}}
 	backend := backends.NewSimulatedBackend(genesis)
 	backend.Commit()
-	signer := types.LatestSignerForChainID(backend.Blockchain().Config().ChainId)
+	chainID, err := backend.ChainID(context.Background())
+	if err != nil {
+		t.Fatalf("expected no error, got %v", err)
+	}
+	signer := types.LatestSignerForChainID(chainID)
 	ctx := context.Background()
 
-	transactOpts, err := bind.NewKeyedTransactorWithChainID(acc1Key, backend.Blockchain().Config().ChainId)
+	transactOpts, err := bind.NewKeyedTransactorWithChainID(acc1Key, chainID)
 	if err != nil {
 		t.Fatalf("can't create TransactOpts: %v", err)
 	}

contracts/tests/Inherited_test.go

@@ -1,6 +1,7 @@
 package tests
 
 import (
+	"context"
 	"fmt"
 	"math/big"
 	"os"
@@ -28,7 +29,11 @@ func TestPriceFeed(t *testing.T) {
 	contractBackend := backends.NewSimulatedBackend(core.GenesisAlloc{
 		mainAddr: {Balance: big.NewInt(0).Mul(big.NewInt(10000000000000), big.NewInt(10000000000000))},
 	})
-	transactOpts, err := bind.NewKeyedTransactorWithChainID(mainKey, contractBackend.Blockchain().Config().ChainId)
+	chainID, err := contractBackend.ChainID(context.Background())
+	if err != nil {
+		t.Fatalf("expected no error, got %v", err)
+	}
+	transactOpts, err := bind.NewKeyedTransactorWithChainID(mainKey, chainID)
 	if err != nil {
 		t.Fatalf("can't create TransactOpts: %v", err)
 	}

contracts/trc21issuer/trc21issuer_test.go

@@ -1,6 +1,7 @@
 package trc21issuer
 
 import (
+	"context"
 	"math/big"
 	"testing"
 
@@ -33,7 +34,11 @@ func TestFeeTxWithTRC21Token(t *testing.T) {
 	contractBackend := backends.NewSimulatedBackend(core.GenesisAlloc{
 		mainAddr: {Balance: big.NewInt(0).Mul(big.NewInt(10000000000000), big.NewInt(10000000000000))},
 	})
-	transactOpts, err := bind.NewKeyedTransactorWithChainID(mainKey, contractBackend.Blockchain().Config().ChainId)
+	chainID, err := contractBackend.ChainID(context.Background())
+	if err != nil {
+		t.Fatalf("expected no error, got %v", err)
+	}
+	transactOpts, err := bind.NewKeyedTransactorWithChainID(mainKey, chainID)
 	if err != nil {
 		t.Fatalf("can't create TransactOpts: %v", err)
 	}
@@ -109,7 +114,7 @@ func TestFeeTxWithTRC21Token(t *testing.T) {
 	}
 
 	// access to address which received token trc21 but dont have tomo
-	key1TransactOpts, err := bind.NewKeyedTransactorWithChainID(airdropKey, contractBackend.Blockchain().Config().ChainId)
+	key1TransactOpts, err := bind.NewKeyedTransactorWithChainID(airdropKey, chainID)
 	if err != nil {
 		t.Fatalf("can't create TransactOpts: %v", err)
 	}

contracts/validator/validator_test.go

@@ -51,7 +51,11 @@ func TestValidator(t *testing.T) {
 			Balance: big.NewInt(10_000_000_000_000_000),
 		},
 	})
-	transactOpts, err := bind.NewKeyedTransactorWithChainID(key, contractBackend.Blockchain().Config().ChainId)
+	chainID, err := contractBackend.ChainID(context.Background())
+	if err != nil {
+		t.Fatalf("expected no error, got %v", err)
+	}
+	transactOpts, err := bind.NewKeyedTransactorWithChainID(key, chainID)
 	if err != nil {
 		t.Fatalf("can't create TransactOpts: %v", err)
 	}
@@ -95,16 +99,20 @@ func TestRewardBalance(t *testing.T) {
 		acc4Addr: {Balance: new(big.Int).SetUint64(10_000_000_000_000_000)},
 	})
 
-	acc1Opts, err := bind.NewKeyedTransactorWithChainID(acc1Key, contractBackend.Blockchain().Config().ChainId)
+	chainID, err := contractBackend.ChainID(context.Background())
+	if err != nil {
+		t.Fatalf("expected no error, got %v", err)
+	}
+	acc1Opts, err := bind.NewKeyedTransactorWithChainID(acc1Key, chainID)
 	if err != nil {
 		t.Fatalf("can't create TransactOpts: %v", err)
 	}
-	acc2Opts, err := bind.NewKeyedTransactorWithChainID(acc2Key, contractBackend.Blockchain().Config().ChainId)
+	acc2Opts, err := bind.NewKeyedTransactorWithChainID(acc2Key, chainID)
 	if err != nil {
 		t.Fatalf("can't create TransactOpts: %v", err)
 	}
 	accounts := []*bind.TransactOpts{acc1Opts, acc2Opts}
-	transactOpts, err := bind.NewKeyedTransactorWithChainID(acc1Key, contractBackend.Blockchain().Config().ChainId)
+	transactOpts, err := bind.NewKeyedTransactorWithChainID(acc1Key, chainID)
 	if err != nil {
 		t.Fatalf("can't create TransactOpts: %v", err)
 	}
@@ -130,7 +138,7 @@ func TestRewardBalance(t *testing.T) {
 	contractBackend.Commit()
 
 	// Propose master node acc3Addr.
-	opts, err := bind.NewKeyedTransactorWithChainID(acc4Key, contractBackend.Blockchain().Config().ChainId)
+	opts, err := bind.NewKeyedTransactorWithChainID(acc4Key, chainID)
 	if err != nil {
 		t.Fatalf("can't create TransactOpts: %v", err)
 	}

ethclient/ethclient.go

@@ -53,6 +53,16 @@ func NewClient(c *rpc.Client) *Client {
 
 // Blockchain Access
 
+// ChainID retrieves the current chain ID for transaction replay protection.
+func (ec *Client) ChainID(ctx context.Context) (*big.Int, error) {
+	var result hexutil.Big
+	err := ec.c.CallContext(ctx, &result, "eth_chainId")
+	if err != nil {
+		return nil, err
+	}
+	return (*big.Int)(&result), err
+}
+
 // BlockByHash returns the given full block.
 //
 // Note that loading full blocks requires two requests. Use HeaderByHash

swarm/services/swap/swap.go

@@ -142,7 +142,11 @@ func NewSwap(local *SwapParams, remote *SwapProfile, backend chequebook.Backend,
 		log.Info(fmt.Sprintf("invalid contract %v for peer %v: %v)", remote.Contract.Hex()[:8], proto, err))
 	} else {
 		// remote contract valid, create inbox
-		in, err = chequebook.NewInbox(local.privateKey, remote.Contract, local.Beneficiary, crypto.ToECDSAPub(common.FromHex(remote.PublicKey)), backend, backend.Blockchain().Config())
+		chainID, err := backend.ChainID(ctx)
+		if err != nil {
+			log.Warn(fmt.Sprintf("unable to get chainID for peer %v: %v)", proto, err))
+		}
+		in, err = chequebook.NewInbox(local.privateKey, remote.Contract, local.Beneficiary, crypto.ToECDSAPub(common.FromHex(remote.PublicKey)), backend, chainID)
 		if err != nil {
 			log.Warn(fmt.Sprintf("unable to set up inbox for chequebook contract %v for peer %v: %v)", remote.Contract.Hex()[:8], proto, err))
 		}