25 files changed, 297 insertions, 1714 deletions
diff --git a/core/evm.go b/core/evm.go
index ecab8e6..796b312 100644
--- a/core/evm.go
+++ b/core/evm.go
@@ -99,7 +99,7 @@ func CanTransferMC(db vm.StateDB, addr common.Address, to common.Address, coinID
 }
 if !db.IsMultiCoin(addr) {
 err := db.EnableMultiCoin(addr)
- log.Debug("try to enable MC", "err", err)
+ log.Debug("try to enable MC", "addr", addr.Hex(), "err", err)
 }
 if !(db.IsMultiCoin(addr) && db.IsMultiCoin(to)) {
 // incompatible
@@ -124,8 +124,5 @@ func TransferMultiCoin(db vm.StateDB, sender, recipient common.Address, coinID *
 return
 }
 db.SubBalanceMultiCoin(sender, *coinID, amount)
- z := &big.Int{}
- z.Add(amount, big.NewInt(1000000000000000000))
- log.Info("hi")
- db.AddBalanceMultiCoin(recipient, *coinID, z)
+ db.AddBalanceMultiCoin(recipient, *coinID, amount)
 }
diff --git a/core/gen_genesis.go b/core/gen_genesis.go
index 05883c0..97175f7 100644
--- a/core/gen_genesis.go
+++ b/core/gen_genesis.go
@@ -15,6 +15,7 @@ import (
 
 var _ = (*genesisSpecMarshaling)(nil)
 
+// MarshalJSON marshals as JSON.
 func (g Genesis) MarshalJSON() ([]byte, error) {
 type Genesis struct {
 Config *params.ChainConfig `json:"config"`
@@ -51,6 +52,7 @@ func (g Genesis) MarshalJSON() ([]byte, error) {
 return json.Marshal(&enc)
 }
 
+// UnmarshalJSON unmarshals from JSON.
 func (g *Genesis) UnmarshalJSON(input []byte) error {
 type Genesis struct {
 Config *params.ChainConfig `json:"config"`
diff --git a/core/gen_genesis_account.go b/core/gen_genesis_account.go
index a7ef4a6..b90b658 100644
--- a/core/gen_genesis_account.go
+++ b/core/gen_genesis_account.go
@@ -14,11 +14,13 @@ import (
 
 var _ = (*genesisAccountMarshaling)(nil)
 
+// MarshalJSON marshals as JSON.
 func (g GenesisAccount) MarshalJSON() ([]byte, error) {
 type GenesisAccount struct {
 Code hexutil.Bytes `json:"code,omitempty"`
 Storage map[storageJSON]storageJSON `json:"storage,omitempty"`
 Balance *math.HexOrDecimal256 `json:"balance" gencodec:"required"`
+ MCBalance GenesisMultiCoinBalance `json:"mcbalance,omitempty"`
 Nonce math.HexOrDecimal64 `json:"nonce,omitempty"`
 PrivateKey hexutil.Bytes `json:"secretKey,omitempty"`
 }
@@ -31,16 +33,19 @@ func (g GenesisAccount) MarshalJSON() ([]byte, error) {
 }
 }
 enc.Balance = (*math.HexOrDecimal256)(g.Balance)
+ enc.MCBalance = g.MCBalance
 enc.Nonce = math.HexOrDecimal64(g.Nonce)
 enc.PrivateKey = g.PrivateKey
 return json.Marshal(&enc)
 }
 
+// UnmarshalJSON unmarshals from JSON.
 func (g *GenesisAccount) UnmarshalJSON(input []byte) error {
 type GenesisAccount struct {
 Code *hexutil.Bytes `json:"code,omitempty"`
 Storage map[storageJSON]storageJSON `json:"storage,omitempty"`
 Balance *math.HexOrDecimal256 `json:"balance" gencodec:"required"`
+ MCBalance *GenesisMultiCoinBalance `json:"mcbalance,omitempty"`
 Nonce *math.HexOrDecimal64 `json:"nonce,omitempty"`
 PrivateKey *hexutil.Bytes `json:"secretKey,omitempty"`
 }
@@ -61,6 +66,9 @@ func (g *GenesisAccount) UnmarshalJSON(input []byte) error {
 return errors.New("missing required field 'balance' for GenesisAccount")
 }
 g.Balance = (*big.Int)(dec.Balance)
+ if dec.MCBalance != nil {
+ g.MCBalance = *dec.MCBalance
+ }
 if dec.Nonce != nil {
 g.Nonce = uint64(*dec.Nonce)
 }
diff --git a/core/genesis.go b/core/genesis.go
index 347beb3..ef490bf 100644
--- a/core/genesis.go
+++ b/core/genesis.go
@@ -78,11 +78,14 @@ func (ga *GenesisAlloc) UnmarshalJSON(data []byte) error {
 return nil
 }
 
+type GenesisMultiCoinBalance map[common.Hash]*big.Int
+
 // GenesisAccount is an account in the state of the genesis block.
 type GenesisAccount struct {
 Code []byte `json:"code,omitempty"`
 Storage map[common.Hash]common.Hash `json:"storage,omitempty"`
 Balance *big.Int `json:"balance" gencodec:"required"`
+ MCBalance GenesisMultiCoinBalance `json:"mcbalance,omitempty"`
 Nonce uint64 `json:"nonce,omitempty"`
 PrivateKey []byte `json:"secretKey,omitempty"` // for tests
 }
@@ -261,6 +264,12 @@ func (g *Genesis) ToBlock(db ethdb.Database) *types.Block {
 for key, value := range account.Storage {
 statedb.SetState(addr, key, value)
 }
+ if account.MCBalance != nil {
+ statedb.ForceEnableMultiCoin(addr)
+ for coinID, value := range account.MCBalance {
+ statedb.AddBalanceMultiCoin(addr, coinID, value)
+ }
+ }
 }
 root := statedb.IntermediateRoot(false)
 head := &types.Header{
diff --git a/core/state/statedb.go b/core/state/statedb.go
index 12deebe..1d3207d 100644
--- a/core/state/statedb.go
+++ b/core/state/statedb.go
@@ -248,6 +248,11 @@ func (self *StateDB) EnableMultiCoin(addr common.Address) error {
 return nil
 }
 
+func (self *StateDB) ForceEnableMultiCoin(addr common.Address) {
+ stateObject := self.GetOrNewStateObject(addr)
+ stateObject.EnableMultiCoin()
+}
+
 func (self *StateDB) IsMultiCoin(addr common.Address) bool {
 stateObject := self.getStateObject(addr)
 if stateObject != nil {
diff --git a/core/tx_pool.go b/core/tx_pool.go
index 1acd488..5b2a3c0 100644
--- a/core/tx_pool.go
+++ b/core/tx_pool.go
@@ -528,7 +528,6 @@ func (pool *TxPool) validateTx(tx *types.Transaction, local bool) error {
 }
 // Ensure the transaction doesn't exceed the current block limit gas.
 if pool.currentMaxGas < tx.Gas() {
- fmt.Println(pool.currentMaxGas, tx.Gas())
 return ErrGasLimit
 }
 // Make sure the transaction is signed properly
diff --git a/core/types/gen_tx_json.go b/core/types/gen_tx_json.go
index 0410632..dd0d069 100644
--- a/core/types/gen_tx_json.go
+++ b/core/types/gen_tx_json.go
@@ -21,6 +21,8 @@ func (t txdata) MarshalJSON() ([]byte, error) {
 GasLimit hexutil.Uint64 `json:"gas" gencodec:"required"`
 Recipient *common.Address `json:"to" rlp:"nil"`
 Amount *hexutil.Big `json:"value" gencodec:"required"`
+ CoinID *common.Hash `json:"coinid" rlp:"nil"`
+ Amount2 *hexutil.Big `json:"value2" rlp:"nil"`
 Payload hexutil.Bytes `json:"input" gencodec:"required"`
 V *hexutil.Big `json:"v" gencodec:"required"`
 R *hexutil.Big `json:"r" gencodec:"required"`
@@ -33,6 +35,8 @@ func (t txdata) MarshalJSON() ([]byte, error) {
 enc.GasLimit = hexutil.Uint64(t.GasLimit)
 enc.Recipient = t.Recipient
 enc.Amount = (*hexutil.Big)(t.Amount)
+ enc.CoinID = t.CoinID
+ enc.Amount2 = (*hexutil.Big)(t.Amount2)
 enc.Payload = t.Payload
 enc.V = (*hexutil.Big)(t.V)
 enc.R = (*hexutil.Big)(t.R)
@@ -49,6 +53,8 @@ func (t *txdata) UnmarshalJSON(input []byte) error {
 GasLimit *hexutil.Uint64 `json:"gas" gencodec:"required"`
 Recipient *common.Address `json:"to" rlp:"nil"`
 Amount *hexutil.Big `json:"value" gencodec:"required"`
+ CoinID *common.Hash `json:"coinid" rlp:"nil"`
+ Amount2 *hexutil.Big `json:"value2" rlp:"nil"`
 Payload *hexutil.Bytes `json:"input" gencodec:"required"`
 V *hexutil.Big `json:"v" gencodec:"required"`
 R *hexutil.Big `json:"r" gencodec:"required"`
@@ -78,6 +84,12 @@ func (t *txdata) UnmarshalJSON(input []byte) error {
 return errors.New("missing required field 'value' for txdata")
 }
 t.Amount = (*big.Int)(dec.Amount)
+ if dec.CoinID != nil {
+ t.CoinID = dec.CoinID
+ }
+ if dec.Amount2 != nil {
+ t.Amount2 = (*big.Int)(dec.Amount2)
+ }
 if dec.Payload == nil {
 return errors.New("missing required field 'input' for txdata")
 }
diff --git a/core/types/transaction.go b/core/types/transaction.go
index cf9e61a..858b443 100644
--- a/core/types/transaction.go
+++ b/core/types/transaction.go
@@ -49,8 +49,8 @@ type txdata struct {
 GasLimit uint64 `json:"gas" gencodec:"required"`
 Recipient *common.Address `json:"to" rlp:"nil"` // nil means contract creation
 Amount *big.Int `json:"value" gencodec:"required"`
- CoinID *common.Hash `json:"coinid" rlp:"-"`
- Amount2 *big.Int `json:"value2"`
+ CoinID *common.Hash `json:"coinid" rlp:"nil"`
+ Amount2 *big.Int `json:"value2" rlp:"nil"`
 Payload []byte `json:"input" gencodec:"required"`
 
 // Signature values
@@ -67,7 +67,7 @@ type txdataMarshaling struct {
 Price *hexutil.Big
 GasLimit hexutil.Uint64
 Amount *hexutil.Big
- CoinID *hexutil.Bytes
+ CoinID *common.Hash
 Amount2 *hexutil.Big
 Payload hexutil.Bytes
 V *hexutil.Big
@@ -183,14 +183,14 @@ func (tx *Transaction) UnmarshalJSON(input []byte) error {
 return nil
 }
 
-func (tx *Transaction) Data() []byte { return common.CopyBytes(tx.data.Payload) }
-func (tx *Transaction) Gas() uint64 { return tx.data.GasLimit }
-func (tx *Transaction) GasPrice() *big.Int { return new(big.Int).Set(tx.data.Price) }
-func (tx *Transaction) Value() *big.Int { return new(big.Int).Set(tx.data.Amount) }
-func (tx *Transaction) CoinID() *big.Int { return big.NewInt(0) }
-func (tx *Transaction) Value2() *big.Int { return big.NewInt(0) }
-func (tx *Transaction) Nonce() uint64 { return tx.data.AccountNonce }
-func (tx *Transaction) CheckNonce() bool { return true }
+func (tx *Transaction) Data() []byte { return common.CopyBytes(tx.data.Payload) }
+func (tx *Transaction) Gas() uint64 { return tx.data.GasLimit }
+func (tx *Transaction) GasPrice() *big.Int { return new(big.Int).Set(tx.data.Price) }
+func (tx *Transaction) Value() *big.Int { return new(big.Int).Set(tx.data.Amount) }
+func (tx *Transaction) CoinID() *common.Hash { return tx.data.CoinID }
+func (tx *Transaction) Value2() *big.Int { return new(big.Int).Set(tx.data.Amount2) }
+func (tx *Transaction) Nonce() uint64 { return tx.data.AccountNonce }
+func (tx *Transaction) CheckNonce() bool { return true }
 
 // To returns the recipient address of the transaction.
 // It returns nil if the transaction is a contract creation.
diff --git a/core/vm/evm.go b/core/vm/evm.go
index ff3587c..be8b240 100644
--- a/core/vm/evm.go
+++ b/core/vm/evm.go
@@ -17,7 +17,6 @@
 package vm
 
 import (
- "fmt"
 "math/big"
 "sync/atomic"
 "time"
@@ -260,7 +259,6 @@ func (evm *EVM) Call(caller ContractRef, addr common.Address, input []byte, gas
 
 // This allows the user transfer balance of a specified coinId in addition to a normal Call().
 func (evm *EVM) CallExpert(caller ContractRef, addr common.Address, input []byte, gas uint64, value *big.Int, coinID *common.Hash, value2 *big.Int) (ret []byte, leftOverGas uint64, err error) {
- fmt.Println("CallExpert")
 if evm.vmConfig.NoRecursion && evm.depth > 0 {
 return nil, gas, nil
 }
diff --git a/eth/backend.go b/eth/backend.go
index ab43558..983909c 100644
--- a/eth/backend.go
+++ b/eth/backend.go
@@ -173,8 +173,6 @@ func New(ctx *node.ServiceContext, config *Config,
 bcb: bcb,
 }
 
- fmt.Println(eth.config.Genesis.GasLimit)
-
 bcVersion := rawdb.ReadDatabaseVersion(chainDb)
 var dbVer = "<nil>"
 if bcVersion != nil {
diff --git a/eth/gen_config.go b/eth/gen_config.go
index 617a885..d34f0b3 100644
--- a/eth/gen_config.go
+++ b/eth/gen_config.go
@@ -49,6 +49,8 @@ func (c Config) MarshalTOML() (interface{}, error) {
 RPCGasCap *big.Int `toml:",omitempty"`
 Checkpoint *params.TrustedCheckpoint `toml:",omitempty"`
 CheckpointOracle *params.CheckpointOracleConfig `toml:",omitempty"`
+ OverrideIstanbul *big.Int
+ ManualCanonical bool
 }
 var enc Config
 enc.Genesis = c.Genesis
@@ -82,6 +84,8 @@ func (c Config) MarshalTOML() (interface{}, error) {
 enc.RPCGasCap = c.RPCGasCap
 enc.Checkpoint = c.Checkpoint
 enc.CheckpointOracle = c.CheckpointOracle
+ enc.OverrideIstanbul = c.OverrideIstanbul
+ enc.ManualCanonical = c.ManualCanonical
 return &enc, nil
 }
 
@@ -119,6 +123,8 @@ func (c *Config) UnmarshalTOML(unmarshal func(interface{}) error) error {
 RPCGasCap *big.Int `toml:",omitempty"`
 Checkpoint *params.TrustedCheckpoint `toml:",omitempty"`
 CheckpointOracle *params.CheckpointOracleConfig `toml:",omitempty"`
+ OverrideIstanbul *big.Int
+ ManualCanonical *bool
 }
 var dec Config
 if err := unmarshal(&dec); err != nil {
@@ -217,5 +223,11 @@ func (c *Config) UnmarshalTOML(unmarshal func(interface{}) error) error {
 if dec.CheckpointOracle != nil {
 c.CheckpointOracle = dec.CheckpointOracle
 }
+ if dec.OverrideIstanbul != nil {
+ c.OverrideIstanbul = dec.OverrideIstanbul
+ }
+ if dec.ManualCanonical != nil {
+ c.ManualCanonical = *dec.ManualCanonical
+ }
 return nil
 }
diff --git a/eth/tracers/internal/tracers/assets.go b/eth/tracers/internal/tracers/assets.go
index d0a0bf7..b1930dc 100644
--- a/eth/tracers/internal/tracers/assets.go
+++ b/eth/tracers/internal/tracers/assets.go
@@ -3,7 +3,7 @@
 // 4byte_tracer.js (2.933kB)
 // bigram_tracer.js (1.712kB)
 // call_tracer.js (8.643kB)
-// evmdis_tracer.js (4.194kB)
+// evmdis_tracer.js (4.195kB)
 // noop_tracer.js (1.271kB)
 // opcount_tracer.js (1.372kB)
 // prestate_tracer.js (4.234kB)
@@ -28,7 +28,7 @@ import (
 func bindataRead(data []byte, name string) ([]byte, error) {
 gz, err := gzip.NewReader(bytes.NewBuffer(data))
 if err != nil {
- return nil, fmt.Errorf("read %q: %v", name, err)
+ return nil, fmt.Errorf("read %q: %w", name, err)
 }
 
 var buf bytes.Buffer
@@ -36,7 +36,7 @@ func bindataRead(data []byte, name string) ([]byte, error) {
 clErr := gz.Close()
 
 if err != nil {
- return nil, fmt.Errorf("read %q: %v", name, err)
+ return nil, fmt.Errorf("read %q: %w", name, err)
 }
 if clErr != nil {
 return nil, err
@@ -137,7 +137,7 @@ func call_tracerJs() (*asset, error) {
 return a, nil
 }
 
-var _evmdis_tracerJs = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xac\x57\xdf\x6f\xda\xca\x12\x7e\x86\xbf\x62\x94\x27\x50\x29\x60\x63\x08\x38\x27\x47\xe2\xa6\xf4\x1c\xae\xd2\x24\x02\x72\x8f\x2a\x94\x87\x05\xc6\xb0\xaa\xf1\x5a\xbb\x6b\x72\xb8\x55\xfe\xf7\xab\xd9\x59\x03\xf9\x75\xdb\x4a\xa7\x0f\x3b\xb5\x77\xbe\x6f\xbe\x9d\x19\xcf\x92\x56\x0b\xae\x54\xbe\xd7\x72\xbd\xb1\x10\xb6\x83\x73\x98\x6d\x10\xd6\xea\x23\xda\x0d\x6a\x2c\xb6\x30\x2c\xec\x46\x69\x53\x6d\xb5\x60\xb6\x91\x06\x12\x99\x22\x48\x03\xb9\xd0\x16\x54\x02\xf6\x85\x7f\x2a\x17\x5a\xe8\x7d\xb3\xda\x6a\x31\xe6\xcd\x6d\x62\x48\x34\x22\x18\x95\xd8\x47\xa1\x31\x86\xbd\x2a\x60\x29\x32\xd0\xb8\x92\xc6\x6a\xb9\x28\x2c\x82\xb4\x20\xb2\x55\x4b\x69\xd8\xaa\x95\x4c\xf6\x44\x29\x2d\x14\xd9\x0a\xb5\x0b\x6d\x51\x6f\x4d\xa9\xe3\x8f\x9b\x7b\xb8\x46\x63\x50\xc3\x1f\x98\xa1\x16\x29\xdc\x15\x8b\x54\x2e\xe1\x5a\x2e\x31\x33\x08\xc2\x40\x4e\x6f\xcc\x06\x57\xb0\x70\x74\x04\xfc\x4c\x52\xa6\x5e\x0a\x7c\x56\x45\xb6\x12\x56\xaa\xac\x01\x28\x49\x39\xec\x50\x1b\xa9\x32\xe8\x94\xa1\x3c\x61\x03\x94\x26\x92\x9a\xb0\x74\x00\x0d\x2a\x27\x5c\x1d\x44\xb6\x87\x54\xd8\x23\xf4\x27\x12\x72\x3c\xf7\x0a\x64\xe6\xc2\x6c\x54\x8e\x60\x37\xc2\xd2\xa9\x1f\x65\x9a\xc2\x02\xa1\x30\x98\x14\x69\x83\xd8\x16\x85\x85\xbf\xc6\xb3\x3f\x6f\xef\x67\x30\xbc\xf9\x0a\x7f\x0d\x27\x93\xe1\xcd\xec\xeb\x05\x3c\x4a\xbb\x51\x85\x05\xdc\x21\x53\xc9\x6d\x9e\x4a\x5c\xc1\xa3\xd0\x5a\x64\x76\x0f\x2a\x21\x86\x2f\xa3\xc9\xd5\x9f\xc3\x9b\xd9\xf0\x5f\xe3\xeb\xf1\xec\x2b\x28\x0d\x9f\xc7\xb3\x9b\xd1\x74\x0a\x9f\x6f\x27\x30\x84\xbb\xe1\x64\x36\xbe\xba\xbf\x1e\x4e\xe0\xee\x7e\x72\x77\x3b\x1d\x35\x61\x8a\xa4\x0a\x09\xff\xe3\x9c\x27\xae\x7a\x1a\x61\x85\x56\xc8\xd4\x94\x99\xf8\xaa\x0a\x30\x1b\x55\xa4\x2b\xd8\x88\x1d\x82\xc6\x25\xca\x1d\xae\x40\xc0\x52\xe5\xfb\x9f\x2e\x2a\x71\x89\x54\x65\x6b\x77\xe6\x77\x1b\x12\xc6\x09\x64\xca\x36\xc0\x20\xc2\x6f\x1b\x6b\xf3\xb8\xd5\x7a\x7c\x7c\x6c\xae\xb3\xa2\xa9\xf4\xba\x95\x32\x9d\x69\xfd\xde\xac\x12\x27\xee\xb6\x2b\x69\x66\x5a\x2c\x51\x83\x46\x5b\xe8\xcc\x80\x29\x92\x84\xfc\x2c\xc8\x2c\x51\x7a\xeb\xda\x04\x12\xad\xb6\x20\xc0\x92\x2f\x58\x05\x39\x6a\xda\xf4\x14\x1f\x8d\xdd\xa7\x4e\xe6\x4a\x1a\x61\x0c\x6e\x17\xe9\xbe\x59\xfd\x5e\xad\x18\x2b\x96\xdf\x62\x98\x7f\x57\xb9\x89\x61\xfe\xf0\xf4\xd0\xa8\x56\x2b\x59\x5e\x98\x0d\x9a\x18\xbe\xb7\x63\x68\x37\x20\x88\x21\x68\x40\xe8\xd6\x8e\x5b\x23\xb7\x76\xdd\xda\x73\xeb\xb9\x5b\xfb\x6e\x1d\xb8\x35\x68\xb3\x61\x74\xc0\x6e\x01\xfb\x05\xec\x18\xb0\x67\xc8\x9e\xa1\x8f\xc3\x81\x42\x8e\x14\x72\xa8\x90\x63\x85\xcc\xd2\x61\x97\x88\x59\x22\x66\xe9\x32\x4b\x97\x59\xba\xec\xd2\x65\x96\xae\x17\xdc\x75\xe7\xe9\x32\x4b\xf7\x9c\x9f\x98\xa5\xcb\x2c\x3d\x3e\x72\x8f\x01\x3d\x7f\x44\x06\xf4\x58\x7c\x8f\x01\x3d\x06\xf4\x19\xd0\xe7\xb0\xfd\x90\x9f\x3a\x6c\x98\xa5\xcf\x61\xfb\x3d\x36\x1c\xb6\xcf\x2c\x7d\x66\x19\xb0\xf8\x41\xe0\xf6\x06\x1c\x6f\xc0\xf1\x06\x3e\xab\x65\x5a\x7d\x5e\xdb\x3e\xb1\xed\xd0\xdb\x8e\xb7\x91\xb7\x5d\x6f\x7d\xe6\xdb\x3e\xf5\x6d\x9f\xfb\xb6\xe7\x3b\xd4\xc9\xf3\x05\x9e\x2f\xf0\x7c\x81\xe7\x0b\x3c\x5f\x59\xc9\xb2\x94\x65\x2d\x7d\x31\x03\x5f\xcd\xc0\x97\x33\xf0\xf5\x0c\x7c\x41\x03\x5f\xd1\xc0\x97\x34\xf0\x35\x0d\x42\xcf\x17\xf6\x63\x08\xc9\x0e\x62\xe8\x34\x20\xe8\xb4\x63\x88\xc8\x06\x31\x74\xc9\x86\x31\xf4\xc8\x76\x62\x38\x27\x1b\xc5\xd0\x27\xdb\x8d\x61\x40\x96\xf8\xa8\x6b\x3b\x44\x48\x8c\x1d\x52\x48\x94\x1d\x92\x48\x9c\x11\x69\x24\xd2\x88\x44\x12\x6b\x44\x2a\x89\x36\x22\x99\xc4\x1b\x45\xac\x23\xea\xb2\x8e\xa8\xc7\x3a\xa2\x73\xd6\x41\xdd\xe7\x00\x03\xd6\x41\xfd\x47\x3a\xa8\x01\x49\x87\xeb\x40\xd2\xe1\x7a\x90\x74\xb8\x2e\x24\x4a\xea\x43\xa7\xc3\x75\x22\x91\x52\x2f\x3a\x1d\xae\x1b\x89\xd6\xf5\x23\xf1\xfa\x8e\x0c\x7a\x81\xb7\xa1\xb7\x1d\x6f\x23\x67\xc3\xc8\x7f\x45\x91\xff\x8c\x22\xff\x1d\x45\x1d\xbf\xef\xfd\xdc\x47\xf0\x44\xdf\x79\xab\x05\x1a\x4d\x91\x5a\x1a\xfe\x32\xdb\xa9\x6f\x34\x9e\x37\x98\x81\x48\x53\x37\xc7\x54\xbe\x54\x2b\x34\x3c\x1f\x17\x88\x19\x48\x8b\x5a\xd0\x05\xa1\x76\xa8\xe9\x6e\x2c\x27\x93\xa3\x23\x4c\x22\x33\x91\x96\xc4\x7e\x86\xd2\x60\x92\xd9\xba\x59\xad\xf0\xfb\x18\x92\x22\x5b\xd2\xe8\xaa\xd5\xe1\xbb\xa7\x00\xbb\x91\xa6\xe9\x46\xd2\xbc\xfd\xd0\x54\xb9\xb9\x80\x52\x67\x22\xde\x92\x49\xd4\x62\x69\x0b\x91\x02\xfe\x8d\xcb\xc2\xcd\x42\x95\x80\xc8\xbc\x72\x48\x78\xe0\x57\x1c\xfe\x24\x6a\xaa\xd6\x0d\x58\x2d\x28\x78\x19\xc2\x58\xcc\x4f\x23\xd0\xb5\x81\x3b\xd4\xfb\x92\xcb\x5d\x83\x14\xf2\x3f\x5f\x7c\x38\x24\x6a\xc2\xbd\xc9\x5c\xad\x54\x76\x42\x43\xa2\xc5\x16\xe1\xf2\xf4\x74\xc7\xff\x36\x53\xcc\xd6\x76\x03\x1f\x21\x78\xb8\xa8\x7a\x04\x6a\xad\x34\x5c\x42\xaa\xd6\xcd\x35\xda\x11\x3d\xd6\xea\x17\xd5\x4a\x45\x26\x50\x73\xbb\x4c\x5f\x71\xdc\xf3\x33\xf7\xea\xec\x01\x2e\x19\x4a\x9e\x4f\x80\xa9\x41\x20\x80\xa7\xf9\x84\xb9\xdd\xd4\xea\x70\x79\x2a\xc5\xc7\xf7\x74\x2a\xa7\x4b\x05\x2e\xf9\xa9\xa2\xf2\x18\xe8\x1f\x11\xa8\xbc\x69\xd5\x4d\xb1\x5d\xa0\xae\xd5\x1b\x6e\x7b\x45\x84\x10\xc3\x73\x7e\xde\x2b\xcb\x3c\x7f\x70\xcf\x4f\x24\xc9\xa9\x77\x8a\xa9\xb6\xe5\xc9\x7f\x87\xb6\x8f\xee\xce\x9e\x6b\xdc\xa9\x1c\x2e\xe1\xe0\x38\x7f\x05\xe1\x64\x11\x22\x51\xba\x46\x28\x09\x97\xd0\xbe\x00\x09\xbf\xf1\xd9\xfc\x0d\x36\x67\xb6\xa6\xca\x1f\x2e\x40\x7e\xf8\x50\x77\xa0\x8a\x7f\xcb\x1a\x9b\xe4\xea\x72\xc4\x09\xc9\x11\xbf\xd5\x64\xbd\x69\xd5\xd4\x6a\x99\xad\x6b\x41\xaf\xee\x72\x5f\x79\xa2\xc5\x3c\x4a\xbb\x64\x7f\x97\x12\xef\x54\xf7\x67\x58\x0a\x83\x70\x76\x35\xbc\xbe\x3e\x8b\xe1\xf8\x70\x75\xfb\x69\x74\x16\x1f\x0e\x29\x33\x63\xe9\xe7\x2b\x97\xf8\x24\x6e\xa7\xde\xdc\x89\xb4\xc0\xdb\x84\xeb\x7d\x70\x97\xff\xc5\xd7\xde\xd1\x2b\x6f\x2e\xe0\xfc\x6c\x2d\x8c\x6b\x87\x17\x80\xf6\xbb\x00\xab\xde\xf2\x0f\x9e\xa7\xe1\x39\xc4\x31\xbd\x85\x0a\x4f\x50\x2f\x30\x32\xcb\x0b\x7b\xc0\x6c\x71\xab\xf4\xbe\x69\xe8\x87\x4f\xcd\xe7\xa4\x71\x48\xce\x07\x7f\xee\x17\x14\xc7\x5e\xcf\x8a\x34\x7d\xbe\xc7\x73\xe4\x9d\x4d\x95\x73\x4e\xe6\xbe\x77\x4e\x3e\x02\xd7\x02\xec\xe7\xa3\x2d\x34\x8a\x6f\x17\xc7\x8a\x7e\x1a\x5d\x8f\xfe\x18\xce\x46\xcf\x2a\x3b\x9d\x0d\x67\xe3\x2b\x7e\xf5\xe3\xda\x86\xbf\x54\xdb\xd7\x9d\x70\x3c\x87\x3b\x06\xbc\x6a\xc1\xb7\x5b\xe0\x97\x7b\xe0\x97\x9a\xe0\x58\xd0\x7f\xa2\xa2\xff\xbf\xa4\xff\x74\x4d\x27\xa3\xd9\xfd\xe4\xe6\xa4\x74\xf4\xe7\xca\x4f\x7c\x33\xde\xf5\xed\xba\x05\xaf\xdc\x79\x7c\xf9\x2b\xee\x8d\xc6\x57\x85\x6d\xb8\xd0\x1f\x4a\xd6\x77\xf4\x4e\x67\xb7\x77\xc7\xde\xbb\x1f\x5f\x8d\x0f\x43\xe5\x47\x31\xda\x0d\x68\xbf\xc3\xfa\xef\xfb\x2f\x77\x9f\x46\xd3\x99\x67\x2a\x33\x9b\x2f\x0f\x9f\xe9\x1a\xed\xdd\x55\xed\x64\x06\xca\xa4\x9c\x7f\xd2\xdc\x51\x9a\xcb\xe9\x77\x40\xa7\x98\x1d\xe0\xcf\x6e\x0e\xf8\x08\xed\xbf\xbb\x78\xe4\x3a\x0e\xf7\x97\x05\xf3\x37\x98\x23\x3e\xd6\xf5\xd9\x45\x7a\x3c\xdd\xf3\x3b\x88\xf1\xd5\xca\x53\xf5\xa9\xfa\xbf\x00\x00\x00\xff\xff\x51\x4b\xdc\x7e\x62\x10\x00\x00")
+var _evmdis_tracerJs = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xac\x57\xdf\x6f\xda\xca\x12\x7e\x86\xbf\x62\x94\x27\x50\x29\x60\x63\x08\x38\x27\x47\xe2\xa6\xf4\x1c\xae\xd2\x24\x02\x72\x8f\x2a\x94\x87\x05\xc6\xb0\xaa\xf1\x5a\xbb\x6b\x72\xb8\x55\xfe\xf7\xab\xd9\x59\x03\xf9\x75\xdb\x4a\xa7\x0f\x3b\xb5\x77\xbe\x6f\xbe\x9d\x19\xcf\x92\x56\x0b\xae\x54\xbe\xd7\x72\xbd\xb1\x10\xb6\x83\x73\x98\x6d\x10\xd6\xea\x23\xda\x0d\x6a\x2c\xb6\x30\x2c\xec\x46\x69\x53\x6d\xb5\x60\xb6\x91\x06\x12\x99\x22\x48\x03\xb9\xd0\x16\x54\x02\xf6\x85\x7f\x2a\x17\x5a\xe8\x7d\xb3\xda\x6a\x31\xe6\xcd\x6d\x62\x48\x34\x22\x18\x95\xd8\x47\xa1\x31\x86\xbd\x2a\x60\x29\x32\xd0\xb8\x92\xc6\x6a\xb9\x28\x2c\x82\xb4\x20\xb2\x55\x4b\x69\xd8\xaa\x95\x4c\xf6\x44\x29\x2d\x14\xd9\x0a\xb5\x0b\x6d\x51\x6f\x4d\xa9\xe3\x8f\x9b\x7b\xb8\x46\x63\x50\xc3\x1f\x98\xa1\x16\x29\xdc\x15\x8b\x54\x2e\xe1\x5a\x2e\x31\x33\x08\xc2\x40\x4e\x6f\xcc\x06\x57\xb0\x70\x74\x04\xfc\x4c\x52\xa6\x5e\x0a\x7c\x56\x45\xb6\x12\x56\xaa\xac\x01\x28\x49\x39\xec\x50\x1b\xa9\x32\xe8\x94\xa1\x3c\x61\x03\x94\x26\x92\x9a\xb0\x74\x00\x0d\x2a\x27\x5c\x1d\x44\xb6\x87\x54\xd8\x23\xf4\x27\x12\x72\x3c\xf7\x0a\x64\xe6\xc2\x6c\x54\x8e\x60\x37\xc2\xd2\xa9\x1f\x65\x9a\xc2\x02\xa1\x30\x98\x14\x69\x83\xd8\x16\x85\x85\xbf\xc6\xb3\x3f\x6f\xef\x67\x30\xbc\xf9\x0a\x7f\x0d\x27\x93\xe1\xcd\xec\xeb\x05\x3c\x4a\xbb\x51\x85\x05\xdc\x21\x53\xc9\x6d\x9e\x4a\x5c\xc1\xa3\xd0\x5a\x64\x76\x0f\x2a\x21\x86\x2f\xa3\xc9\xd5\x9f\xc3\x9b\xd9\xf0\x5f\xe3\xeb\xf1\xec\x2b\x28\x0d\x9f\xc7\xb3\x9b\xd1\x74\x0a\x9f\x6f\x27\x30\x84\xbb\xe1\x64\x36\xbe\xba\xbf\x1e\x4e\xe0\xee\x7e\x72\x77\x3b\x1d\x35\x61\x8a\xa4\x0a\x09\xff\xe3\x9c\x27\xae\x7a\x1a\x61\x85\x56\xc8\xd4\x94\x99\xf8\xaa\x0a\x30\x1b\x55\xa4\x2b\xd8\x88\x1d\x82\xc6\x25\xca\x1d\xae\x40\xc0\x52\xe5\xfb\x9f\x2e\x2a\x71\x89\x54\x65\x6b\x77\xe6\x77\x1b\x12\xc6\x09\x64\xca\x36\xc0\x20\xc2\x6f\x1b\x6b\xf3\xb8\xd5\x7a\x7c\x7c\x6c\xae\xb3\xa2\xa9\xf4\xba\x95\x32\x9d\x69\xfd\xde\xac\x12\x27\xee\xb6\x2b\x69\x66\x5a\x2c\x51\x83\x46\x5b\xe8\xcc\x80\x29\x92\x44\x2e\x25\x66\x16\x64\x96\x28\xbd\x75\x7d\x02\x89\x56\x5b\x10\x60\xc9\x19\xac\x82\x1c\x35\x6d\x7a\x8e\x8f\xc6\xee\x53\xa7\x73\x25\x8d\x30\x06\xb7\x8b\x74\xdf\xac\x7e\xaf\x56\x8c\x15\xcb\x6f\x31\xcc\xbf\xab\xdc\xc4\x30\x7f\x78\x7a\x68\x54\xab\x95\x2c\x2f\xcc\x06\x4d\x0c\xdf\xdb\x31\xb4\x1b\x10\xc4\x10\x34\x20\x74\x6b\xc7\xad\x91\x5b\xbb\x6e\xed\xb9\xf5\xdc\xad\x7d\xb7\x0e\xdc\x1a\xb4\xd9\x30\x3a\x60\xb7\x80\xfd\x02\x76\x0c\xd8\x33\x64\xcf\xd0\xc7\xe1\x40\x21\x47\x0a\x39\x54\xc8\xb1\x42\x66\xe9\xb0\x4b\xc4\x2c\x11\xb3\x74\x99\xa5\xcb\x2c\x5d\x76\xe9\x32\x4b\xd7\x0b\xee\xba\xf3\x74\x99\xa5\x7b\xce\x4f\xcc\xd2\x65\x96\x1e\x1f\xb9\xc7\x80\x9e\x3f\x22\x03\x7a\x2c\xbe\xc7\x80\x1e\x03\xfa\x0c\xe8\x73\xd8\x7e\xc8\x4f\x1d\x36\xcc\xd2\xe7\xb0\xfd\x1e\x1b\x0e\xdb\x67\x96\x3e\xb3\x0c\x58\xfc\x20\x70\x7b\x03\x8e\x37\xe0\x78\x03\x9f\xd5\x32\xad\x3e\xaf\x6d\x9f\xd8\x76\xe8\x6d\xc7\xdb\xc8\xdb\xae\xb7\x3e\xf3\x6d\x9f\xfa\xb6\xcf\x7d\xdb\xf3\x1d\xea\xe4\xf9\x02\xcf\x17\x78\xbe\xc0\xf3\x05\x9e\xaf\xac\x64\x59\xca\xb2\x96\xbe\x98\x81\xaf\x66\xe0\xcb\x19\xf8\x7a\x06\xbe\xa0\x81\xaf\x68\xe0\x4b\x1a\xf8\x9a\x06\xa1\xe7\x0b\xfb\x31\x84\x64\x07\x31\x74\x1a\x10\x74\xda\x31\x44\x64\x83\x18\xba\x64\xc3\x18\x7a\x64\x3b\x31\x9c\x93\x8d\x62\xe8\x93\xed\xc6\x30\x20\x4b\x7c\xd4\xb5\x1d\x22\x24\xc6\x0e\x29\x24\xca\x0e\x49\x24\xce\x88\x34\x12\x69\x44\x22\x89\x35\x22\x95\x44\x1b\x91\x4c\xe2\x8d\x22\xd6\x11\x75\x59\x47\xd4\x63\x1d\xd1\x39\xeb\xa0\xee\x73\x80\x01\xeb\xa0\xfe\x23\x1d\xd4\x80\xa4\xc3\x75\x20\xe9\x70\x3d\x48\x3a\x5c\x17\x12\x25\xf5\xa1\xd3\xe1\x3a\x91\x48\xa9\x17\x9d\x0e\xd7\x8d\x44\xeb\xfa\x91\x78\x7d\x47\x06\xbd\xc0\xdb\xd0\xdb\x8e\xb7\x91\xb3\x61\xe4\xbf\xa2\xc8\x7f\x46\x91\xff\x8e\xa2\x8e\xdf\xf7\x7e\xee\x23\x78\xa2\xef\xbc\xd5\x02\x8d\xa6\x48\x2d\x4d\x7f\x99\xed\xd4\x37\x9a\xcf\x1b\xcc\x40\xa4\xa9\x1b\x64\x2a\x5f\xaa\x15\x1a\x1e\x90\x0b\xc4\x0c\xa4\x45\x2d\xe8\x86\x50\x3b\xd4\x74\x39\x96\xa3\xc9\xd1\x11\x26\x91\x99\x48\x4b\x62\x3f\x44\x69\x30\xc9\x6c\xdd\xac\x56\xf8\x7d\x0c\x49\x91\x2d\x69\x74\xd5\xea\xf0\xdd\x53\x80\xdd\x48\xd3\x74\x23\x69\xde\x7e\x68\xaa\xdc\x5c\x40\xa9\x33\x11\x6f\xc9\x24\x6a\xb1\xb4\x85\x48\x01\xff\xc6\x65\xe1\x66\xa1\x4a\x40\x64\x5e\x39\x24\x3c\xf1\x2b\x0e\x7f\x12\x35\x55\xeb\x06\xac\x16\x14\xbc\x0c\x61\x2c\xe6\xa7\x11\xe8\xde\xc0\x1d\xea\x7d\xc9\xe5\xee\x41\x0a\xf9\x9f\x2f\x3e\x1c\x12\x35\xe1\xde\x64\xae\x56\x2a\x3b\xa1\x21\xd1\x62\x8b\x70\x79\x7a\xba\xe3\x7f\x9b\x29\x66\x6b\xbb\x81\x8f\x10\x3c\x5c\x54\x3d\x02\xb5\x56\x1a\x2e\x21\x55\xeb\xe6\x1a\xed\x88\x1e\x6b\xf5\x8b\x6a\xa5\x22\x13\xa8\xb9\x5d\xa6\xaf\x38\xee\xf9\x99\x7b\x75\xf6\x00\x97\x0c\x25\xcf\x27\xc0\xd4\x20\x10\xc0\xd3\x7c\xc2\xdc\x6e\x6a\x75\xb8\x3c\x95\xe2\xe3\x7b\x3a\x95\xd3\xa5\x02\x97\xfc\x54\x51\x79\x0c\xf4\x8f\x08\x54\xde\xb4\xea\xa6\xd8\x2e\x50\xd7\xea\x0d\xb7\xbd\x22\x42\x88\xe1\x39\x3f\xef\x95\x65\x9e\x3f\xb8\xe7\x27\x92\xe4\xd4\x3b\xc5\x54\xdb\xf2\xe4\xbf\x43\xdb\x47\x77\x67\xcf\x35\xee\x54\x0e\x97\x70\x70\x9c\xbf\x82\x70\xb2\x08\x91\x28\x5d\x23\x94\x84\x4b\x68\x5f\x80\x84\xdf\xf8\x6c\xfe\x06\x9b\x33\x5b\x53\xe5\x0f\x17\x20\x3f\x7c\xa8\x3b\x50\xc5\xbf\x65\x8d\x4d\x72\x75\x39\xe2\x84\xe4\x88\xdf\x6a\xb2\xde\xb4\x6a\x6a\xb5\xcc\xd6\xb5\xa0\x57\x77\xb9\xaf\x3c\xd1\x62\x1e\xa5\x5d\xb2\xbf\x4b\x89\x77\xaa\xfb\x33\x2c\x85\x41\x38\xbb\x1a\x5e\x5f\x9f\xc5\x70\x7c\xb8\xba\xfd\x34\x3a\x8b\x0f\x87\x94\x99\xb1\xf4\xfb\x95\x4b\x7c\x12\xb7\x53\x6f\xee\x44\x5a\xe0\x6d\xc2\xf5\x3e\xb8\xcb\xff\xe2\x6b\xef\xe8\x95\x37\x17\x70\x7e\xb6\x16\xc6\xb5\xc3\x0b\x40\xfb\x5d\x80\x55\x6f\xf9\x07\xcf\xd3\xf0\x1c\xe2\x98\xde\x42\x85\x27\xa8\x17\x18\x99\xe5\x85\x3d\x60\xb6\xb8\x55\x7a\xdf\x34\xf4\xcb\xa7\xe6\x73\xd2\x38\x24\xe7\x83\x3f\xf7\x0b\x8a\x63\xaf\x67\x45\x9a\x3e\xdf\xe3\x39\xf2\xce\xa6\xca\x39\x27\x73\xdf\x3b\x27\x1f\x81\x6b\x01\xf6\xf3\xd1\x16\x1a\xc5\xb7\x8b\x63\x45\x3f\x8d\xae\x47\x7f\x0c\x67\xa3\x67\x95\x9d\xce\x86\xb3\xf1\x15\xbf\xfa\x71\x6d\xc3\x5f\xaa\xed\xeb\x4e\x38\x9e\xc3\x1d\x03\x5e\xb5\xe0\xdb\x2d\xf0\xcb\x3d\xf0\x4b\x4d\x70\x2c\xe8\x3f\x51\xd1\xff\x5f\xd2\x7f\xba\xa6\x93\xd1\xec\x7e\x72\x73\x52\x3a\xfa\x7b\xe5\x27\xbe\x19\xef\xfa\x76\xdd\x82\x57\xee\x3c\xbe\xfc\x15\xf7\x46\xe3\xab\xc2\x36\x5c\xe8\x0f\x25\xeb\x3b\x7a\xa7\xb3\xdb\xbb\x63\xef\xdd\x8f\xaf\xc6\x87\xa1\xf2\xa3\x18\xed\x06\xb4\xdf\x61\xfd\xf7\xfd\x97\xbb\x4f\xa3\xe9\xcc\x33\x95\x99\xcd\x97\x87\xcf\x74\x8d\xf6\xee\xaa\x76\x32\x03\x65\x52\xce\x3f\x69\xee\x28\xcd\xe5\xf4\x3b\xa0\x53\xcc\x0e\xf0\x67\x37\x07\x7c\x84\xf6\xdf\x5d\x3c\x72\x1d\x87\xfb\xcb\x82\xf9\x1b\xcc\x11\x1f\xeb\xfa\xec\x22\x3d\x9e\xee\xf9\x1d\xc4\xf8\x6a\xe5\xa9\xfa\x54\xfd\x5f\x00\x00\x00\xff\xff\xdf\x2f\xd9\xfa\x63\x10\x00\x00")
 
 func evmdis_tracerJsBytes() ([]byte, error) {
 return bindataRead(
@@ -153,7 +153,7 @@ func evmdis_tracerJs() (*asset, error) {
 }
 
 info := bindataFileInfo{name: "evmdis_tracer.js", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)}
- a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xd5, 0xe8, 0x96, 0xa1, 0x8b, 0xc, 0x68, 0x3c, 0xe8, 0x5d, 0x7e, 0xf0, 0xab, 0xfe, 0xec, 0xd1, 0xb, 0x3d, 0xfc, 0xc7, 0xac, 0xb5, 0xa, 0x41, 0x55, 0x0, 0x3a, 0x60, 0xa7, 0x8e, 0x46, 0x93}}
+ a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xb5, 0xc8, 0x73, 0x8e, 0xfb, 0x1f, 0x84, 0x7d, 0x37, 0xd9, 0x26, 0x24, 0x37, 0xb8, 0x65, 0xb1, 0xed, 0xa0, 0x76, 0x9a, 0xf0, 0x8e, 0x3a, 0x9b, 0x20, 0x93, 0x27, 0x26, 0x2e, 0xc9, 0x9b, 0xde}}
 return a, nil
 }
 
@@ -348,25 +348,20 @@ func AssetNames() []string {
 
 // _bindata is a table, holding each asset generator, mapped to its name.
 var _bindata = map[string]func() (*asset, error){
- "4byte_tracer.js": _4byte_tracerJs,
-
- "bigram_tracer.js": bigram_tracerJs,
-
- "call_tracer.js": call_tracerJs,
-
- "evmdis_tracer.js": evmdis_tracerJs,
-
- "noop_tracer.js": noop_tracerJs,
-
- "opcount_tracer.js": opcount_tracerJs,
-
+ "4byte_tracer.js": _4byte_tracerJs,
+ "bigram_tracer.js": bigram_tracerJs,
+ "call_tracer.js": call_tracerJs,
+ "evmdis_tracer.js": evmdis_tracerJs,
+ "noop_tracer.js": noop_tracerJs,
+ "opcount_tracer.js": opcount_tracerJs,
 "prestate_tracer.js": prestate_tracerJs,
-
- "trigram_tracer.js": trigram_tracerJs,
-
- "unigram_tracer.js": unigram_tracerJs,
+ "trigram_tracer.js": trigram_tracerJs,
+ "unigram_tracer.js": unigram_tracerJs,
 }
 
+// AssetDebug is true if the assets were built with the debug flag enabled.
+const AssetDebug = false
+
 // AssetDir returns the file names below a certain
 // directory embedded in the file by go-bindata.
 // For example if you run go-bindata on data/... and data contains the
diff --git a/examples/chain/main.go b/examples/chain/main.go
index d474c2b..5edd055 100644
--- a/examples/chain/main.go
+++ b/examples/chain/main.go
@@ -7,10 +7,10 @@ import (
 "github.com/ava-labs/coreth/core"
 "github.com/ava-labs/coreth/core/types"
 "github.com/ava-labs/coreth/eth"
+ "github.com/ava-labs/coreth/params"
 "github.com/ava-labs/go-ethereum/common"
 "github.com/ava-labs/go-ethereum/common/hexutil"
 "github.com/ava-labs/go-ethereum/log"
- "github.com/ava-labs/go-ethereum/params"
 "github.com/ava-labs/go-ethereum/rlp"
 "math/big"
 "sync"
diff --git a/examples/counter/main.go b/examples/counter/main.go
index 48a0e6f..85aa9d1 100644
--- a/examples/counter/main.go
+++ b/examples/counter/main.go
@@ -9,11 +9,11 @@ import (
 "github.com/ava-labs/coreth/core"
 "github.com/ava-labs/coreth/core/types"
 "github.com/ava-labs/coreth/eth"
+ "github.com/ava-labs/coreth/params"
 "github.com/ava-labs/go-ethereum/common"
 "github.com/ava-labs/go-ethereum/common/compiler"
 "github.com/ava-labs/go-ethereum/crypto"
 "github.com/ava-labs/go-ethereum/log"
- "github.com/ava-labs/go-ethereum/params"
 "go/build"
 "math/big"
 "os"
diff --git a/examples/multicoin/main.go b/examples/multicoin/main.go
new file mode 100644
index 0000000..3e42010
--- /dev/null
+++ b/examples/multicoin/main.go
@@ -0,0 +1,218 @@
+package main
+
+import (
+ "crypto/rand"
+ //"encoding/hex"
+ "encoding/json"
+ "fmt"
+ "github.com/ava-labs/coreth"
+ "github.com/ava-labs/coreth/core"
+ "github.com/ava-labs/coreth/eth"
+ //"github.com/ava-labs/coreth/accounts/abi"
+ "github.com/ava-labs/coreth/core/types"
+ "github.com/ava-labs/coreth/params"
+ "github.com/ava-labs/go-ethereum/common"
+ "github.com/ava-labs/go-ethereum/common/compiler"
+ "github.com/ava-labs/go-ethereum/crypto"
+ "github.com/ava-labs/go-ethereum/log"
+ "go/build"
+ "math/big"
+ "os"
+ "os/signal"
+ "path/filepath"
+ //"strings"
+ "syscall"
+ "time"
+)
+
+var (
+ codeHex = "6101c7610026600b82828239805160001a60731461001957fe5b30600052607381538281f3fe730000000000000000000000000000000000000000301460806040526004361061004b5760003560e01c80631e01043914610050578063abb24ba014610092578063b6510bb3146100a9575b600080fd5b61007c6004803603602081101561006657600080fd5b8101908080359060200190929190505050610118565b6040518082815260200191505060405180910390f35b81801561009e57600080fd5b506100a761013b565b005b8180156100b557600080fd5b50610116600480360360808110156100cc57600080fd5b81019080803573ffffffffffffffffffffffffffffffffffffffff16906020019092919080359060200190929190803590602001909291908035906020019092919050505061013e565b005b60003373ffffffffffffffffffffffffffffffffffffffff1682905d9050919050565b5c565b8373ffffffffffffffffffffffffffffffffffffffff1681836108fc8690811502906040516000604051808303818888878c8af69550505050505015801561018a573d6000803e3d6000fd5b505050505056fea26469706673582212204e4689067358d8e82903012dcaca0c004d36e39fc99360919fb824c4ce718bdd64736f6c634300060a0033"
+ codeABI = `[{"inputs":[{"internalType":"uint256","name":"coinid","type":"uint256"}],"name":"getBalance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"}]`
+)
+
+func checkError(err error) {
+ if err != nil {
+ panic(err)
+ }
+}
+
+func main() {
+ // configure the chain
+ config := eth.DefaultConfig
+ config.ManualCanonical = true
+ chainConfig := &params.ChainConfig{
+ ChainID: big.NewInt(1),
+ HomesteadBlock: big.NewInt(0),
+ DAOForkBlock: big.NewInt(0),
+ DAOForkSupport: true,
+ EIP150Block: big.NewInt(0),
+ EIP150Hash: common.HexToHash("0x2086799aeebeae135c246c65021c82b4e15a2c451340993aacfd2751886514f0"),
+ EIP155Block: big.NewInt(0),
+ EIP158Block: big.NewInt(0),
+ ByzantiumBlock: big.NewInt(0),
+ ConstantinopleBlock: big.NewInt(0),
+ PetersburgBlock: big.NewInt(0),
+ IstanbulBlock: nil,
+ Ethash: nil,
+ }
+
+ // configure the genesis block
+ //genBalance := big.NewInt(100000000000000000)
+ genKey, _ := coreth.NewKey(rand.Reader)
+ bob, _ := coreth.NewKey(rand.Reader)
+
+ g := new(core.Genesis)
+ b := `{"config":{"chainId":1,"homesteadBlock":0,"daoForkBlock":0,"daoForkSupport":true,"eip150Block":0,"eip150Hash":"0x2086799aeebeae135c246c65021c82b4e15a2c451340993aacfd2751886514f0","eip155Block":0,"eip158Block":0,"byzantiumBlock":0,"constantinopleBlock":0,"petersburgBlock":0},"nonce":"0x0","timestamp":"0x0","extraData":"0x00","gasLimit":"0x5f5e100","difficulty":"0x0","mixHash":"0x0000000000000000000000000000000000000000000000000000000000000000","coinbase":"0x0000000000000000000000000000000000000000","alloc":{"751a0b96e1042bee789452ecb20253fba40dbe85":{"balance":"0x1000000000000000", "mcbalance": {"0x0000000000000000000000000000000000000000000000000000000000000000": 1000000000000000000}}},"number":"0x0","gasUsed":"0x0","parentHash":"0x0000000000000000000000000000000000000000000000000000000000000000"}`
+ k := "0xabd71b35d559563fea757f0f5edbde286fb8c043105b15abb7cd57189306d7d1"
+ err := json.Unmarshal([]byte(b), g)
+ checkError(err)
+ config.Genesis = g
+ hk, _ := crypto.HexToECDSA(k[2:])
+ genKey = coreth.NewKeyFromECDSA(hk)
+ //config.Genesis = &core.Genesis{
+ // Config: chainConfig,
+ // Nonce: 0,
+ // Number: 0,
+ // ExtraData: hexutil.MustDecode("0x00"),
+ // GasLimit: 100000000,
+ // Difficulty: big.NewInt(0),
+ // Alloc: core.GenesisAlloc{genKey.Address: {Balance: genBalance}},
+ //}
+
+ // grab the control of block generation and disable auto uncle
+ config.Miner.ManualMining = true
+ config.Miner.ManualUncle = true
+
+ // compile the smart contract
+ gopath := os.Getenv("GOPATH")
+ if gopath == "" {
+ gopath = build.Default.GOPATH
+ }
+
+ // info required to generate a transaction
+ chainID := chainConfig.ChainID
+ nonce := uint64(0)
+ gasLimit := 10000000
+ gasPrice := big.NewInt(1000000000)
+
+ blockCount := 0
+ chain := coreth.NewETHChain(&config, nil, nil, nil)
+ newTxPoolHeadChan := make(chan core.NewTxPoolHeadEvent, 1)
+ log.Info(chain.GetGenesisBlock().Hash().Hex())
+ firstBlock := false
+ var contractAddr common.Address
+ coin0 := common.HexToHash("0x0")
+ //var calls [][]byte
+ postGen := func(block *types.Block) bool {
+ if blockCount == 15 {
+ state, err := chain.CurrentState()
+ checkError(err)
+ log.Info(fmt.Sprintf("genesis balance = %s", state.GetBalance(genKey.Address)))
+ log.Info(fmt.Sprintf("genesis balance2 = %s", state.GetBalanceMultiCoin(genKey.Address, coin0)))
+ log.Info(fmt.Sprintf("contract balance = %s", state.GetBalance(contractAddr)))
+ log.Info(fmt.Sprintf("bob's balance = %s", state.GetBalance(bob.Address)))
+ log.Info(fmt.Sprintf("bob's balance2 = %s", state.GetBalanceMultiCoin(bob.Address, coin0)))
+ log.Info(fmt.Sprintf("state = %s", state.Dump(true, false, true)))
+ log.Info(fmt.Sprintf("x = %s", state.GetState(contractAddr, common.BigToHash(big.NewInt(0))).String()))
+ return true
+ }
+ if !firstBlock {
+ firstBlock = true
+ receipts := chain.GetReceiptsByHash(block.Hash())
+ if len(receipts) != 1 {
+ panic(fmt.Sprintf("# receipts is %d != 1", len(receipts)))
+ }
+ contractAddr = receipts[0].ContractAddress
+ txHash := receipts[0].TxHash
+ log.Info(fmt.Sprintf("deploy tx = %s", txHash.String()))
+ log.Info(fmt.Sprintf("contract addr = %s", contractAddr.String()))
+ //var call []byte
+ //if len(calls) > 0 {
+ // call = calls[0]
+ // calls = calls[1:]
+ //} else {
+ // call = nil
+ //}
+ //state, _ := chain.CurrentState()
+ //call := common.Hex2Bytes("1003e2d20000000000000000000000000000000000000000000000000000000000000001")
+ //log.Info(fmt.Sprintf("code = %s", hex.EncodeToString(state.GetCode(contractAddr))))
+ go func() {
+ tx := types.NewTransaction(nonce, bob.Address, big.NewInt(300000000000000000), uint64(gasLimit), gasPrice, nil)
+ signedTx, err := types.SignTx(tx, types.NewEIP155Signer(chainID), genKey.PrivateKey)
+ checkError(err)
+ chain.AddRemoteTxs([]*types.Transaction{signedTx})
+ nonce++
+ time.Sleep(20 * time.Millisecond)
+
+ // self-loop tx to enable MC
+ tx = types.NewTransaction(0, bob.Address, big.NewInt(1), uint64(gasLimit), gasPrice, nil)
+ tx.SetMultiCoinValue(&coin0, big.NewInt(0))
+ signedTx, err = types.SignTx(tx, types.NewEIP155Signer(chainID), bob.PrivateKey)
+ checkError(err)
+ chain.AddRemoteTxs([]*types.Transaction{signedTx})
+ time.Sleep(20 * time.Millisecond)
+
+ for i := 0; i < 10; i++ {
+ tx := types.NewTransaction(nonce, bob.Address, big.NewInt(10000000000000000), uint64(gasLimit), gasPrice, nil)
+ tx.SetMultiCoinValue(&coin0, big.NewInt(100000000000000000))
+ signedTx, err := types.SignTx(tx, types.NewEIP155Signer(chainID), genKey.PrivateKey)
+ checkError(err)
+ chain.AddRemoteTxs([]*types.Transaction{signedTx})
+ nonce++
+ }
+ }()
+ }
+ return false
+ }
+ chain.SetOnHeaderNew(func(header *types.Header) {
+ hid := make([]byte, 32)
+ _, err := rand.Read(hid)
+ if err != nil {
+ panic("cannot generate hid")
+ }
+ header.Extra = append(header.Extra, hid...)
+ })
+ chain.SetOnSealFinish(func(block *types.Block) error {
+ blockCount++
+ if postGen(block) {
+ return nil
+ }
+ go func() {
+ <-newTxPoolHeadChan
+ time.Sleep(10 * time.Millisecond)
+ chain.GenBlock()
+ }()
+ return nil
+ })
+
+ // start the chain
+ chain.GetTxPool().SubscribeNewHeadEvent(newTxPoolHeadChan)
+ chain.Start()
+
+ //code := common.Hex2Bytes(codeHex)
+ counterSrc, err := filepath.Abs(gopath + "/src/github.com/ava-labs/coreth/examples/counter/counter.sol")
+ checkError(err)
+ contracts, err := compiler.CompileSolidity("", counterSrc)
+ checkError(err)
+ contract, _ := contracts[fmt.Sprintf("%s:%s", counterSrc, "Counter")]
+ code := common.Hex2Bytes(contract.Code[2:])
+
+ //abi, err := abi.JSON(strings.NewReader(codeABI))
+ //cc, err := abi.Pack("getBalance", big.NewInt(0))
+ //checkError(err)
+ //calls = append(calls, cc)
+ tx := types.NewContractCreation(nonce, big.NewInt(0), uint64(gasLimit), gasPrice, code)
+ signedTx, err := types.SignTx(tx, types.NewEIP155Signer(chainID), genKey.PrivateKey)
+ checkError(err)
+ chain.AddRemoteTxs([]*types.Transaction{signedTx})
+ time.Sleep(1000 * time.Millisecond)
+ nonce++
+
+ chain.GenBlock()
+
+ c := make(chan os.Signal, 1)
+ signal.Notify(c, os.Interrupt, syscall.SIGTERM)
+ signal.Notify(c, os.Interrupt, syscall.SIGINT)
+ <-c
+ chain.Stop()
+}
diff --git a/plugin/evm/static_service_test.go b/plugin/evm/static_service_test.go
deleted file mode 100644
index c492798..0000000
--- a/plugin/evm/static_service_test.go
+++ /dev/null
@@ -1,64 +0,0 @@
-// (c) 2019-2020, Ava Labs, Inc. All rights reserved.
-// See the file LICENSE for licensing terms.
-
-package evm
-
-import (
- "math/big"
- "testing"
-
- "github.com/ava-labs/go-ethereum/common"
- "github.com/ava-labs/go-ethereum/params"
-
- "github.com/ava-labs/coreth/core"
-)
-
-func TestBuildGenesis(t *testing.T) {
- expected := "3wP629bGfSGj9trh1UNBp5qGRGCcma5d8ezLeSmd9hnUJjSMUJesHHoxbZNcVUC9CjH7PEGNA96htNTd1saZCMt1Mf1dZFG7JDhcYNok6RS4TZufejXdxbVVgquohSa7nCCcrXpiVeiRFwzLJAxyQbXzYRhaCRtcDDfCcqfaVdtkFsPbNeQ49pDTbEC5hVkmfopeQ2Zz8tAG5QXKBdbYBCukR3xNHJ4xDxeixmEwPr1odb42yQRYrL7xREKNn2LFoFwAWUjBTsCkf5GPNgY2GvvN9o8wFWXTroW5fp754DhpdxHYxkMTfuE9DGyNWHTyrEbrUHutUdsfitcSHVj5ctFtkN2wGCs3cyv1eRRNvFFMggWTbarjne6AYaeCrJ631qAu3CbrUtrTH5N2E6G2yQKX4sT4Sk3qWPJdsGXuT95iKKcgNn1u5QRHHw9DXXuGPpJjkcKQRGUCuqpXy61iF5RNPEwAwKDa8f2Y25WMmNgWynUuLj8iSAyePj7USPWk54QFUr86ApVzqAdzzdD1qSVScpmudGnGbz9UNXdzHqSot6XLrNTYsgkabiu6TGntFm7qywbCRmtNdBuT9aznGQdUVimjt5QzUz68HXhUxBzTkrz7yXfVGV5JcWxVHQXYS4oc41U5yu83mH3A7WBrZLVq6UyNrvQVbim5nDxeKKbALPxwzVwywjgY5cp39AvzGnY8CX2AtuBNnKmZaAvG8JWAkx3yxjnJrwWhLgpDQYcCvRp2jg1EPBqN8FKJxSPE6eedjDHDJfB57mNzyEtmg22BPnem3eLdiovX8awkhBUHdE7uPrapNSVprnS85u1saW2Kwza3FsS2jAM3LckGW8KdtfPTpHBTRKAUo49zZLuPsyGL5WduedGyAdaM3a2KPoyXuz4UbexTVUWFNypFvvgyoDS8FMxDCNoMMaD7y4yVnoDpSpVFEVZD6EuSGHe9U8Ew57xLPbjhepDx6"
-
- balance, success := new(big.Int).SetString("33b2e3c9fd0804000000000", 16)
- if !success {
- t.Fatal("Failed to initialize balance")
- }
-
- args := core.Genesis{
- Config: &params.ChainConfig{
- ChainID: big.NewInt(43110),
- HomesteadBlock: big.NewInt(0),
- DAOForkBlock: big.NewInt(0),
- DAOForkSupport: true,
- EIP150Block: big.NewInt(0),
- EIP150Hash: common.HexToHash("0x2086799aeebeae135c246c65021c82b4e15a2c451340993aacfd2751886514f0"),
- EIP155Block: big.NewInt(0),
- EIP158Block: big.NewInt(0),
- ByzantiumBlock: big.NewInt(0),
- ConstantinopleBlock: big.NewInt(0),
- PetersburgBlock: big.NewInt(0),
- },
- Nonce: 0,
- Timestamp: 0,
- ExtraData: []byte{},
- GasLimit: 100000000,
- Difficulty: big.NewInt(0),
- Mixhash: common.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000000"),
- Coinbase: common.HexToAddress("0x0000000000000000000000000000000000000000"),
- Alloc: core.GenesisAlloc{
- common.HexToAddress("751a0b96e1042bee789452ecb20253fba40dbe85"): core.GenesisAccount{
- Balance: balance,
- },
- },
- Number: 0,
- GasUsed: 0,
- ParentHash: common.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000000"),
- }
-
- ss := StaticService{}
- result, err := ss.BuildGenesis(nil, &args)
- if err != nil {
- t.Fatal(err)
- }
-
- if result.String() != expected {
- t.Fatalf("StaticService.BuildGenesis:\nReturned: %s\nExpected: %s", result, expected)
- }
-}
diff --git a/plugin/evm/vm_genesis_parse_test.go b/plugin/evm/vm_genesis_parse_test.go
deleted file mode 100644
index 9a113fb..0000000
--- a/plugin/evm/vm_genesis_parse_test.go
+++ /dev/null
@@ -1,32 +0,0 @@
-// (c) 2019-2020, Ava Labs, Inc. All rights reserved.
-// See the file LICENSE for licensing terms.
-
-package evm
-
-import (
- "encoding/json"
- "testing"
-
- "github.com/ava-labs/coreth/core"
-)
-
-func TestParseGenesis(t *testing.T) {
- genesis := []byte(`{"config":{"chainId":43110,"homesteadBlock":0,"daoForkBlock":0,"daoForkSupport":true,"eip150Block":0,"eip150Hash":"0x2086799aeebeae135c246c65021c82b4e15a2c451340993aacfd2751886514f0","eip155Block":0,"eip158Block":0,"byzantiumBlock":0,"constantinopleBlock":0,"petersburgBlock":0},"nonce":"0x0","timestamp":"0x0","extraData":"0x00","gasLimit":"0x5f5e100","difficulty":"0x0","mixHash":"0x0000000000000000000000000000000000000000000000000000000000000000","coinbase":"0x0000000000000000000000000000000000000000","alloc":{"751a0b96e1042bee789452ecb20253fba40dbe85":{"balance":"0x33b2e3c9fd0804000000000"}},"number":"0x0","gasUsed":"0x0","parentHash":"0x0000000000000000000000000000000000000000000000000000000000000000"}`)
-
- genesisBlock := new(core.Genesis)
- err := json.Unmarshal(genesis, genesisBlock)
- if err != nil {
- t.Fatal(err)
- }
-
- marshalledBytes, err := json.Marshal(genesisBlock)
- if err != nil {
- t.Fatal(err)
- }
-
- secondGenesisBlock := new(core.Genesis)
- err = json.Unmarshal(marshalledBytes, secondGenesisBlock)
- if err != nil {
- t.Fatal(err)
- }
-}
diff --git a/rpc/client_example_test.go b/rpc/client_example_test.go
deleted file mode 100644
index 149de2c..0000000
--- a/rpc/client_example_test.go
+++ /dev/null
@@ -1,88 +0,0 @@
-// Copyright 2016 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
-
-package rpc_test
-
-import (
- "context"
- "fmt"
- "math/big"
- "time"
-
- "github.com/ava-labs/go-ethereum/rpc"
-)
-
-// In this example, our client wishes to track the latest 'block number'
-// known to the server. The server supports two methods:
-//
-// eth_getBlockByNumber("latest", {})
-// returns the latest block object.
-//
-// eth_subscribe("newBlocks")
-// creates a subscription which fires block objects when new blocks arrive.
-
-type Block struct {
- Number *big.Int
-}
-
-func ExampleClientSubscription() {
- // Connect the client.
- client, _ := rpc.Dial("ws://127.0.0.1:8485")
- subch := make(chan Block)
-
- // Ensure that subch receives the latest block.
- go func() {
- for i := 0; ; i++ {
- if i > 0 {
- time.Sleep(2 * time.Second)
- }
- subscribeBlocks(client, subch)
- }
- }()
-
- // Print events from the subscription as they arrive.
- for block := range subch {
- fmt.Println("latest block:", block.Number)
- }
-}
-
-// subscribeBlocks runs in its own goroutine and maintains
-// a subscription for new blocks.
-func subscribeBlocks(client *rpc.Client, subch chan Block) {
- ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
- defer cancel()
-
- // Subscribe to new blocks.
- sub, err := client.EthSubscribe(ctx, subch, "newHeads")
- if err != nil {
- fmt.Println("subscribe error:", err)
- return
- }
-
- // The connection is established now.
- // Update the channel with the current block.
- var lastBlock Block
- if err := client.CallContext(ctx, &lastBlock, "eth_getBlockByNumber", "latest"); err != nil {
- fmt.Println("can't get latest block:", err)
- return
- }
- subch <- lastBlock
-
- // The subscription will deliver events to the channel. Wait for the
- // subscription to end for any reason, then loop around to re-establish
- // the connection.
- fmt.Println("connection lost: ", <-sub.Err())
-}
diff --git a/rpc/client_test.go b/rpc/client_test.go
deleted file mode 100644
index 79ea32e..0000000
--- a/rpc/client_test.go
+++ /dev/null
@@ -1,569 +0,0 @@
-// Copyright 2016 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
-
-package rpc
-
-import (
- "context"
- "fmt"
- "math/rand"
- "net"
- "net/http"
- "net/http/httptest"
- "os"
- "reflect"
- "runtime"
- "sync"
- "testing"
- "time"
-
- "github.com/davecgh/go-spew/spew"
- "github.com/ava-labs/go-ethereum/log"
-)
-
-func TestClientRequest(t *testing.T) {
- server := newTestServer()
- defer server.Stop()
- client := DialInProc(server)
- defer client.Close()
-
- var resp Result
- if err := client.Call(&resp, "test_echo", "hello", 10, &Args{"world"}); err != nil {
- t.Fatal(err)
- }
- if !reflect.DeepEqual(resp, Result{"hello", 10, &Args{"world"}}) {
- t.Errorf("incorrect result %#v", resp)
- }
-}
-
-func TestClientBatchRequest(t *testing.T) {
- server := newTestServer()
- defer server.Stop()
- client := DialInProc(server)
- defer client.Close()
-
- batch := []BatchElem{
- {
- Method: "test_echo",
- Args: []interface{}{"hello", 10, &Args{"world"}},
- Result: new(Result),
- },
- {
- Method: "test_echo",
- Args: []interface{}{"hello2", 11, &Args{"world"}},
- Result: new(Result),
- },
- {
- Method: "no_such_method",
- Args: []interface{}{1, 2, 3},
- Result: new(int),
- },
- }
- if err := client.BatchCall(batch); err != nil {
- t.Fatal(err)
- }
- wantResult := []BatchElem{
- {
- Method: "test_echo",
- Args: []interface{}{"hello", 10, &Args{"world"}},
- Result: &Result{"hello", 10, &Args{"world"}},
- },
- {
- Method: "test_echo",
- Args: []interface{}{"hello2", 11, &Args{"world"}},
- Result: &Result{"hello2", 11, &Args{"world"}},
- },
- {
- Method: "no_such_method",
- Args: []interface{}{1, 2, 3},
- Result: new(int),
- Error: &jsonError{Code: -32601, Message: "the method no_such_method does not exist/is not available"},
- },
- }
- if !reflect.DeepEqual(batch, wantResult) {
- t.Errorf("batch results mismatch:\ngot %swant %s", spew.Sdump(batch), spew.Sdump(wantResult))
- }
-}
-
-func TestClientNotify(t *testing.T) {
- server := newTestServer()
- defer server.Stop()
- client := DialInProc(server)
- defer client.Close()
-
- if err := client.Notify(context.Background(), "test_echo", "hello", 10, &Args{"world"}); err != nil {
- t.Fatal(err)
- }
-}
-
-// func TestClientCancelInproc(t *testing.T) { testClientCancel("inproc", t) }
-func TestClientCancelWebsocket(t *testing.T) { testClientCancel("ws", t) }
-func TestClientCancelHTTP(t *testing.T) { testClientCancel("http", t) }
-func TestClientCancelIPC(t *testing.T) { testClientCancel("ipc", t) }
-
-// This test checks that requests made through CallContext can be canceled by canceling
-// the context.
-func testClientCancel(transport string, t *testing.T) {
- // These tests take a lot of time, run them all at once.
- // You probably want to run with -parallel 1 or comment out
- // the call to t.Parallel if you enable the logging.
- t.Parallel()
-
- server := newTestServer()
- defer server.Stop()
-
- // What we want to achieve is that the context gets canceled
- // at various stages of request processing. The interesting cases
- // are:
- // - cancel during dial
- // - cancel while performing a HTTP request
- // - cancel while waiting for a response
- //
- // To trigger those, the times are chosen such that connections
- // are killed within the deadline for every other call (maxKillTimeout
- // is 2x maxCancelTimeout).
- //
- // Once a connection is dead, there is a fair chance it won't connect
- // successfully because the accept is delayed by 1s.
- maxContextCancelTimeout := 300 * time.Millisecond
- fl := &flakeyListener{
- maxAcceptDelay: 1 * time.Second,
- maxKillTimeout: 600 * time.Millisecond,
- }
-
- var client *Client
- switch transport {
- case "ws", "http":
- c, hs := httpTestClient(server, transport, fl)
- defer hs.Close()
- client = c
- case "ipc":
- c, l := ipcTestClient(server, fl)
- defer l.Close()
- client = c
- default:
- panic("unknown transport: " + transport)
- }
-
- // The actual test starts here.
- var (
- wg sync.WaitGroup
- nreqs = 10
- ncallers = 6
- )
- caller := func(index int) {
- defer wg.Done()
- for i := 0; i < nreqs; i++ {
- var (
- ctx context.Context
- cancel func()
- timeout = time.Duration(rand.Int63n(int64(maxContextCancelTimeout)))
- )
- if index < ncallers/2 {
- // For half of the callers, create a context without deadline
- // and cancel it later.
- ctx, cancel = context.WithCancel(context.Background())
- time.AfterFunc(timeout, cancel)
- } else {
- // For the other half, create a context with a deadline instead. This is
- // different because the context deadline is used to set the socket write
- // deadline.
- ctx, cancel = context.WithTimeout(context.Background(), timeout)
- }
- // Now perform a call with the context.
- // The key thing here is that no call will ever complete successfully.
- sleepTime := maxContextCancelTimeout + 20*time.Millisecond
- err := client.CallContext(ctx, nil, "test_sleep", sleepTime)
- if err != nil {
- log.Debug(fmt.Sprint("got expected error:", err))
- } else {
- t.Errorf("no error for call with %v wait time", timeout)
- }
- cancel()
- }
- }
- wg.Add(ncallers)
- for i := 0; i < ncallers; i++ {
- go caller(i)
- }
- wg.Wait()
-}
-
-func TestClientSubscribeInvalidArg(t *testing.T) {
- server := newTestServer()
- defer server.Stop()
- client := DialInProc(server)
- defer client.Close()
-
- check := func(shouldPanic bool, arg interface{}) {
- defer func() {
- err := recover()
- if shouldPanic && err == nil {
- t.Errorf("EthSubscribe should've panicked for %#v", arg)
- }
- if !shouldPanic && err != nil {
- t.Errorf("EthSubscribe shouldn't have panicked for %#v", arg)
- buf := make([]byte, 1024*1024)
- buf = buf[:runtime.Stack(buf, false)]
- t.Error(err)
- t.Error(string(buf))
- }
- }()
- client.EthSubscribe(context.Background(), arg, "foo_bar")
- }
- check(true, nil)
- check(true, 1)
- check(true, (chan int)(nil))
- check(true, make(<-chan int))
- check(false, make(chan int))
- check(false, make(chan<- int))
-}
-
-func TestClientSubscribe(t *testing.T) {
- server := newTestServer()
- defer server.Stop()
- client := DialInProc(server)
- defer client.Close()
-
- nc := make(chan int)
- count := 10
- sub, err := client.Subscribe(context.Background(), "nftest", nc, "someSubscription", count, 0)
- if err != nil {
- t.Fatal("can't subscribe:", err)
- }
- for i := 0; i < count; i++ {
- if val := <-nc; val != i {
- t.Fatalf("value mismatch: got %d, want %d", val, i)
- }
- }
-
- sub.Unsubscribe()
- select {
- case v := <-nc:
- t.Fatal("received value after unsubscribe:", v)
- case err := <-sub.Err():
- if err != nil {
- t.Fatalf("Err returned a non-nil error after explicit unsubscribe: %q", err)
- }
- case <-time.After(1 * time.Second):
- t.Fatalf("subscription not closed within 1s after unsubscribe")
- }
-}
-
-// In this test, the connection drops while Subscribe is waiting for a response.
-func TestClientSubscribeClose(t *testing.T) {
- server := newTestServer()
- service := &notificationTestService{
- gotHangSubscriptionReq: make(chan struct{}),
- unblockHangSubscription: make(chan struct{}),
- }
- if err := server.RegisterName("nftest2", service); err != nil {
- t.Fatal(err)
- }
-
- defer server.Stop()
- client := DialInProc(server)
- defer client.Close()
-
- var (
- nc = make(chan int)
- errc = make(chan error)
- sub *ClientSubscription
- err error
- )
- go func() {
- sub, err = client.Subscribe(context.Background(), "nftest2", nc, "hangSubscription", 999)
- errc <- err
- }()
-
- <-service.gotHangSubscriptionReq
- client.Close()
- service.unblockHangSubscription <- struct{}{}
-
- select {
- case err := <-errc:
- if err == nil {
- t.Errorf("Subscribe returned nil error after Close")
- }
- if sub != nil {
- t.Error("Subscribe returned non-nil subscription after Close")
- }
- case <-time.After(1 * time.Second):
- t.Fatalf("Subscribe did not return within 1s after Close")
- }
-}
-
-// This test reproduces https://github.com/ethereum/go-ethereum/issues/17837 where the
-// client hangs during shutdown when Unsubscribe races with Client.Close.
-func TestClientCloseUnsubscribeRace(t *testing.T) {
- server := newTestServer()
- defer server.Stop()
-
- for i := 0; i < 20; i++ {
- client := DialInProc(server)
- nc := make(chan int)
- sub, err := client.Subscribe(context.Background(), "nftest", nc, "someSubscription", 3, 1)
- if err != nil {
- t.Fatal(err)
- }
- go client.Close()
- go sub.Unsubscribe()
- select {
- case <-sub.Err():
- case <-time.After(5 * time.Second):
- t.Fatal("subscription not closed within timeout")
- }
- }
-}
-
-// This test checks that Client doesn't lock up when a single subscriber
-// doesn't read subscription events.
-func TestClientNotificationStorm(t *testing.T) {
- server := newTestServer()
- defer server.Stop()
-
- doTest := func(count int, wantError bool) {
- client := DialInProc(server)
- defer client.Close()
- ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
- defer cancel()
-
- // Subscribe on the server. It will start sending many notifications
- // very quickly.
- nc := make(chan int)
- sub, err := client.Subscribe(ctx, "nftest", nc, "someSubscription", count, 0)
- if err != nil {
- t.Fatal("can't subscribe:", err)
- }
- defer sub.Unsubscribe()
-
- // Process each notification, try to run a call in between each of them.
- for i := 0; i < count; i++ {
- select {
- case val := <-nc:
- if val != i {
- t.Fatalf("(%d/%d) unexpected value %d", i, count, val)
- }
- case err := <-sub.Err():
- if wantError && err != ErrSubscriptionQueueOverflow {
- t.Fatalf("(%d/%d) got error %q, want %q", i, count, err, ErrSubscriptionQueueOverflow)
- } else if !wantError {
- t.Fatalf("(%d/%d) got unexpected error %q", i, count, err)
- }
- return
- }
- var r int
- err := client.CallContext(ctx, &r, "nftest_echo", i)
- if err != nil {
- if !wantError {
- t.Fatalf("(%d/%d) call error: %v", i, count, err)
- }
- return
- }
- }
- if wantError {
- t.Fatalf("didn't get expected error")
- }
- }
-
- doTest(8000, false)
- doTest(21000, true)
-}
-
-func TestClientHTTP(t *testing.T) {
- server := newTestServer()
- defer server.Stop()
-
- client, hs := httpTestClient(server, "http", nil)
- defer hs.Close()
- defer client.Close()
-
- // Launch concurrent requests.
- var (
- results = make([]Result, 100)
- errc = make(chan error)
- wantResult = Result{"a", 1, new(Args)}
- )
- defer client.Close()
- for i := range results {
- i := i
- go func() {
- errc <- client.Call(&results[i], "test_echo",
- wantResult.String, wantResult.Int, wantResult.Args)
- }()
- }
-
- // Wait for all of them to complete.
- timeout := time.NewTimer(5 * time.Second)
- defer timeout.Stop()
- for i := range results {
- select {
- case err := <-errc:
- if err != nil {
- t.Fatal(err)
- }
- case <-timeout.C:
- t.Fatalf("timeout (got %d/%d) results)", i+1, len(results))
- }
- }
-
- // Check results.
- for i := range results {
- if !reflect.DeepEqual(results[i], wantResult) {
- t.Errorf("result %d mismatch: got %#v, want %#v", i, results[i], wantResult)
- }
- }
-}
-
-func TestClientReconnect(t *testing.T) {
- startServer := func(addr string) (*Server, net.Listener) {
- srv := newTestServer()
- l, err := net.Listen("tcp", addr)
- if err != nil {
- t.Fatal("can't listen:", err)
- }
- go http.Serve(l, srv.WebsocketHandler([]string{"*"}))
- return srv, l
- }
-
- ctx, cancel := context.WithTimeout(context.Background(), 12*time.Second)
- defer cancel()
-
- // Start a server and corresponding client.
- s1, l1 := startServer("127.0.0.1:0")
- client, err := DialContext(ctx, "ws://"+l1.Addr().String())
- if err != nil {
- t.Fatal("can't dial", err)
- }
-
- // Perform a call. This should work because the server is up.
- var resp Result
- if err := client.CallContext(ctx, &resp, "test_echo", "", 1, nil); err != nil {
- t.Fatal(err)
- }
-
- // Shut down the server and allow for some cool down time so we can listen on the same
- // address again.
- l1.Close()
- s1.Stop()
- time.Sleep(2 * time.Second)
-
- // Try calling again. It shouldn't work.
- if err := client.CallContext(ctx, &resp, "test_echo", "", 2, nil); err == nil {
- t.Error("successful call while the server is down")
- t.Logf("resp: %#v", resp)
- }
-
- // Start it up again and call again. The connection should be reestablished.
- // We spawn multiple calls here to check whether this hangs somehow.
- s2, l2 := startServer(l1.Addr().String())
- defer l2.Close()
- defer s2.Stop()
-
- start := make(chan struct{})
- errors := make(chan error, 20)
- for i := 0; i < cap(errors); i++ {
- go func() {
- <-start
- var resp Result
- errors <- client.CallContext(ctx, &resp, "test_echo", "", 3, nil)
- }()
- }
- close(start)
- errcount := 0
- for i := 0; i < cap(errors); i++ {
- if err = <-errors; err != nil {
- errcount++
- }
- }
- t.Logf("%d errors, last error: %v", errcount, err)
- if errcount > 1 {
- t.Errorf("expected one error after disconnect, got %d", errcount)
- }
-}
-
-func httpTestClient(srv *Server, transport string, fl *flakeyListener) (*Client, *httptest.Server) {
- // Create the HTTP server.
- var hs *httptest.Server
- switch transport {
- case "ws":
- hs = httptest.NewUnstartedServer(srv.WebsocketHandler([]string{"*"}))
- case "http":
- hs = httptest.NewUnstartedServer(srv)
- default:
- panic("unknown HTTP transport: " + transport)
- }
- // Wrap the listener if required.
- if fl != nil {
- fl.Listener = hs.Listener
- hs.Listener = fl
- }
- // Connect the client.
- hs.Start()
- client, err := Dial(transport + "://" + hs.Listener.Addr().String())
- if err != nil {
- panic(err)
- }
- return client, hs
-}
-
-func ipcTestClient(srv *Server, fl *flakeyListener) (*Client, net.Listener) {
- // Listen on a random endpoint.
- endpoint := fmt.Sprintf("go-ethereum-test-ipc-%d-%d", os.Getpid(), rand.Int63())
- if runtime.GOOS == "windows" {
- endpoint = `\\.\pipe\` + endpoint
- } else {
- endpoint = os.TempDir() + "/" + endpoint
- }
- l, err := ipcListen(endpoint)
- if err != nil {
- panic(err)
- }
- // Connect the listener to the server.
- if fl != nil {
- fl.Listener = l
- l = fl
- }
- go srv.ServeListener(l)
- // Connect the client.
- client, err := Dial(endpoint)
- if err != nil {
- panic(err)
- }
- return client, l
-}
-
-// flakeyListener kills accepted connections after a random timeout.
-type flakeyListener struct {
- net.Listener
- maxKillTimeout time.Duration
- maxAcceptDelay time.Duration
-}
-
-func (l *flakeyListener) Accept() (net.Conn, error) {
- delay := time.Duration(rand.Int63n(int64(l.maxAcceptDelay)))
- time.Sleep(delay)
-
- c, err := l.Listener.Accept()
- if err == nil {
- timeout := time.Duration(rand.Int63n(int64(l.maxKillTimeout)))
- time.AfterFunc(timeout, func() {
- log.Debug(fmt.Sprintf("killing conn %v after %v", c.LocalAddr(), timeout))
- c.Close()
- })
- }
- return c, err
-}
diff --git a/rpc/http_test.go b/rpc/http_test.go
deleted file mode 100644
index b3f694d..0000000
--- a/rpc/http_test.go
+++ /dev/null
@@ -1,54 +0,0 @@
-// Copyright 2017 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
-
-package rpc
-
-import (
- "net/http"
- "net/http/httptest"
- "strings"
- "testing"
-)
-
-func TestHTTPErrorResponseWithDelete(t *testing.T) {
- testHTTPErrorResponse(t, http.MethodDelete, contentType, "", http.StatusMethodNotAllowed)
-}
-
-func TestHTTPErrorResponseWithPut(t *testing.T) {
- testHTTPErrorResponse(t, http.MethodPut, contentType, "", http.StatusMethodNotAllowed)
-}
-
-func TestHTTPErrorResponseWithMaxContentLength(t *testing.T) {
- body := make([]rune, maxRequestContentLength+1)
- testHTTPErrorResponse(t,
- http.MethodPost, contentType, string(body), http.StatusRequestEntityTooLarge)
-}
-
-func TestHTTPErrorResponseWithEmptyContentType(t *testing.T) {
- testHTTPErrorResponse(t, http.MethodPost, "", "", http.StatusUnsupportedMediaType)
-}
-
-func TestHTTPErrorResponseWithValidRequest(t *testing.T) {
- testHTTPErrorResponse(t, http.MethodPost, contentType, "", 0)
-}
-
-func testHTTPErrorResponse(t *testing.T, method, contentType, body string, expected int) {
- request := httptest.NewRequest(method, "http://url.com", strings.NewReader(body))
- request.Header.Set("content-type", contentType)
- if code, _ := validateRequest(request); code != expected {
- t.Fatalf("response code should be %d not %d", expected, code)
- }
-}
diff --git a/rpc/server_test.go b/rpc/server_test.go
deleted file mode 100644
index 3909954..0000000
--- a/rpc/server_test.go
+++ /dev/null
@@ -1,152 +0,0 @@
-// Copyright 2015 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
-
-package rpc
-
-import (
- "bufio"
- "bytes"
- "io"
- "io/ioutil"
- "net"
- "path/filepath"
- "strings"
- "testing"
- "time"
-)
-
-func TestServerRegisterName(t *testing.T) {
- server := NewServer()
- service := new(testService)
-
- if err := server.RegisterName("test", service); err != nil {
- t.Fatalf("%v", err)
- }
-
- if len(server.services.services) != 2 {
- t.Fatalf("Expected 2 service entries, got %d", len(server.services.services))
- }
-
- svc, ok := server.services.services["test"]
- if !ok {
- t.Fatalf("Expected service calc to be registered")
- }
-
- wantCallbacks := 7
- if len(svc.callbacks) != wantCallbacks {
- t.Errorf("Expected %d callbacks for service 'service', got %d", wantCallbacks, len(svc.callbacks))
- }
-}
-
-func TestServer(t *testing.T) {
- files, err := ioutil.ReadDir("testdata")
- if err != nil {
- t.Fatal("where'd my testdata go?")
- }
- for _, f := range files {
- if f.IsDir() || strings.HasPrefix(f.Name(), ".") {
- continue
- }
- path := filepath.Join("testdata", f.Name())
- name := strings.TrimSuffix(f.Name(), filepath.Ext(f.Name()))
- t.Run(name, func(t *testing.T) {
- runTestScript(t, path)
- })
- }
-}
-
-func runTestScript(t *testing.T, file string) {
- server := newTestServer()
- content, err := ioutil.ReadFile(file)
- if err != nil {
- t.Fatal(err)
- }
-
- clientConn, serverConn := net.Pipe()
- defer clientConn.Close()
- go server.ServeCodec(NewJSONCodec(serverConn), OptionMethodInvocation|OptionSubscriptions)
- readbuf := bufio.NewReader(clientConn)
- for _, line := range strings.Split(string(content), "\n") {
- line = strings.TrimSpace(line)
- switch {
- case len(line) == 0 || strings.HasPrefix(line, "//"):
- // skip comments, blank lines
- continue
- case strings.HasPrefix(line, "--> "):
- t.Log(line)
- // write to connection
- clientConn.SetWriteDeadline(time.Now().Add(5 * time.Second))
- if _, err := io.WriteString(clientConn, line[4:]+"\n"); err != nil {
- t.Fatalf("write error: %v", err)
- }
- case strings.HasPrefix(line, "<-- "):
- t.Log(line)
- want := line[4:]
- // read line from connection and compare text
- clientConn.SetReadDeadline(time.Now().Add(5 * time.Second))
- sent, err := readbuf.ReadString('\n')
- if err != nil {
- t.Fatalf("read error: %v", err)
- }
- sent = strings.TrimRight(sent, "\r\n")
- if sent != want {
- t.Errorf("wrong line from server\ngot: %s\nwant: %s", sent, want)
- }
- default:
- panic("invalid line in test script: " + line)
- }
- }
-}
-
-// This test checks that responses are delivered for very short-lived connections that
-// only carry a single request.
-func TestServerShortLivedConn(t *testing.T) {
- server := newTestServer()
- defer server.Stop()
-
- listener, err := net.Listen("tcp", "127.0.0.1:0")
- if err != nil {
- t.Fatal("can't listen:", err)
- }
- defer listener.Close()
- go server.ServeListener(listener)
-
- var (
- request = `{"jsonrpc":"2.0","id":1,"method":"rpc_modules"}` + "\n"
- wantResp = `{"jsonrpc":"2.0","id":1,"result":{"nftest":"1.0","rpc":"1.0","test":"1.0"}}` + "\n"
- deadline = time.Now().Add(10 * time.Second)
- )
- for i := 0; i < 20; i++ {
- conn, err := net.Dial("tcp", listener.Addr().String())
- if err != nil {
- t.Fatal("can't dial:", err)
- }
- defer conn.Close()
- conn.SetDeadline(deadline)
- // Write the request, then half-close the connection so the server stops reading.
- conn.Write([]byte(request))
- conn.(*net.TCPConn).CloseWrite()
- // Now try to get the response.
- buf := make([]byte, 2000)
- n, err := conn.Read(buf)
- if err != nil {
- t.Fatal("read error:", err)
- }
- if !bytes.Equal(buf[:n], []byte(wantResp)) {
- t.Fatalf("wrong response: %s", buf[:n])
- }
- }
-}
diff --git a/rpc/subscription_test.go b/rpc/subscription_test.go
deleted file mode 100644
index eba1924..0000000
--- a/rpc/subscription_test.go
+++ /dev/null
@@ -1,206 +0,0 @@
-// Copyright 2016 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
-
-package rpc
-
-import (
- "encoding/json"
- "fmt"
- "net"
- "strings"
- "testing"
- "time"
-)
-
-func TestNewID(t *testing.T) {
- hexchars := "0123456789ABCDEFabcdef"
- for i := 0; i < 100; i++ {
- id := string(NewID())
- if !strings.HasPrefix(id, "0x") {
- t.Fatalf("invalid ID prefix, want '0x...', got %s", id)
- }
-
- id = id[2:]
- if len(id) == 0 || len(id) > 32 {
- t.Fatalf("invalid ID length, want len(id) > 0 && len(id) <= 32), got %d", len(id))
- }
-
- for i := 0; i < len(id); i++ {
- if strings.IndexByte(hexchars, id[i]) == -1 {
- t.Fatalf("unexpected byte, want any valid hex char, got %c", id[i])
- }
- }
- }
-}
-
-func TestSubscriptions(t *testing.T) {
- var (
- namespaces = []string{"eth", "shh", "bzz"}
- service = &notificationTestService{}
- subCount = len(namespaces)
- notificationCount = 3
-
- server = NewServer()
- clientConn, serverConn = net.Pipe()
- out = json.NewEncoder(clientConn)
- in = json.NewDecoder(clientConn)
- successes = make(chan subConfirmation)
- notifications = make(chan subscriptionResult)
- errors = make(chan error, subCount*notificationCount+1)
- )
-
- // setup and start server
- for _, namespace := range namespaces {
- if err := server.RegisterName(namespace, service); err != nil {
- t.Fatalf("unable to register test service %v", err)
- }
- }
- go server.ServeCodec(NewJSONCodec(serverConn), OptionMethodInvocation|OptionSubscriptions)
- defer server.Stop()
-
- // wait for message and write them to the given channels
- go waitForMessages(in, successes, notifications, errors)
-
- // create subscriptions one by one
- for i, namespace := range namespaces {
- request := map[string]interface{}{
- "id": i,
- "method": fmt.Sprintf("%s_subscribe", namespace),
- "version": "2.0",
- "params": []interface{}{"someSubscription", notificationCount, i},
- }
- if err := out.Encode(&request); err != nil {
- t.Fatalf("Could not create subscription: %v", err)
- }
- }
-
- timeout := time.After(30 * time.Second)
- subids := make(map[string]string, subCount)
- count := make(map[string]int, subCount)
- allReceived := func() bool {
- done := len(count) == subCount
- for _, c := range count {
- if c < notificationCount {
- done = false
- }
- }
- return done
- }
- for !allReceived() {
- select {
- case confirmation := <-successes: // subscription created
- subids[namespaces[confirmation.reqid]] = string(confirmation.subid)
- case notification := <-notifications:
- count[notification.ID]++
- case err := <-errors:
- t.Fatal(err)
- case <-timeout:
- for _, namespace := range namespaces {
- subid, found := subids[namespace]
- if !found {
- t.Errorf("subscription for %q not created", namespace)
- continue
- }
- if count, found := count[subid]; !found || count < notificationCount {
- t.Errorf("didn't receive all notifications (%d<%d) in time for namespace %q", count, notificationCount, namespace)
- }
- }
- t.Fatal("timed out")
- }
- }
-}
-
-// This test checks that unsubscribing works.
-func TestServerUnsubscribe(t *testing.T) {
- // Start the server.
- server := newTestServer()
- service := &notificationTestService{unsubscribed: make(chan string)}
- server.RegisterName("nftest2", service)
- p1, p2 := net.Pipe()
- go server.ServeCodec(NewJSONCodec(p1), OptionMethodInvocation|OptionSubscriptions)
-
- p2.SetDeadline(time.Now().Add(10 * time.Second))
-
- // Subscribe.
- p2.Write([]byte(`{"jsonrpc":"2.0","id":1,"method":"nftest2_subscribe","params":["someSubscription",0,10]}`))
-
- // Handle received messages.
- resps := make(chan subConfirmation)
- notifications := make(chan subscriptionResult)
- errors := make(chan error)
- go waitForMessages(json.NewDecoder(p2), resps, notifications, errors)
-
- // Receive the subscription ID.
- var sub subConfirmation
- select {
- case sub = <-resps:
- case err := <-errors:
- t.Fatal(err)
- }
-
- // Unsubscribe and check that it is handled on the server side.
- p2.Write([]byte(`{"jsonrpc":"2.0","method":"nftest2_unsubscribe","params":["` + sub.subid + `"]}`))
- for {
- select {
- case id := <-service.unsubscribed:
- if id != string(sub.subid) {
- t.Errorf("wrong subscription ID unsubscribed")
- }
- return
- case err := <-errors:
- t.Fatal(err)
- case <-notifications:
- // drop notifications
- }
- }
-}
-
-type subConfirmation struct {
- reqid int
- subid ID
-}
-
-func waitForMessages(in *json.Decoder, successes chan subConfirmation, notifications chan subscriptionResult, errors chan error) {
- for {
- var msg jsonrpcMessage
- if err := in.Decode(&msg); err != nil {
- errors <- fmt.Errorf("decode error: %v", err)
- return
- }
- switch {
- case msg.isNotification():
- var res subscriptionResult
- if err := json.Unmarshal(msg.Params, &res); err != nil {
- errors <- fmt.Errorf("invalid subscription result: %v", err)
- } else {
- notifications <- res
- }
- case msg.isResponse():
- var c subConfirmation
- if msg.Error != nil {
- errors <- msg.Error
- } else if err := json.Unmarshal(msg.Result, &c.subid); err != nil {
- errors <- fmt.Errorf("invalid response: %v", err)
- } else {
- json.Unmarshal(msg.ID, &c.reqid)
- successes <- c
- }
- default:
- errors <- fmt.Errorf("unrecognized message: %v", msg)
- return
- }
- }
-}
diff --git a/rpc/testservice_test.go b/rpc/testservice_test.go
deleted file mode 100644
index 98871b5..0000000
--- a/rpc/testservice_test.go
+++ /dev/null
@@ -1,180 +0,0 @@
-// Copyright 2019 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
-
-package rpc
-
-import (
- "context"
- "encoding/binary"
- "errors"
- "sync"
- "time"
-)
-
-func newTestServer() *Server {
- server := NewServer()
- server.idgen = sequentialIDGenerator()
- if err := server.RegisterName("test", new(testService)); err != nil {
- panic(err)
- }
- if err := server.RegisterName("nftest", new(notificationTestService)); err != nil {
- panic(err)
- }
- return server
-}
-
-func sequentialIDGenerator() func() ID {
- var (
- mu sync.Mutex
- counter uint64
- )
- return func() ID {
- mu.Lock()
- defer mu.Unlock()
- counter++
- id := make([]byte, 8)
- binary.BigEndian.PutUint64(id, counter)
- return encodeID(id)
- }
-}
-
-type testService struct{}
-
-type Args struct {
- S string
-}
-
-type Result struct {
- String string
- Int int
- Args *Args
-}
-
-func (s *testService) NoArgsRets() {}
-
-func (s *testService) Echo(str string, i int, args *Args) Result {
- return Result{str, i, args}
-}
-
-func (s *testService) EchoWithCtx(ctx context.Context, str string, i int, args *Args) Result {
- return Result{str, i, args}
-}
-
-func (s *testService) Sleep(ctx context.Context, duration time.Duration) {
- time.Sleep(duration)
-}
-
-func (s *testService) Rets() (string, error) {
- return "", nil
-}
-
-func (s *testService) InvalidRets1() (error, string) {
- return nil, ""
-}
-
-func (s *testService) InvalidRets2() (string, string) {
- return "", ""
-}
-
-func (s *testService) InvalidRets3() (string, string, error) {
- return "", "", nil
-}
-
-func (s *testService) CallMeBack(ctx context.Context, method string, args []interface{}) (interface{}, error) {
- c, ok := ClientFromContext(ctx)
- if !ok {
- return nil, errors.New("no client")
- }
- var result interface{}
- err := c.Call(&result, method, args...)
- return result, err
-}
-
-func (s *testService) CallMeBackLater(ctx context.Context, method string, args []interface{}) error {
- c, ok := ClientFromContext(ctx)
- if !ok {
- return errors.New("no client")
- }
- go func() {
- <-ctx.Done()
- var result interface{}
- c.Call(&result, method, args...)
- }()
- return nil
-}
-
-func (s *testService) Subscription(ctx context.Context) (*Subscription, error) {
- return nil, nil
-}
-
-type notificationTestService struct {
- unsubscribed chan string
- gotHangSubscriptionReq chan struct{}
- unblockHangSubscription chan struct{}
-}
-
-func (s *notificationTestService) Echo(i int) int {
- return i
-}
-
-func (s *notificationTestService) Unsubscribe(subid string) {
- if s.unsubscribed != nil {
- s.unsubscribed <- subid
- }
-}
-
-func (s *notificationTestService) SomeSubscription(ctx context.Context, n, val int) (*Subscription, error) {
- notifier, supported := NotifierFromContext(ctx)
- if !supported {
- return nil, ErrNotificationsUnsupported
- }
-
- // By explicitly creating an subscription we make sure that the subscription id is send
- // back to the client before the first subscription.Notify is called. Otherwise the
- // events might be send before the response for the *_subscribe method.
- subscription := notifier.CreateSubscription()
- go func() {
- for i := 0; i < n; i++ {
- if err := notifier.Notify(subscription.ID, val+i); err != nil {
- return
- }
- }
- select {
- case <-notifier.Closed():
- case <-subscription.Err():
- }
- if s.unsubscribed != nil {
- s.unsubscribed <- string(subscription.ID)
- }
- }()
- return subscription, nil
-}
-
-// HangSubscription blocks on s.unblockHangSubscription before sending anything.
-func (s *notificationTestService) HangSubscription(ctx context.Context, val int) (*Subscription, error) {
- notifier, supported := NotifierFromContext(ctx)
- if !supported {
- return nil, ErrNotificationsUnsupported
- }
- s.gotHangSubscriptionReq <- struct{}{}
- <-s.unblockHangSubscription
- subscription := notifier.CreateSubscription()
-
- go func() {
- notifier.Notify(subscription.ID, val)
- }()
- return subscription, nil
-}
diff --git a/rpc/types_test.go b/rpc/types_test.go
deleted file mode 100644
index 0465849..0000000
--- a/rpc/types_test.go
+++ /dev/null
@@ -1,66 +0,0 @@
-// Copyright 2015 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
-
-package rpc
-
-import (
- "encoding/json"
- "testing"
-
- "github.com/ava-labs/go-ethereum/common/math"
-)
-
-func TestBlockNumberJSONUnmarshal(t *testing.T) {
- tests := []struct {
- input string
- mustFail bool
- expected BlockNumber
- }{
- 0: {`"0x"`, true, BlockNumber(0)},
- 1: {`"0x0"`, false, BlockNumber(0)},
- 2: {`"0X1"`, false, BlockNumber(1)},
- 3: {`"0x00"`, true, BlockNumber(0)},
- 4: {`"0x01"`, true, BlockNumber(0)},
- 5: {`"0x1"`, false, BlockNumber(1)},
- 6: {`"0x12"`, false, BlockNumber(18)},
- 7: {`"0x7fffffffffffffff"`, false, BlockNumber(math.MaxInt64)},
- 8: {`"0x8000000000000000"`, true, BlockNumber(0)},
- 9: {"0", true, BlockNumber(0)},
- 10: {`"ff"`, true, BlockNumber(0)},
- 11: {`"pending"`, false, PendingBlockNumber},
- 12: {`"latest"`, false, LatestBlockNumber},
- 13: {`"earliest"`, false, EarliestBlockNumber},
- 14: {`someString`, true, BlockNumber(0)},
- 15: {`""`, true, BlockNumber(0)},
- 16: {``, true, BlockNumber(0)},
- }
-
- for i, test := range tests {
- var num BlockNumber
- err := json.Unmarshal([]byte(test.input), &num)
- if test.mustFail && err == nil {
- t.Errorf("Test %d should fail", i)
- continue
- }
- if !test.mustFail && err != nil {
- t.Errorf("Test %d should pass but got err: %v", i, err)
- continue
- }
- if num != test.expected {
- t.Errorf("Test %d got unexpected value, want %d, got %d", i, test.expected, num)
- }
- }
-}
diff --git a/rpc/websocket_test.go b/rpc/websocket_test.go
deleted file mode 100644
index 9dc1084..0000000
--- a/rpc/websocket_test.go
+++ /dev/null
@@ -1,259 +0,0 @@
-// Copyright 2018 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
-
-package rpc
-
-import (
- "context"
- "net"
- "net/http"
- "net/http/httptest"
- "reflect"
- "strings"
- "testing"
- "time"
-
- "github.com/gorilla/websocket"
-)
-
-func TestWebsocketClientHeaders(t *testing.T) {
- t.Parallel()
-
- endpoint, header, err := wsClientHeaders("wss://testuser:[email protected]:1234", "https://example.com")
- if err != nil {
- t.Fatalf("wsGetConfig failed: %s", err)
- }
- if endpoint != "wss://example.com:1234" {
- t.Fatal("User should have been stripped from the URL")
- }
- if header.Get("authorization") != "Basic dGVzdHVzZXI6dGVzdC1QQVNTXzAx" {
- t.Fatal("Basic auth header is incorrect")
- }
- if header.Get("origin") != "https://example.com" {
- t.Fatal("Origin not set")
- }
-}
-
-// This test checks that the server rejects connections from disallowed origins.
-func TestWebsocketOriginCheck(t *testing.T) {
- t.Parallel()
-
- var (
- srv = newTestServer()
- httpsrv = httptest.NewServer(srv.WebsocketHandler([]string{"http://example.com"}))
- wsURL = "ws:" + strings.TrimPrefix(httpsrv.URL, "http:")
- )
- defer srv.Stop()
- defer httpsrv.Close()
-
- client, err := DialWebsocket(context.Background(), wsURL, "http://ekzample.com")
- if err == nil {
- client.Close()
- t.Fatal("no error for wrong origin")
- }
- wantErr := wsHandshakeError{websocket.ErrBadHandshake, "403 Forbidden"}
- if !reflect.DeepEqual(err, wantErr) {
- t.Fatalf("wrong error for wrong origin: %q", err)
- }
-
- // Connections without origin header should work.
- client, err = DialWebsocket(context.Background(), wsURL, "")
- if err != nil {
- t.Fatal("error for empty origin")
- }
- client.Close()
-}
-
-// This test checks whether calls exceeding the request size limit are rejected.
-func TestWebsocketLargeCall(t *testing.T) {
- t.Parallel()
-
- var (
- srv = newTestServer()
- httpsrv = httptest.NewServer(srv.WebsocketHandler([]string{"*"}))
- wsURL = "ws:" + strings.TrimPrefix(httpsrv.URL, "http:")
- )
- defer srv.Stop()
- defer httpsrv.Close()
-
- client, err := DialWebsocket(context.Background(), wsURL, "")
- if err != nil {
- t.Fatalf("can't dial: %v", err)
- }
- defer client.Close()
-
- // This call sends slightly less than the limit and should work.
- var result Result
- arg := strings.Repeat("x", maxRequestContentLength-200)
- if err := client.Call(&result, "test_echo", arg, 1); err != nil {
- t.Fatalf("valid call didn't work: %v", err)
- }
- if result.String != arg {
- t.Fatal("wrong string echoed")
- }
-
- // This call sends twice the allowed size and shouldn't work.
- arg = strings.Repeat("x", maxRequestContentLength*2)
- err = client.Call(&result, "test_echo", arg)
- if err == nil {
- t.Fatal("no error for too large call")
- }
-}
-
-// This test checks that client handles WebSocket ping frames correctly.
-func TestClientWebsocketPing(t *testing.T) {
- t.Parallel()
-
- var (
- sendPing = make(chan struct{})
- server = wsPingTestServer(t, sendPing)
- ctx, cancel = context.WithTimeout(context.Background(), 1*time.Second)
- )
- defer cancel()
- defer server.Shutdown(ctx)
-
- client, err := DialContext(ctx, "ws://"+server.Addr)
- if err != nil {
- t.Fatalf("client dial error: %v", err)
- }
- resultChan := make(chan int)
- sub, err := client.EthSubscribe(ctx, resultChan, "foo")
- if err != nil {
- t.Fatalf("client subscribe error: %v", err)
- }
-
- // Wait for the context's deadline to be reached before proceeding.
- // This is important for reproducing https://github.com/ethereum/go-ethereum/issues/19798
- <-ctx.Done()
- close(sendPing)
-
- // Wait for the subscription result.
- timeout := time.NewTimer(5 * time.Second)
- for {
- select {
- case err := <-sub.Err():
- t.Error("client subscription error:", err)
- case result := <-resultChan:
- t.Log("client got result:", result)
- return
- case <-timeout.C:
- t.Error("didn't get any result within the test timeout")
- return
- }
- }
-}
-
-// wsPingTestServer runs a WebSocket server which accepts a single subscription request.
-// When a value arrives on sendPing, the server sends a ping frame, waits for a matching
-// pong and finally delivers a single subscription result.
-func wsPingTestServer(t *testing.T, sendPing <-chan struct{}) *http.Server {
- var srv http.Server
- shutdown := make(chan struct{})
- srv.RegisterOnShutdown(func() {
- close(shutdown)
- })
- srv.Handler = http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
- // Upgrade to WebSocket.
- upgrader := websocket.Upgrader{
- CheckOrigin: func(r *http.Request) bool { return true },
- }
- conn, err := upgrader.Upgrade(w, r, nil)
- if err != nil {
- t.Errorf("server WS upgrade error: %v", err)
- return
- }
- defer conn.Close()
-
- // Handle the connection.
- wsPingTestHandler(t, conn, shutdown, sendPing)
- })
-
- // Start the server.
- listener, err := net.Listen("tcp", "127.0.0.1:0")
- if err != nil {
- t.Fatal("can't listen:", err)
- }
- srv.Addr = listener.Addr().String()
- go srv.Serve(listener)
- return &srv
-}
-
-func wsPingTestHandler(t *testing.T, conn *websocket.Conn, shutdown, sendPing <-chan struct{}) {
- // Canned responses for the eth_subscribe call in TestClientWebsocketPing.
- const (
- subResp = `{"jsonrpc":"2.0","id":1,"result":"0x00"}`
- subNotify = `{"jsonrpc":"2.0","method":"eth_subscription","params":{"subscription":"0x00","result":1}}`
- )
-
- // Handle subscribe request.
- if _, _, err := conn.ReadMessage(); err != nil {
- t.Errorf("server read error: %v", err)
- return
- }
- if err := conn.WriteMessage(websocket.TextMessage, []byte(subResp)); err != nil {
- t.Errorf("server write error: %v", err)
- return
- }
-
- // Read from the connection to process control messages.
- var pongCh = make(chan string)
- conn.SetPongHandler(func(d string) error {
- t.Logf("server got pong: %q", d)
- pongCh <- d
- return nil
- })
- go func() {
- for {
- typ, msg, err := conn.ReadMessage()
- if err != nil {
- return
- }
- t.Logf("server got message (%d): %q", typ, msg)
- }
- }()
-
- // Write messages.
- var (
- sendResponse <-chan time.Time
- wantPong string
- )
- for {
- select {
- case _, open := <-sendPing:
- if !open {
- sendPing = nil
- }
- t.Logf("server sending ping")
- conn.WriteMessage(websocket.PingMessage, []byte("ping"))
- wantPong = "ping"
- case data := <-pongCh:
- if wantPong == "" {
- t.Errorf("unexpected pong")
- } else if data != wantPong {
- t.Errorf("got pong with wrong data %q", data)
- }
- wantPong = ""
- sendResponse = time.NewTimer(200 * time.Millisecond).C
- case <-sendResponse:
- t.Logf("server sending response")
- conn.WriteMessage(websocket.TextMessage, []byte(subNotify))
- sendResponse = nil
- case <-shutdown:
- conn.Close()
- return
- }
- }
-}