Articulate EIP parameters and feature implementations

.travis.yml

@@ -156,7 +156,7 @@ matrix:
  git:
  submodules: false # avoid cloning ethereum/tests
  before_install:
- - curl https://storage.googleapis.com/golang/go1.11.2.linux-amd64.tar.gz | tar -xz
+ - curl https://storage.googleapis.com/golang/go1.11.4.linux-amd64.tar.gz | tar -xz
  - export PATH=`pwd`/go/bin:$PATH
  - export GOROOT=`pwd`/go
  - export GOPATH=$HOME/go

accounts/abi/bind/base.go

@@ -36,10 +36,10 @@ type SignerFn func(types.Signer, common.Address, *types.Transaction) (*types.Tra
 
 // CallOpts is the collection of options to fine tune a contract call request.
 type CallOpts struct {
- Pending bool // Whether to operate on the pending state or the last known one
- From common.Address // Optional the sender address, otherwise the first account is used
-
- Context context.Context // Network context to support cancellation and timeouts (nil = no timeout)
+ Pending  bool  // Whether to operate on the pending state or the last known one
+ From  common.Address  // Optional the sender address, otherwise the first account is used
+ BlockNumber *big.Int // Optional the block number on which the call should be performed
+ Context  context.Context // Network context to support cancellation and timeouts (nil = no timeout)
 }
 
 // TransactOpts is the collection of authorization data required to create a
@@ -148,10 +148,10 @@ func (c *BoundContract) Call(opts *CallOpts, result interface{}, method string,
  }
  }
  } else {
- output, err = c.caller.CallContract(ctx, msg, nil)
+ output, err = c.caller.CallContract(ctx, msg, opts.BlockNumber)
  if err == nil && len(output) == 0 {
  // Make sure we have a contract to operate on, and bail out otherwise.
- if code, err = c.caller.CodeAt(ctx, c.address, nil); err != nil {
+ if code, err = c.caller.CodeAt(ctx, c.address, opts.BlockNumber); err != nil {
  return err
  } else if len(code) == 0 {
  return ErrNoCode

accounts/abi/bind/base_test.go

@@ -0,0 +1,64 @@
+package bind_test
+
+import (
+ "context"
+ "math/big"
+ "testing"
+
+ ethereum "github.com/ethereum/go-ethereum"
+ "github.com/ethereum/go-ethereum/accounts/abi"
+ "github.com/ethereum/go-ethereum/accounts/abi/bind"
+ "github.com/ethereum/go-ethereum/common"
+)
+
+type mockCaller struct {
+ codeAtBlockNumber *big.Int
+ callContractBlockNumber *big.Int
+}
+
+func (mc *mockCaller) CodeAt(ctx context.Context, contract common.Address, blockNumber *big.Int) ([]byte, error) {
+ mc.codeAtBlockNumber = blockNumber
+ return []byte{1, 2, 3}, nil
+}
+
+func (mc *mockCaller) CallContract(ctx context.Context, call ethereum.CallMsg, blockNumber *big.Int) ([]byte, error) {
+ mc.callContractBlockNumber = blockNumber
+ return nil, nil
+}
+
+func TestPassingBlockNumber(t *testing.T) {
+
+ mc := &mockCaller{}
+
+ bc := bind.NewBoundContract(common.HexToAddress("0x0"), abi.ABI{
+ Methods: map[string]abi.Method{
+ "something": {
+ Name: "something",
+ Outputs: abi.Arguments{},
+ },
+ },
+ }, mc, nil, nil)
+ var ret string
+
+ blockNumber := big.NewInt(42)
+
+ bc.Call(&bind.CallOpts{BlockNumber: blockNumber}, &ret, "something")
+
+ if mc.callContractBlockNumber != blockNumber {
+ t.Fatalf("CallContract() was not passed the block number")
+ }
+
+ if mc.codeAtBlockNumber != blockNumber {
+ t.Fatalf("CodeAt() was not passed the block number")
+ }
+
+ bc.Call(&bind.CallOpts{}, &ret, "something")
+
+ if mc.callContractBlockNumber != nil {
+ t.Fatalf("CallContract() was passed a block number when it should not have been")
+ }
+
+ if mc.codeAtBlockNumber != nil {
+ t.Fatalf("CodeAt() was passed a block number when it should not have been")
+ }
+}

appveyor.yml

@@ -23,8 +23,8 @@ environment:
 install:
  - git submodule update --init
  - rmdir C:\go /s /q
- - appveyor DownloadFile https://storage.googleapis.com/golang/go1.11.2.windows-%GETH_ARCH%.zip
- - 7z x go1.11.2.windows-%GETH_ARCH%.zip -y -oC:\ > NUL
+ - appveyor DownloadFile https://storage.googleapis.com/golang/go1.11.4.windows-%GETH_ARCH%.zip
+ - 7z x go1.11.4.windows-%GETH_ARCH%.zip -y -oC:\ > NUL
  - go version
  - gcc --version
 

build/update-license.go

@@ -1,3 +1,19 @@
+// 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/>.
+
 // +build none
 
 /*

cmd/puppeth/genesis.go

@@ -417,7 +417,7 @@ func (spec *parityChainSpec) setPrecompile(address byte, data *parityChainSpecBu
 }
 
 func (spec *parityChainSpec) setByzantium(num *big.Int) {
- spec.Engine.Ethash.Params.BlockReward[hexutil.EncodeBig(num)] = hexutil.EncodeBig(ethash.ByzantiumBlockReward)
+ spec.Engine.Ethash.Params.BlockReward[hexutil.EncodeBig(num)] = hexutil.EncodeBig(ethash.EIP649FBlockReward)
  spec.Engine.Ethash.Params.DifficultyBombDelays[hexutil.EncodeBig(num)] = hexutil.EncodeUint64(3000000)
  n := hexutil.Uint64(num.Uint64())
  spec.Engine.Ethash.Params.EIP100bTransition = n
@@ -428,7 +428,7 @@ func (spec *parityChainSpec) setByzantium(num *big.Int) {
 }
 
 func (spec *parityChainSpec) setConstantinople(num *big.Int) {
- spec.Engine.Ethash.Params.BlockReward[hexutil.EncodeBig(num)] = hexutil.EncodeBig(ethash.ConstantinopleBlockReward)
+ spec.Engine.Ethash.Params.BlockReward[hexutil.EncodeBig(num)] = hexutil.EncodeBig(ethash.EIP1234FBlockReward)
  spec.Engine.Ethash.Params.DifficultyBombDelays[hexutil.EncodeBig(num)] = hexutil.EncodeUint64(2000000)
  n := hexutil.Uint64(num.Uint64())
  spec.Params.EIP145Transition = n

consensus/clique/clique.go

@@ -581,7 +581,7 @@ func (c *Clique) Prepare(chain consensus.ChainReader, header *types.Header) erro
 // rewards given, and returns the final block.
 func (c *Clique) Finalize(chain consensus.ChainReader, header *types.Header, state *state.StateDB, txs []*types.Transaction, uncles []*types.Header, receipts []*types.Receipt) (*types.Block, error) {
  // No block rewards in PoA, so the state remains as is and uncles are dropped
- header.Root = state.IntermediateRoot(chain.Config().IsEIP158(header.Number))
+ header.Root = state.IntermediateRoot(chain.Config().IsEIP161F(header.Number))
  header.UncleHash = types.CalcUncleHash(nil)
 
  // Assemble and return the final block for sealing

consensus/ethash/consensus.go

@@ -38,23 +38,25 @@ import (
 
 // Ethash proof-of-work protocol constants.
 var (
- FrontierBlockReward  = big.NewInt(5e+18) // Block reward in wei for successfully mining a block
- ByzantiumBlockReward  = big.NewInt(3e+18) // Block reward in wei for successfully mining a block upward from Byzantium
- ConstantinopleBlockReward = big.NewInt(2e+18) // Block reward in wei for successfully mining a block upward from Constantinople
- maxUncles  = 2 // Maximum number of uncles allowed in a single block
- allowedFutureBlockTime  = 15 * time.Second // Max time from current time allowed for blocks, before they're considered future blocks
+ FrontierBlockReward = big.NewInt(5e+18) // Block reward in wei for successfully mining a block
+ EIP649FBlockReward = big.NewInt(3e+18) // Block reward in wei for successfully mining a block upward from Byzantium
+ EIP1234FBlockReward  = big.NewInt(2e+18) // Block reward in wei for successfully mining a block upward from Constantinople
+ maxUncles = 2 // Maximum number of uncles allowed in a single block
+ allowedFutureBlockTime = 15 * time.Second // Max time from current time allowed for blocks, before they're considered future blocks
 
- // calcDifficultyConstantinople is the difficulty adjustment algorithm for Constantinople.
+ // calcDifficultyEIP1234 is the difficulty adjustment algorithm for Constantinople.
  // It returns the difficulty that a new block should have when created at time given the
  // parent block's time and difficulty. The calculation uses the Byzantium rules, but with
  // bomb offset 5M.
  // Specification EIP-1234: https://eips.ethereum.org/EIPS/eip-1234
- calcDifficultyConstantinople = makeDifficultyCalculator(big.NewInt(5000000))
+ calcDifficultyEIP1234 = makeDifficultyCalculator(big.NewInt(5000000))
 
- // calcDifficultyByzantium is the difficulty adjustment algorithm. It returns
+ // calcDifficultyByzantium is the difficulty adjustment algorithm for Byzantium. It returns
  // the difficulty that a new block should have when created at time given the
  // parent block's time and difficulty. The calculation uses the Byzantium rules.
  // Specification EIP-649: https://eips.ethereum.org/EIPS/eip-649
+ // Related meta-ish EIP-669: https://github.com/ethereum/EIPs/pull/669
+ // Note that this calculator also includes the change from EIP100.
  calcDifficultyByzantium = makeDifficultyCalculator(big.NewInt(3000000))
 )
 
@@ -313,10 +315,16 @@ func (ethash *Ethash) CalcDifficulty(chain consensus.ChainReader, time uint64, p
 func CalcDifficulty(config *params.ChainConfig, time uint64, parent *types.Header) *big.Int {
  next := new(big.Int).Add(parent.Number, big1)
  switch {
- case config.IsConstantinople(next):
- return calcDifficultyConstantinople(time, parent)
- case config.IsByzantium(next):
+ case config.IsEIP1234F(next):
+ return calcDifficultyEIP1234(time, parent)
+ case config.IsByzantium(next) || (config.IsEIP649F(next) && config.IsEIP100F(next)):
  return calcDifficultyByzantium(time, parent)
+ case config.IsEIP649F(next):
+ // TODO: calculator for only EIP649:difficulty bomb delay (without EIP100:mean time adjustment)
+ panic("not implemented")
+ case config.IsEIP100F(next):
+ // TODO: calculator for only EIP100:mean time adjustment (without EIP649:difficulty bomb delay)
+ panic("not implemented")
  case config.IsHomestead(next):
  return calcDifficultyHomestead(time, parent)
  default:
@@ -567,7 +575,7 @@ func (ethash *Ethash) Prepare(chain consensus.ChainReader, header *types.Header)
 func (ethash *Ethash) Finalize(chain consensus.ChainReader, header *types.Header, state *state.StateDB, txs []*types.Transaction, uncles []*types.Header, receipts []*types.Receipt) (*types.Block, error) {
  // Accumulate any block and uncle rewards and commit the final state root
  accumulateRewards(chain.Config(), state, header, uncles)
- header.Root = state.IntermediateRoot(chain.Config().IsEIP158(header.Number))
+ header.Root = state.IntermediateRoot(chain.Config().IsEIP161F(header.Number))
 
  // Header seems complete, assemble into a block and return
  return types.NewBlock(header, txs, uncles, receipts), nil
@@ -608,11 +616,11 @@ var (
 func accumulateRewards(config *params.ChainConfig, state *state.StateDB, header *types.Header, uncles []*types.Header) {
  // Select the correct block reward based on chain progression
  blockReward := FrontierBlockReward
- if config.IsByzantium(header.Number) {
- blockReward = ByzantiumBlockReward
+ if config.IsEIP649F(header.Number) {
+ blockReward = EIP649FBlockReward
  }
- if config.IsConstantinople(header.Number) {
- blockReward = ConstantinopleBlockReward
+ if config.IsEIP1234F(header.Number) {
+ blockReward = EIP1234FBlockReward
  }
  // Accumulate the rewards for the miner and any included uncles
  reward := new(big.Int).Set(blockReward)

core/block_validator.go

@@ -95,7 +95,7 @@ func (v *BlockValidator) ValidateState(block, parent *types.Block, statedb *stat
  }
  // Validate the state root against the received state root and throw
  // an error if they don't match.
- if root := statedb.IntermediateRoot(v.config.IsEIP158(header.Number)); header.Root != root {
+ if root := statedb.IntermediateRoot(v.config.IsEIP161F(header.Number)); header.Root != root {
  return fmt.Errorf("invalid merkle root (remote: %x local: %x)", header.Root, root)
  }
  return nil

core/blockchain.go

@@ -43,7 +43,7 @@ import (
  "github.com/ethereum/go-ethereum/params"
  "github.com/ethereum/go-ethereum/rlp"
  "github.com/ethereum/go-ethereum/trie"
- "github.com/hashicorp/golang-lru"
+ lru "github.com/hashicorp/golang-lru"
 )
 
 var (
@@ -946,7 +946,7 @@ func (bc *BlockChain) WriteBlockWithState(block *types.Block, receipts []*types.
  }
  rawdb.WriteBlock(bc.db, block)
 
- root, err := state.Commit(bc.chainConfig.IsEIP158(block.Number()))
+ root, err := state.Commit(bc.chainConfig.IsEIP161F(block.Number()))
  if err != nil {
  return NonStatTy, err
  }

core/chain_makers.go

@@ -200,7 +200,7 @@ func GenerateChain(config *params.ChainConfig, parent *types.Block, engine conse
  block, _ := b.engine.Finalize(chainreader, b.header, statedb, b.txs, b.uncles, b.receipts)
 
  // Write state changes to db
- root, err := statedb.Commit(config.IsEIP158(b.header.Number))
+ root, err := statedb.Commit(config.IsEIP161F(b.header.Number))
  if err != nil {
  panic(fmt.Sprintf("state write error: %v", err))
  }
@@ -233,7 +233,7 @@ func makeHeader(chain consensus.ChainReader, parent *types.Block, state *state.S
  }
 
  return &types.Header{
- Root: state.IntermediateRoot(chain.Config().IsEIP158(parent.Number())),
+ Root: state.IntermediateRoot(chain.Config().IsEIP161F(parent.Number())),
  ParentHash: parent.Hash(),
  Coinbase: parent.Coinbase(),
  Difficulty: engine.CalcDifficulty(chain, time.Uint64(), &types.Header{

core/state_processor.go

@@ -102,10 +102,10 @@ func ApplyTransaction(config *params.ChainConfig, bc ChainContext, author *commo
  }
  // Update the state with pending changes
  var root []byte
- if config.IsByzantium(header.Number) {
+ if config.IsEIP658F(header.Number) {
  statedb.Finalise(true)
  } else {
- root = statedb.IntermediateRoot(config.IsEIP158(header.Number)).Bytes()
+ root = statedb.IntermediateRoot(config.IsEIP161F(header.Number)).Bytes()
  }
  *usedGas += gas
 

core/vm/contracts.go

@@ -37,18 +37,8 @@ type PrecompiledContract interface {
  Run(input []byte) ([]byte, error) // Run runs the precompiled contract
 }
 
-// PrecompiledContractsHomestead contains the default set of pre-compiled Ethereum
-// contracts used in the Frontier and Homestead releases.
-var PrecompiledContractsHomestead = map[common.Address]PrecompiledContract{
- common.BytesToAddress([]byte{1}): &ecrecover{},
- common.BytesToAddress([]byte{2}): &sha256hash{},
- common.BytesToAddress([]byte{3}): &ripemd160hash{},
- common.BytesToAddress([]byte{4}): &dataCopy{},
-}
-
-// PrecompiledContractsByzantium contains the default set of pre-compiled Ethereum
-// contracts used in the Byzantium release.
-var PrecompiledContractsByzantium = map[common.Address]PrecompiledContract{
+// AllPrecompiledContracts returns all possible precompiled contracts.
+var AllPrecompiledContracts = map[common.Address]PrecompiledContract{
  common.BytesToAddress([]byte{1}): &ecrecover{},
  common.BytesToAddress([]byte{2}): &sha256hash{},
  common.BytesToAddress([]byte{3}): &ripemd160hash{},
@@ -59,6 +49,27 @@ var PrecompiledContractsByzantium = map[common.Address]PrecompiledContract{
  common.BytesToAddress([]byte{8}): &bn256Pairing{},
 }
 
+// IsPrecompiledContractEnabled checks whether a given precompiled contract is enabled for a chain config at a given block.
+func IsPrecompiledContractEnabled(config *params.ChainConfig, num *big.Int, codeAddr common.Address) bool {
+ switch codeAddr {
+ case common.BytesToAddress([]byte{1}),
+ common.BytesToAddress([]byte{2}),
+ common.BytesToAddress([]byte{3}),
+ common.BytesToAddress([]byte{4}):
+ return true
+ case common.BytesToAddress([]byte{5}):
+ return config.IsEIP198F(num)
+ case common.BytesToAddress([]byte{6}):
+ return config.IsEIP213F(num)
+ case common.BytesToAddress([]byte{7}):
+ return config.IsEIP213F(num)
+ case common.BytesToAddress([]byte{8}):
+ return config.IsEIP212F(num)
+ default:
+ return false
+ }
+}
+
 // RunPrecompiledContract runs and evaluates the output of a precompiled contract.
 func RunPrecompiledContract(p PrecompiledContract, input []byte, contract *Contract) (ret []byte, err error) {
  gas := p.RequiredGas(input)