adding support for creating bootnode
diff --git a/Makefile b/Makefile
index 3922d60..77f351d 100644
--- a/Makefile
+++ b/Makefile
@@ -16,6 +16,11 @@ geth:
@echo "Done building."
@echo "Run \"$(GOBIN)/geth\" to launch geth."
+ bootnode:+ build/env.sh go run build/ci.go install ./cmd/bootnode+ @echo "Done building."+ @echo "Run \"$(GOBIN)/bootnode\" to launch bootnode."+ accounts/abi/bind/backends/simulated.go diff --git a/accounts/abi/bind/backends/simulated.go b/accounts/abi/bind/backends/simulated.go
index 2b5c5fc..5362c94 100644
--- a/accounts/abi/bind/backends/simulated.go
+++ b/accounts/abi/bind/backends/simulated.go
@@ -37,6 +37,7 @@ import (
"github.com/ethereum/go-ethereum/eth/filters"
"github.com/ethereum/go-ethereum/ethdb"
"github.com/ethereum/go-ethereum/event"
+ "github.com/ethereum/go-ethereum/log"@@ -286,7 +287,7 @@ func (b *SimulatedBackend) callContract(ctx context.Context, call ethereum.CallM
// about the transaction and calling mechanisms.
vmenv := vm.NewEVM(evmContext, statedb, b.config, vm.Config{})
gaspool := new(core.GasPool).AddGas(math.MaxUint64)
- + log.Iolite("when simulated? callContract", "msg.Data", msg.Data())core/meta/base_meta_executor.go
MetaExecutor interface base implementation
IntrinsicGas() inherit Ethereum algorithm
diff --git a/core/meta/base_meta_executor.go b/core/meta/base_meta_executor.go
new file mode 100644
index 0000000..89eb636
--- /dev/null
+++ b/core/meta/base_meta_executor.go
@@ -0,0 +1,46 @@
+ // Copyright 2018 ... iolite.TODO+ + package meta+ + import (+ "math"+ + "github.com/ethereum/go-ethereum/core/vm"+ "github.com/ethereum/go-ethereum/params"+ )+ + type BaseMetaExecutor struct {+ metadata []byte+ }+ + // IntrinsicGas computes the 'intrinsic gas' for a message with the given metadata. iolite.TODO: need to rework algorithm+ func (executor *BaseMetaExecutor) IntrinsicGas() (uint64, error) {+ if len(executor.metadata) == 0 {+ return 0, nil+ }+ + // Set the starting gas for the raw transaction+ var gas uint64+ // Bump the required gas by the amount of transactional data+ if len(executor.metadata) > 0 {+ // Zero and non-zero bytes are priced differently+ var nz uint64+ for _, byt := range executor.metadata {+ if byt != 0 {+ nz+++ }+ }+ // Make sure we don't exceed uint64 for all data combinations+ if (math.MaxUint64-gas)/params.TxDataNonZeroGas < nz {+ return 0, vm.ErrOutOfGas+ }+ gas += nz * params.TxDataNonZeroGas+ + z := uint64(len(executor.metadata)) - nz+ if (math.MaxUint64-gas)/params.TxDataZeroGas < z {+ return 0, vm.ErrOutOfGas+ }+ gas += z * params.TxDataZeroGas+ }+ return gas, nil+ }core/meta/base_meta_payer.go
MetaPayer interface base implementation
CanPay() sums up all recipients and compares it with the specified limitthe result of IntrinsicGas() is the product of the number of recipients by TxGas(21000)
diff --git a/core/meta/base_meta_payer.go b/core/meta/base_meta_payer.go
new file mode 100644
index 0000000..c927ba2
--- /dev/null
+++ b/core/meta/base_meta_payer.go
@@ -0,0 +1,52 @@
+ // Copyright 2018 ... iolite.TODO+ + package meta+ + import (+ "math/big"+ + "github.com/ethereum/go-ethereum/common"+ "github.com/ethereum/go-ethereum/core/types"+ "github.com/ethereum/go-ethereum/core/vm"+ "github.com/ethereum/go-ethereum/log"+ "github.com/ethereum/go-ethereum/params"+ )+ + type BaseMetaPayer struct {+ from *common.Address+ metaLogs *types.MetaLogs+ metaLimit *big.Int+ }+ + func (payer *BaseMetaPayer) CanPay() (*big.Int, bool) {+ sum := big.NewInt(0)+ + if payer.metaLogs == nil || len(payer.metaLogs.Logs()) == 0 {+ return sum, true+ }+ + for _, log := range payer.metaLogs.Logs() {+ sum.Add(sum, log.Amount)+ }+ + log.Iolite("CanPay", "sum", sum, "metaLimit", payer.metaLimit)+ if sum.Cmp(payer.metaLimit) > 0 {+ return sum, false+ }+ + return sum, true+ }+ + func (payer *BaseMetaPayer) IntrinsicGas() (uint64, error) {+ count := uint64(len(payer.metaLogs.Logs()))+ if payer.metaLogs == nil || count == 0 {+ return 0, nil+ }+ + gas := count * params.TxGas+ if gas/count != params.TxGas {+ return 0, vm.ErrOutOfGas+ }+ + return gas, nil+ }core/meta/business_meta_executor.go
Business implementation of MetaExecutor interface
Executes the metadata code in the EVM without changing the state
Compiles a list of recipients and their values
diff --git a/core/meta/business_meta_executor.go b/core/meta/business_meta_executor.go
new file mode 100644
index 0000000..c68083a
--- /dev/null
+++ b/core/meta/business_meta_executor.go
@@ -0,0 +1,65 @@
+ // Copyright 2018 ... iolite.TODO+ + package meta+ + import (+ "errors"+ "math"+ "math/big"+ + "github.com/ethereum/go-ethereum/common"+ "github.com/ethereum/go-ethereum/core/types"+ "github.com/ethereum/go-ethereum/core/vm"+ "github.com/ethereum/go-ethereum/log"+ "github.com/ethereum/go-ethereum/rlp"+ )+ + type BusinessMetaExecutor struct {+ BaseMetaExecutor+ + readEVM *vm.EVM+ from common.Address+ }+ + func (executor *BusinessMetaExecutor) Execute() (*types.MetaLogs, error) {+ metadata := new(types.BusinessMetadata)+ metalogs := new(types.MetaLogs)+ + if len(executor.metadata) == 0 {+ return metalogs, nil+ }+ + if executor.readEVM == nil {+ return metalogs, errors.New("the runtime is not specified")+ }+ + if err := rlp.DecodeBytes(executor.metadata, metadata); err != nil {+ return metalogs, err+ }+ + log.Iolite("Business Metadata", "metadata", metadata)+ + sender := vm.AccountRef(executor.from)+ + ret, _, vmerr := executor.readEVM.Call(sender, *metadata.Data().Buisness, metadata.Data().Input, math.MaxUint64/2, big.NewInt(0))+ if vmerr != nil {+ return metalogs, vmerr+ }+ + log.Iolite("Executed Metadata", "ret", ret)+ + if len(ret) != 64 {+ return metalogs, errors.New("the business call result does not match the format (address, uint256)")+ }+ + metalogs.Push(common.BytesToAddress(ret[:32]), big.NewInt(0).SetBytes(ret[32:]))+ + for _, data := range metalogs.Logs() {+ log.Iolite("Decoded Metalogs", "To", data.Recipient, "Value", data.Amount)+ }+ return metalogs, nil+ }+ + func NewBusinessMetaExecutor(metadata []byte, readEVM *vm.EVM, from common.Address) *BusinessMetaExecutor {+ return &BusinessMetaExecutor{BaseMetaExecutor{metadata}, readEVM, from}+ }core/meta/business_meta_payer.go
Business implementation of MetaPayer interface
Pay off with the recipients through the EVM function call
diff --git a/core/meta/business_meta_payer.go b/core/meta/business_meta_payer.go
new file mode 100644
index 0000000..b3d6f43
--- /dev/null
+++ b/core/meta/business_meta_payer.go
@@ -0,0 +1,60 @@
+ // Copyright 2018 ... iolite.TODO+ + package meta+ + import (+ "errors"+ "math/big"+ + "github.com/ethereum/go-ethereum/common"+ "github.com/ethereum/go-ethereum/log"+ + "github.com/ethereum/go-ethereum/core/types"+ "github.com/ethereum/go-ethereum/core/vm"+ )+ + type BusinessMetaPayer struct {+ BaseMetaPayer+ + evm *vm.EVM+ }+ + func tryPay(from *common.Address, metaLogs *types.MetaLogs, evm *vm.EVM, gas uint64) (uint64, error) {+ if evm == nil {+ return gas, errors.New("the runtime is not specified")+ }+ + var vmerr error+ gasLeft := gas+ sender := vm.AccountRef(*from)+ for _, metalog := range metaLogs.Logs() {+ _, gasLeft, vmerr = evm.Call(sender, *metalog.Recipient, []byte{}, gasLeft, metalog.Amount) // iolite.TODO need the correct gas calculation+ log.Iolite("tryPay", "gas", gas, "gasLeft", gasLeft, "gasUsed", gas-gasLeft)+ if vmerr != nil {+ return gasLeft, vmerr+ }+ }+ return gasLeft, nil+ }+ + func (payer *BusinessMetaPayer) Pay(gas uint64) (*big.Int, uint64, error) {+ if len(payer.metaLogs.Logs()) > 1 {+ return big.NewInt(0), gas, errors.New("only one recipient is allowed for business call")+ }+ + sum, payable := payer.CanPay()+ if !payable {+ return big.NewInt(0), gas, vm.ErrInsufficientBalance+ }+ + gasLeft, err := tryPay(payer.from, payer.metaLogs, payer.evm, gas)+ if err != nil {+ return big.NewInt(0), gasLeft, err+ }+ + return sum, gasLeft, nil+ }+ + func NewBusinessMetaPayer(from common.Address, metaLogs *types.MetaLogs, metaLimit *big.Int, evm *vm.EVM) *BusinessMetaPayer {+ return &BusinessMetaPayer{BaseMetaPayer{&from, metaLogs, metaLimit}, evm}+ }core/meta/meta_executor.go
Interface for working with metadata
diff --git a/core/meta/meta_executor.go b/core/meta/meta_executor.go
new file mode 100644
index 0000000..c66b7c5
--- /dev/null
+++ b/core/meta/meta_executor.go
@@ -0,0 +1,11 @@
+ // Copyright 2018 ... iolite.TODO+ + package meta+ + import "github.com/ethereum/go-ethereum/core/types"+ + type MetaExecutor interface {+ Execute() (*types.MetaLogs, error)+ + IntrinsicGas() (uint64, error)+ }
Interface for working with metadata
diff --git a/core/meta/meta_payer.go b/core/meta/meta_payer.go
new file mode 100644
index 0000000..17f9742
--- /dev/null
+++ b/core/meta/meta_payer.go
@@ -0,0 +1,13 @@
+ // Copyright 2018 ... iolite.TODO+ + package meta+ + import "math/big"+ + type MetaPayer interface {+ Pay(gas uint64) (*big.Int, uint64, error)+ + CanPay() (*big.Int, bool)+ + IntrinsicGas() (uint64, error)+ }core/meta/simple_meta_executor.go
(Depreciated) Simple implementation of MetaExecutor interface
diff --git a/core/meta/simple_meta_executor.go b/core/meta/simple_meta_executor.go
new file mode 100644
index 0000000..fa9f070
--- /dev/null
+++ b/core/meta/simple_meta_executor.go
@@ -0,0 +1,34 @@
+ // Copyright 2018 ... iolite.TODO+ + package meta+ + import (+ "github.com/ethereum/go-ethereum/core/types"+ "github.com/ethereum/go-ethereum/log"+ "github.com/ethereum/go-ethereum/rlp"+ )+ + type SimpleMetaExecutor struct {+ BaseMetaExecutor+ }+ + func (executor *SimpleMetaExecutor) Execute() (*types.MetaLogs, error) {+ meta := new(types.MetaLogs)+ + if len(executor.metadata) == 0 {+ return meta, nil+ }+ + if err := rlp.DecodeBytes(executor.metadata, meta); err != nil {+ return meta, err+ }+ + for _, data := range meta.Logs() {+ log.Iolite("Decoded Metadata", "To", data.Recipient, "Value", data.Amount)+ }+ return meta, nil+ }+ + func NewSimpleMetaExecutor(metadata []byte) *SimpleMetaExecutor {+ return &SimpleMetaExecutor{BaseMetaExecutor{metadata}}+ }core/meta/simple_meta_payer.go
(Depreciated) Simple implementation of MetaPayer interface
diff --git a/core/meta/simple_meta_payer.go b/core/meta/simple_meta_payer.go
new file mode 100644
index 0000000..1cdc717
--- /dev/null
+++ b/core/meta/simple_meta_payer.go
@@ -0,0 +1,36 @@
+ // Copyright 2018 ... iolite.TODO+ + package meta+ + import (+ "math/big"+ + "github.com/ethereum/go-ethereum/common"+ + "github.com/ethereum/go-ethereum/core/types"+ "github.com/ethereum/go-ethereum/core/vm"+ )+ + type SimpleMetaPayer struct {+ BaseMetaPayer+ + state vm.StateDB+ }+ + func (payer *SimpleMetaPayer) Pay(gas uint64) (*big.Int, uint64, error) {+ sum, payable := payer.CanPay()+ if !payable {+ return big.NewInt(0), 0, vm.ErrInsufficientBalance+ }+ + for _, log := range payer.metaLogs.Logs() {+ payer.state.AddBalance(*log.Recipient, log.Amount)+ payer.state.SubBalance(*payer.from, log.Amount)+ }+ + return sum, 0, nil+ }+ + func NewSimpleMetaPayer(from common.Address, metaLogs *types.MetaLogs, metaLimit *big.Int, state vm.StateDB) *SimpleMetaPayer {+ return &SimpleMetaPayer{BaseMetaPayer{&from, metaLogs, metaLimit}, state}+ }
Contains additional functions for working with metadata
diff --git a/core/meta_util.go b/core/meta_util.go
new file mode 100644
index 0000000..3c493a0
--- /dev/null
+++ b/core/meta_util.go
@@ -0,0 +1,113 @@
+ // Copyright 2018 ... iolite.TODO+ + package core+ + import (+ "errors"+ "math/big"+ + "github.com/ethereum/go-ethereum/common"+ "github.com/ethereum/go-ethereum/common/math"+ "github.com/ethereum/go-ethereum/core/meta"+ "github.com/ethereum/go-ethereum/core/state"+ "github.com/ethereum/go-ethereum/core/types"+ "github.com/ethereum/go-ethereum/core/vm"+ "github.com/ethereum/go-ethereum/log"+ )+ + var (+ ErrMetaInsufficientFunds = errors.New("insufficient funds for metadata payment or payment are not allowed")+ + ErrMetaIntrinsicGas = errors.New("metadata intrinsic gas error")+ )+ + // iolite.TODO do something with code duplication+ + func UnpackSimpleMetadata(from common.Address, metadata []byte, metaLimit *big.Int, state vm.StateDB) (payer meta.MetaPayer, metaLogs *types.MetaLogs, payment *big.Int, intrinsicGas uint64, err error) {+ log.Iolite("UnpackSimpleMetadata", "metaLimit", metaLimit)+ + executor := meta.NewSimpleMetaExecutor(metadata)+ + executorGas, err := executor.IntrinsicGas()+ if err != nil {+ return nil, nil, nil, 0, err+ }+ + metaLogs, err = executor.Execute()+ if err != nil {+ return nil, metaLogs, nil, 0, err+ }+ + payer = meta.NewSimpleMetaPayer(from, metaLogs, metaLimit, state)+ + payerGas, err := payer.IntrinsicGas()+ if err != nil {+ return nil, nil, nil, 0, err+ }+ + payment, payable := payer.CanPay()+ if !payable {+ return nil, nil, nil, 0, ErrMetaInsufficientFunds+ }+ + intrinsicGas = executorGas + payerGas+ // Make sure we don't exceed uint64+ if intrinsicGas < executorGas {+ return nil, nil, nil, 0, ErrMetaIntrinsicGas+ }+ + return payer, metaLogs, payment, intrinsicGas, nil+ }+ + func UnpackBusinessMetadata(from common.Address, metadata []byte, metaLimit *big.Int, writeEVM *vm.EVM, readEVM *vm.EVM) (payer meta.MetaPayer, metaLogs *types.MetaLogs, payment *big.Int, intrinsicGas uint64, err error) {+ log.Iolite("UnpackBusinessMetadata", "metaLimit", metaLimit)+ + executor := meta.NewBusinessMetaExecutor(metadata, readEVM, from)+ + executorGas, err := executor.IntrinsicGas()+ if err != nil {+ return nil, nil, nil, 0, err+ }+ + metaLogs, err = executor.Execute()+ if err != nil {+ return nil, metaLogs, nil, 0, err+ }+ + payer = meta.NewBusinessMetaPayer(from, metaLogs, metaLimit, writeEVM)+ + payerGas, err := payer.IntrinsicGas()+ if err != nil {+ return nil, nil, nil, 0, err+ }+ + payment, payable := payer.CanPay()+ if !payable {+ return nil, nil, nil, 0, ErrMetaInsufficientFunds+ }+ + intrinsicGas = executorGas + payerGas+ // Make sure we don't exceed uint64+ if intrinsicGas < executorGas {+ return nil, nil, nil, 0, ErrMetaIntrinsicGas+ }+ + return payer, metaLogs, payment, intrinsicGas, nil+ }+ + func CreateReadOnlyEVMCopy(evm *vm.EVM, from common.Address) *vm.EVM {+ statedb, ok := evm.StateDB.(*state.StateDB)+ statedbCpy := statedb.Copy()+ statedbCpy.SetBalance(from, math.MaxBig256)+ log.Iolite("CREATE_STATE", "ok", ok)+ + return vm.NewEVM(evm.Context, statedbCpy, evm.ChainConfig(), vm.Config{})+ }+ + func CreateReadOnlyEVM(msg types.Message, chain *BlockChain, statedb *state.StateDB) *vm.EVM {+ statedbCpy := statedb.Copy()+ header := chain.CurrentBlock().Header()+ context := NewEVMContext(msg, header, chain, nil)+ statedbCpy.SetBalance(msg.From(), math.MaxBig256)+ return vm.NewEVM(context, statedbCpy, chain.Config(), vm.Config{})+ }
Support of extra metadata fields
additional logs
diff --git a/core/state_processor.go b/core/state_processor.go
index 4dc58b9..b5e1f83 100644
--- a/core/state_processor.go
+++ b/core/state_processor.go
@@ -18,12 +18,14 @@ package core
import (
"github.com/ethereum/go-ethereum/common"
+ "github.com/ethereum/go-ethereum/common/hexutil"+ "github.com/ethereum/go-ethereum/log"@@ -96,7 +98,7 @@ func ApplyTransaction(config *params.ChainConfig, bc *BlockChain, author *common
// about the transaction and calling mechanisms.
vmenv := vm.NewEVM(context, statedb, config, cfg)
// Apply the transaction to the current state (included in the env)
- _, gas, failed, err := ApplyMessage(vmenv, msg, gp)+ meta, _, gas, metaGas, failed, err := ApplyMessage(vmenv, msg, gp)@@ -114,13 +116,15 @@ func ApplyTransaction(config *params.ChainConfig, bc *BlockChain, author *common
receipt := types.NewReceipt(root, failed, *usedGas)
receipt.TxHash = tx.Hash()
receipt.GasUsed = gas
+ receipt.MetaGasUsed = metaGas+ receipt.MetaLogs = meta.Logs()- + log.Iolite("ApplyTransaction", "metadata", hexutil.Encode(msg.Metadata()))
Support of extra metadata fields
Backward compatibility with Ethereum transactions
additional logs
diff --git a/core/state_transition.go b/core/state_transition.go
index 5654cd0..b268014 100644
--- a/core/state_transition.go
+++ b/core/state_transition.go
@@ -22,6 +22,9 @@ import (
"math/big"
"github.com/ethereum/go-ethereum/common"
+ "github.com/ethereum/go-ethereum/common/hexutil"+ "github.com/ethereum/go-ethereum/core/meta"+ "github.com/ethereum/go-ethereum/core/types"@@ -73,6 +76,8 @@ type Message interface {
Nonce() uint64
CheckNonce() bool
Data() []byte
+ Metadata() []byte+ MetadataLimit() *big.Int@@ -128,7 +133,7 @@ func NewStateTransition(evm *vm.EVM, msg Message, gp *GasPool) *StateTransition
// the gas used (which includes gas refunds) and an error if it failed. An error always
// indicates a core error meaning that the message would always fail for that particular
// state and would never be accepted within a block.
- func ApplyMessage(evm *vm.EVM, msg Message, gp *GasPool) ([]byte, uint64, bool, error) {+ func ApplyMessage(evm *vm.EVM, msg Message, gp *GasPool) (*types.MetaLogs, []byte, uint64, uint64, bool, error) {@@ -180,7 +185,7 @@ func (st *StateTransition) preCheck() error {
// TransitionDb will transition the state by applying the current message and
// returning the result including the the used gas. It returns an error if it
// failed. An error indicates a consensus issue.
- func (st *StateTransition) TransitionDb() (ret []byte, usedGas uint64, failed bool, err error) {+ func (st *StateTransition) TransitionDb() (metalogs *types.MetaLogs, ret []byte, usedGas uint64, metaGasUsed uint64, failed bool, err error) {@@ -188,14 +193,31 @@ func (st *StateTransition) TransitionDb() (ret []byte, usedGas uint64, failed bo
sender := vm.AccountRef(msg.From())
homestead := st.evm.ChainConfig().IsHomestead(st.evm.BlockNumber)
contractCreation := msg.To() == nil
+ log.Iolite("ApplyMessage", "metadata", hexutil.Encode(st.msg.Metadata()), "limit", st.msg.MetadataLimit())+ + readEVM := CreateReadOnlyEVMCopy(st.evm, msg.From())+ payer, metalogs, _, metaGas, err := UnpackBusinessMetadata(msg.From(), msg.Metadata(), msg.MetadataLimit(), st.evm, readEVM)+ // payer, metalogs, _, metaGas, err := UnpackSimpleMetadata(msg.From(), msg.Metadata(), msg.MetadataLimit(), st.state)+ if err != nil {+ return nil, nil, 0, 0, false, err+ }- gas, err := IntrinsicGas(st.data, contractCreation, homestead)+ txGas, err := IntrinsicGas(st.data, contractCreation, homestead)- return nil, 0, false, err+ return nil, nil, 0, 0, false, err+ }+ + gas := txGas + metaGas+ // Make sure we don't exceed uint64+ if gas < txGas {+ return nil, nil, 0, 0, false, vm.ErrOutOfGas+ + log.Iolite("ApplyMessage", "gas", txGas, "metaGas", metaGas, "fullGas", gas)+ - return nil, 0, false, err+ return nil, nil, 0, 0, false, err@@ -203,28 +225,51 @@ func (st *StateTransition) TransitionDb() (ret []byte, usedGas uint64, failed bo
// vm errors do not effect consensus and are therefor
// not assigned to err, except for insufficient balance
// error.
- vmerr error+ vmerr error+ vmerr2 error+ beforeMetaGasUsed uint64- if contractCreation {- ret, _, st.gas, vmerr = evm.Create(sender, st.data, st.gas, st.value)+ + // if the business contract call is not correct, then the transaction will be considered a failure,+ // but the logic of the pure transaction will be executed+ tryPayer := meta.NewBusinessMetaPayer(msg.From(), metalogs, msg.MetadataLimit(), readEVM)+ _, _, vmerr2 = tryPayer.Pay(metaGas)+ + if vmerr2 == nil {+ log.Iolite("evm.before", "gas", st.gas)+ if contractCreation {+ ret, _, st.gas, vmerr = evm.Create(sender, st.data, st.gas, st.value)+ } else {+ // Increment the nonce for the next transaction+ st.state.SetNonce(msg.From(), st.state.GetNonce(sender.Address())+1)+ ret, st.gas, vmerr = evm.Call(sender, st.to(), st.data, st.gas, st.value)+ }+ log.Iolite("evm.after", "err", vmerr, "gas", st.gas)+ if vmerr != nil {+ log.Debug("VM returned with error", "err", vmerr)+ // The only possible consensus-error would be if there wasn't+ // sufficient balance to make the transfer happen. The first+ // balance transfer may never fail.+ if vmerr == vm.ErrInsufficientBalance {+ return nil, nil, 0, 0, false, vmerr+ }+ }+ + beforeMetaGasUsed = st.gasUsed()+ log.Iolite("payer.Pay.before", "gas", st.gas)+ _, st.gas, vmerr2 = payer.Pay(st.gas)+ log.Iolite("payer.Pay.after", "err", vmerr2, "gas", st.gas)+ // iolite.TODO check vmerr == vm.ErrInsufficientBalance ?- // Increment the nonce for the next transaction- ret, st.gas, vmerr = evm.Call(sender, st.to(), st.data, st.gas, st.value)- }- if vmerr != nil {- log.Debug("VM returned with error", "err", vmerr)- // The only possible consensus-error would be if there wasn't- // sufficient balance to make the transfer happen. The first- // balance transfer may never fail.- if vmerr == vm.ErrInsufficientBalance {- return nil, 0, false, vmerr- }+ log.Iolite("check before exec", "err", vmerr2)- return ret, st.gasUsed(), vmerr != nil, err+ metaGasUsed = metaGas + st.gasUsed() - beforeMetaGasUsed+ log.Iolite("metags???", "gasUsed diff", metaGasUsed)+ return metalogs, ret, st.gasUsed(), metaGasUsed, vmerr != nil || vmerr2 != nil, err
Support of extra metadata fields
additional logs
diff --git a/core/tx_pool.go b/core/tx_pool.go
index a554f66..1da68f1 100644
--- a/core/tx_pool.go
+++ b/core/tx_pool.go
@@ -581,16 +581,40 @@ func (pool *TxPool) validateTx(tx *types.Transaction, local bool) error {
if pool.currentState.GetNonce(from) > tx.Nonce() {
return ErrNonceTooLow
}
+ + msg, err := tx.AsMessage(pool.signer)+ if err != nil {+ return ErrInvalidSender+ }+ + readEVM := CreateReadOnlyEVM(msg, pool.chain.(*BlockChain), pool.currentState)+ _, _, payment, metaGas, err := UnpackBusinessMetadata(from, tx.Metadata(), tx.MetadataLimit(), nil, readEVM)+ // _, _, payment, metaGas, err := UnpackSimpleMetadata(from, tx.Metadata(), tx.MetadataLimit(), nil)+ if err != nil {+ return err+ }- if pool.currentState.GetBalance(from).Cmp(tx.Cost()) < 0 {+ txCost := big.NewInt(0)+ txCost.Add(txCost, tx.Cost())+ txCost.Add(txCost, payment)+ + if pool.currentState.GetBalance(from).Cmp(txCost) < 0 {+ - if tx.Gas() < intrGas {+ + gas := intrGas + metaGas+ // Make sure we don't exceed uint64+ if gas < intrGas {+ return ErrIntrinsicGas+ }+ + if tx.Gas() < gas {@@ -608,12 +632,12 @@ func (pool *TxPool) add(tx *types.Transaction, local bool) (bool, error) {
// If the transaction is already known, discard it
hash := tx.Hash()
if pool.all[hash] != nil {
- log.Trace("Discarding already known transaction", "hash", hash)+ log.Warn("Discarding already known transaction", "hash", hash)- log.Trace("Discarding invalid transaction", "hash", hash, "err", err)+ log.Warn("Discarding invalid transaction", "hash", hash, "err", err)@@ -621,14 +645,14 @@ func (pool *TxPool) add(tx *types.Transaction, local bool) (bool, error) {
if uint64(len(pool.all)) >= pool.config.GlobalSlots+pool.config.GlobalQueue {
// If the new transaction is underpriced, don't accept it
if pool.priced.Underpriced(tx, pool.locals) {
- log.Trace("Discarding underpriced transaction", "hash", hash, "price", tx.GasPrice())+ log.Warn("Discarding underpriced transaction", "hash", hash, "price", tx.GasPrice())- log.Trace("Discarding freshly underpriced transaction", "hash", tx.Hash(), "price", tx.GasPrice())+ log.Warn("Discarding freshly underpriced transaction", "hash", tx.Hash(), "price", tx.GasPrice())@@ -652,7 +676,7 @@ func (pool *TxPool) add(tx *types.Transaction, local bool) (bool, error) {
pool.priced.Put(tx)
pool.journalTx(from, tx)
- log.Trace("Pooled new executable transaction", "hash", hash, "from", from, "to", tx.To())+ log.Warn("Pooled new executable transaction", "hash", hash, "from", from, "to", tx.To())@@ -670,7 +694,7 @@ func (pool *TxPool) add(tx *types.Transaction, local bool) (bool, error) {
}
pool.journalTx(from, tx)
- log.Trace("Pooled new future transaction", "hash", hash, "from", from, "to", tx.To())+ log.Warn("Pooled new future transaction", "hash", hash, "from", from, "to", tx.To())@@ -784,9 +808,9 @@ func (pool *TxPool) AddRemotes(txs []*types.Transaction) []error {
func (pool *TxPool) addTx(tx *types.Transaction, local bool) error {
pool.mu.Lock()
defer pool.mu.Unlock()
- + log.Iolite("TxPool", "addTx.err", err)/core/types/business_metadata.go
Type describing the Businnes metadata structure
diff --git a/core/types/business_metadata.go b/core/types/business_metadata.go
new file mode 100644
index 0000000..0913d13
--- /dev/null
+++ b/core/types/business_metadata.go
@@ -0,0 +1,39 @@
+ // Copyright 2018 ... iolite.TODO+ + package types+ + import (+ "io"+ + "github.com/ethereum/go-ethereum/common"+ "github.com/ethereum/go-ethereum/common/hexutil"+ "github.com/ethereum/go-ethereum/rlp"+ )+ + //go:generate gencodec -type metadata -field-override metadataMarshaling -out gen_metadata_json.go+ + // Metadata+ type BusinessMetadata struct {+ data metadata+ }+ + type metadata struct {+ Buisness *common.Address `json:"to" gencodec:"required"`+ Input []byte `json:"input" gencodec:"required"`+ }+ + type metadataMarshaling struct {+ Input hexutil.Bytes+ }+ + // EncodeRLP implements rlp.Encoder+ func (meta *BusinessMetadata) EncodeRLP(w io.Writer) error {+ return rlp.Encode(w, &meta.data)+ }+ + // DecodeRLP implements rlp.Decoder+ func (meta *BusinessMetadata) DecodeRLP(s *rlp.Stream) error {+ return s.Decode(&meta.data)+ }+ + func (meta *BusinessMetadata) Data() *metadata { return &meta.data }
core/types/gen_header_json.go
diff --git a/core/types/gen_header_json.go b/core/types/gen_header_json.go
index 1b92cd9..1e832f2 100644
--- a/core/types/gen_header_json.go
+++ b/core/types/gen_header_json.go
@@ -13,6 +13,7 @@ import (
var _ = (*headerMarshaling)(nil)
+ // MarshalJSON marshals as JSON.@@ -52,6 +53,7 @@ func (h Header) MarshalJSON() ([]byte, error) {
return json.Marshal(&enc)
}
+ // UnmarshalJSON unmarshals from JSON.diff --git a/core/types/gen_log_json.go b/core/types/gen_log_json.go
index 1b5ae3c..6e94339 100644
--- a/core/types/gen_log_json.go
+++ b/core/types/gen_log_json.go
@@ -12,6 +12,7 @@ import (
var _ = (*logMarshaling)(nil)
+ // MarshalJSON marshals as JSON.@@ -37,6 +38,7 @@ func (l Log) MarshalJSON() ([]byte, error) {
return json.Marshal(&enc)
}
+ // UnmarshalJSON unmarshals from JSON.core/types/gen_metadata_json.go diff --git a/core/types/gen_metadata_json.go b/core/types/gen_metadata_json.go
new file mode 100644
index 0000000..b88be61
--- /dev/null
+++ b/core/types/gen_metadata_json.go
@@ -0,0 +1,46 @@
+ // Code generated by github.com/fjl/gencodec. DO NOT EDIT.+ + package types+ + import (+ "encoding/json"+ "errors"+ + "github.com/ethereum/go-ethereum/common"+ "github.com/ethereum/go-ethereum/common/hexutil"+ )+ + var _ = (*metadataMarshaling)(nil)+ + // MarshalJSON marshals as JSON.+ func (m metadata) MarshalJSON() ([]byte, error) {+ type metadata struct {+ Buisness *common.Address `json:"to" gencodec:"required"`+ Input hexutil.Bytes `json:"input" gencodec:"required"`+ }+ var enc metadata+ enc.Buisness = m.Buisness+ enc.Input = m.Input+ return json.Marshal(&enc)+ }+ + // UnmarshalJSON unmarshals from JSON.+ func (m *metadata) UnmarshalJSON(input []byte) error {+ type metadata struct {+ Buisness *common.Address `json:"to" gencodec:"required"`+ Input *hexutil.Bytes `json:"input" gencodec:"required"`+ }+ var dec metadata+ if err := json.Unmarshal(input, &dec); err != nil {+ return err+ }+ if dec.Buisness == nil {+ return errors.New("missing required field 'to' for metadata")+ }+ m.Buisness = dec.Buisness+ if dec.Input == nil {+ return errors.New("missing required field 'input' for metadata")+ }+ m.Input = *dec.Input+ return nil+ }core/types/gen_metalog_json.go diff --git a/core/types/gen_metalog_json.go b/core/types/gen_metalog_json.go
new file mode 100644
index 0000000..be79f88
--- /dev/null
+++ b/core/types/gen_metalog_json.go
@@ -0,0 +1,47 @@
+ // Code generated by github.com/fjl/gencodec. DO NOT EDIT.+ + package types+ + import (+ "encoding/json"+ "errors"+ "math/big"+ + "github.com/ethereum/go-ethereum/common"+ "github.com/ethereum/go-ethereum/common/hexutil"+ )+ + var _ = (*metalogMarshaling)(nil)+ + // MarshalJSON marshals as JSON.+ func (m MetaLog) MarshalJSON() ([]byte, error) {+ type MetaLog struct {+ Recipient *common.Address `json:"to" gencodec:"required"`+ Amount *hexutil.Big `json:"value" gencodec:"required"`+ }+ var enc MetaLog+ enc.Recipient = m.Recipient+ enc.Amount = (*hexutil.Big)(m.Amount)+ return json.Marshal(&enc)+ }+ + // UnmarshalJSON unmarshals from JSON.+ func (m *MetaLog) UnmarshalJSON(input []byte) error {+ type MetaLog struct {+ Recipient *common.Address `json:"to" gencodec:"required"`+ Amount *hexutil.Big `json:"value" gencodec:"required"`+ }+ var dec MetaLog+ if err := json.Unmarshal(input, &dec); err != nil {+ return err+ }+ if dec.Recipient == nil {+ return errors.New("missing required field 'to' for MetaLog")+ }+ m.Recipient = dec.Recipient+ if dec.Amount == nil {+ return errors.New("missing required field 'value' for MetaLog")+ }+ m.Amount = (*big.Int)(dec.Amount)+ return nil+ }core/types/gen_receipt_json.go diff --git a/core/types/gen_receipt_json.go b/core/types/gen_receipt_json.go
index c297ade..9018eaa 100644
--- a/core/types/gen_receipt_json.go
+++ b/core/types/gen_receipt_json.go
@@ -12,6 +12,7 @@ import (
var _ = (*receiptMarshaling)(nil)
+ // MarshalJSON marshals as JSON.@@ -19,9 +20,11 @@ func (r Receipt) MarshalJSON() ([]byte, error) {
CumulativeGasUsed hexutil.Uint64 `json:"cumulativeGasUsed" gencodec:"required"`
Bloom Bloom `json:"logsBloom" gencodec:"required"`
Logs []*Log `json:"logs" gencodec:"required"`
+ MetaLogs []*MetaLog `json:"metaLogs" gencodec:"required"`+ MetaGasUsed hexutil.Uint64 `json:"metaGasUsed" gencodec:"required"`@@ -29,12 +32,15 @@ func (r Receipt) MarshalJSON() ([]byte, error) {
enc.CumulativeGasUsed = hexutil.Uint64(r.CumulativeGasUsed)
enc.Bloom = r.Bloom
enc.Logs = r.Logs
+ enc.MetaLogs = r.MetaLogs+ enc.MetaGasUsed = hexutil.Uint64(r.MetaGasUsed)+ // UnmarshalJSON unmarshals from JSON.@@ -42,9 +48,11 @@ func (r *Receipt) UnmarshalJSON(input []byte) error {
CumulativeGasUsed *hexutil.Uint64 `json:"cumulativeGasUsed" gencodec:"required"`
Bloom *Bloom `json:"logsBloom" gencodec:"required"`
Logs []*Log `json:"logs" gencodec:"required"`
+ MetaLogs []*MetaLog `json:"metaLogs" gencodec:"required"`+ MetaGasUsed *hexutil.Uint64 `json:"metaGasUsed" gencodec:"required"`@@ -68,6 +76,10 @@ func (r *Receipt) UnmarshalJSON(input []byte) error {
return errors.New("missing required field 'logs' for Receipt")
}
r.Logs = dec.Logs
+ if dec.MetaLogs == nil {+ return errors.New("missing required field 'metaLogs' for Receipt")+ }+ r.MetaLogs = dec.MetaLogs@@ -79,5 +91,9 @@ func (r *Receipt) UnmarshalJSON(input []byte) error {
return errors.New("missing required field 'gasUsed' for Receipt")
}
r.GasUsed = uint64(*dec.GasUsed)
+ if dec.MetaGasUsed == nil {+ return errors.New("missing required field 'metaGasUsed' for Receipt")+ }+ r.MetaGasUsed = uint64(*dec.MetaGasUsed)core/types/gen_tx_json.go diff --git a/core/types/gen_tx_json.go b/core/types/gen_tx_json.go
index c27da67..ef6ac7f 100644
--- a/core/types/gen_tx_json.go
+++ b/core/types/gen_tx_json.go
@@ -13,18 +13,22 @@ import (
var _ = (*txdataMarshaling)(nil)
+ // MarshalJSON marshals as JSON.- AccountNonce hexutil.Uint64 `json:"nonce" gencodec:"required"`- Price *hexutil.Big `json:"gasPrice" gencodec:"required"`- GasLimit hexutil.Uint64 `json:"gas" gencodec:"required"`- Recipient *common.Address `json:"to" rlp:"nil"`- Amount *hexutil.Big `json:"value" gencodec:"required"`- Payload hexutil.Bytes `json:"input" gencodec:"required"`- V *hexutil.Big `json:"v" gencodec:"required"`- R *hexutil.Big `json:"r" gencodec:"required"`- S *hexutil.Big `json:"s" gencodec:"required"`- Hash *common.Hash `json:"hash" rlp:"-"`+ AccountNonce hexutil.Uint64 `json:"nonce" gencodec:"required"`+ Price *hexutil.Big `json:"gasPrice" gencodec:"required"`+ GasLimit hexutil.Uint64 `json:"gas" gencodec:"required"`+ Recipient *common.Address `json:"to" rlp:"nil"`+ Amount *hexutil.Big `json:"value" gencodec:"required"`+ Payload hexutil.Bytes `json:"input" gencodec:"required"`+ Metadata hexutil.Bytes `json:"metadata" gencodec:"required"`+ MetadataLimit *hexutil.Big `json:"metadataLimit" gencodec:"required"`+ IsOld hexutil.Uint `json:"isOld" gencodec:"required"`+ V *hexutil.Big `json:"v" gencodec:"required"`+ R *hexutil.Big `json:"r" gencodec:"required"`+ S *hexutil.Big `json:"s" gencodec:"required"`+ Hash *common.Hash `json:"hash" rlp:"-"`@@ -33,6 +37,9 @@ func (t txdata) MarshalJSON() ([]byte, error) {
enc.Recipient = t.Recipient
enc.Amount = (*hexutil.Big)(t.Amount)
enc.Payload = t.Payload
+ enc.Metadata = t.Metadata+ enc.MetadataLimit = (*hexutil.Big)(t.MetadataLimit)+ enc.IsOld = hexutil.Uint(t.IsOld)@@ -40,18 +47,22 @@ func (t txdata) MarshalJSON() ([]byte, error) {
return json.Marshal(&enc)
}
+ // UnmarshalJSON unmarshals from JSON.- AccountNonce *hexutil.Uint64 `json:"nonce" gencodec:"required"`- Price *hexutil.Big `json:"gasPrice" gencodec:"required"`- GasLimit *hexutil.Uint64 `json:"gas" gencodec:"required"`- Recipient *common.Address `json:"to" rlp:"nil"`- Amount *hexutil.Big `json:"value" gencodec:"required"`- Payload *hexutil.Bytes `json:"input" gencodec:"required"`- V *hexutil.Big `json:"v" gencodec:"required"`- R *hexutil.Big `json:"r" gencodec:"required"`- S *hexutil.Big `json:"s" gencodec:"required"`- Hash *common.Hash `json:"hash" rlp:"-"`+ AccountNonce *hexutil.Uint64 `json:"nonce" gencodec:"required"`+ Price *hexutil.Big `json:"gasPrice" gencodec:"required"`+ GasLimit *hexutil.Uint64 `json:"gas" gencodec:"required"`+ Recipient *common.Address `json:"to" rlp:"nil"`+ Amount *hexutil.Big `json:"value" gencodec:"required"`+ Payload *hexutil.Bytes `json:"input" gencodec:"required"`+ Metadata *hexutil.Bytes `json:"metadata" gencodec:"required"`+ MetadataLimit *hexutil.Big `json:"metadataLimit" gencodec:"required"`+ IsOld *hexutil.Uint `json:"isOld" gencodec:"required"`+ V *hexutil.Big `json:"v" gencodec:"required"`+ R *hexutil.Big `json:"r" gencodec:"required"`+ S *hexutil.Big `json:"s" gencodec:"required"`+ Hash *common.Hash `json:"hash" rlp:"-"`@@ -80,6 +91,18 @@ func (t *txdata) UnmarshalJSON(input []byte) error {
return errors.New("missing required field 'input' for txdata")
}
t.Payload = *dec.Payload
+ if dec.Metadata == nil {+ return errors.New("missing required field 'metadata' for txdata")+ }+ t.Metadata = *dec.Metadata+ if dec.MetadataLimit == nil {+ return errors.New("missing required field 'metadataLimit' for txdata")+ }+ t.MetadataLimit = (*big.Int)(dec.MetadataLimit)+ if dec.IsOld == nil {+ return errors.New("missing required field 'isOld' for txdata")+ }+ t.IsOld = uint(*dec.IsOld)
Type describing the structure of unpacked metadata
diff --git a/core/types/metalogs.go b/core/types/metalogs.go
new file mode 100644
index 0000000..9796382
--- /dev/null
+++ b/core/types/metalogs.go
@@ -0,0 +1,44 @@
+ // Copyright 2018 ... iolite.TODO+ + package types+ + import (+ "io"+ "math/big"+ + "github.com/ethereum/go-ethereum/common"+ "github.com/ethereum/go-ethereum/common/hexutil"+ "github.com/ethereum/go-ethereum/rlp"+ )+ + //go:generate gencodec -type MetaLog -field-override metalogMarshaling -out gen_metalog_json.go+ + // Metadata+ type MetaLogs struct {+ logs []*MetaLog+ }+ + type MetaLog struct {+ Recipient *common.Address `json:"to" gencodec:"required"`+ Amount *big.Int `json:"value" gencodec:"required"`+ }+ + type metalogMarshaling struct {+ Amount *hexutil.Big+ }+ + // EncodeRLP implements rlp.Encoder+ func (meta *MetaLogs) EncodeRLP(w io.Writer) error {+ return rlp.Encode(w, &meta.logs)+ }+ + // DecodeRLP implements rlp.Decoder+ func (meta *MetaLogs) DecodeRLP(s *rlp.Stream) error {+ return s.Decode(&meta.logs)+ }+ + func (meta *MetaLogs) Logs() []*MetaLog { return meta.logs }+ + func (meta *MetaLogs) Push(recipient common.Address, amount *big.Int) {+ meta.logs = append(meta.logs, &MetaLog{&recipient, amount})+ }core/types/new_iolite_transaction.go
Intermediate type containing metadata fields specific for the Iolite
diff --git a/core/types/new_iolite_transaction.go b/core/types/new_iolite_transaction.go
new file mode 100644
index 0000000..7d3ff36
--- /dev/null
+++ b/core/types/new_iolite_transaction.go
@@ -0,0 +1,97 @@
+ // Copyright 2018 ... iolite.TODO+ + package types+ + import (+ "io"+ "math/big"+ + "github.com/ethereum/go-ethereum/common"+ "github.com/ethereum/go-ethereum/rlp"+ )+ + // IoliteTransaction is an extra type, necessary for maintaining iolite transactions.+ type NewIoliteTransaction struct {+ data newtxdata+ }+ + type newtxdata struct {+ AccountNonce uint64 `json:"nonce" gencodec:"required"`+ Price *big.Int `json:"gasPrice" gencodec:"required"`+ GasLimit uint64 `json:"gas" gencodec:"required"`+ Recipient *common.Address `json:"to" rlp:"nil"` // nil means contract creation+ Amount *big.Int `json:"value" gencodec:"required"`+ Payload []byte `json:"input" gencodec:"required"`+ Metadata []byte `json:"metadata" gencodec:"required"`+ MetadataLimit *big.Int `json:"metadataLimit" gencodec:"required"`+ + // Signature values+ V *big.Int `json:"v" gencodec:"required"`+ R *big.Int `json:"r" gencodec:"required"`+ S *big.Int `json:"s" gencodec:"required"`+ }+ + // EncodeRLP implements rlp.Encoder+ func (tx *NewIoliteTransaction) EncodeRLP(w io.Writer) error {+ return rlp.Encode(w, &tx.data)+ }+ + // DecodeRLP implements rlp.Decoder+ func (tx *NewIoliteTransaction) DecodeRLP(s *rlp.Stream) error {+ return s.Decode(&tx.data)+ }+ + // AsTransaction returns the OldTransaction as a Transaction.+ func (tx *NewIoliteTransaction) AsTransaction() *Transaction {+ d := txdata{+ AccountNonce: tx.data.AccountNonce,+ Recipient: tx.data.Recipient,+ Payload: tx.data.Payload,+ Amount: tx.data.Amount,+ GasLimit: tx.data.GasLimit,+ Price: tx.data.Price,+ Metadata: tx.data.Metadata,+ MetadataLimit: tx.data.MetadataLimit,+ IsOld: 0,+ V: tx.data.V,+ R: tx.data.R,+ S: tx.data.S,+ }+ + return &Transaction{data: d}+ }+ + func CreateNewTransaction(nonce uint64, to common.Address, amount *big.Int, gasLimit uint64, gasPrice *big.Int, data []byte) *NewIoliteTransaction {+ return createNewTransaction(nonce, &to, amount, gasLimit, gasPrice, data)+ }+ + func CreateNewContractCreation(nonce uint64, amount *big.Int, gasLimit uint64, gasPrice *big.Int, data []byte) *NewIoliteTransaction {+ return createNewTransaction(nonce, nil, amount, gasLimit, gasPrice, data)+ }+ + func createNewTransaction(nonce uint64, to *common.Address, amount *big.Int, gasLimit uint64, gasPrice *big.Int, data []byte) *NewIoliteTransaction {+ if len(data) > 0 {+ data = common.CopyBytes(data)+ }+ d := newtxdata{+ AccountNonce: nonce,+ Recipient: to,+ Payload: data,+ Amount: new(big.Int),+ GasLimit: gasLimit,+ Price: new(big.Int),+ Metadata: nil,+ MetadataLimit: new(big.Int),+ V: new(big.Int),+ R: new(big.Int),+ S: new(big.Int),+ }+ if amount != nil {+ d.Amount.Set(amount)+ }+ if gasPrice != nil {+ d.Price.Set(gasPrice)+ }+ + return &NewIoliteTransaction{data: d}+ }core/types/old_transaction.go
Saved structure of the Ethereum transaction
Intermediate type that is used for backward compatibility
diff --git a/core/types/old_transaction.go b/core/types/old_transaction.go
new file mode 100644
index 0000000..b85206f
--- /dev/null
+++ b/core/types/old_transaction.go
@@ -0,0 +1,93 @@
+ // Copyright 2018 ... iolite.TODO+ + package types+ + import (+ "io"+ "math/big"+ + "github.com/ethereum/go-ethereum/common"+ "github.com/ethereum/go-ethereum/rlp"+ )+ + // OldTransaction is an extra type, necessary for maintaining pure ethereum transactions.+ type OldTransaction struct {+ data oldtxdata+ }+ + type oldtxdata struct {+ AccountNonce uint64 `json:"nonce" gencodec:"required"`+ Price *big.Int `json:"gasPrice" gencodec:"required"`+ GasLimit uint64 `json:"gas" gencodec:"required"`+ Recipient *common.Address `json:"to" rlp:"nil"` // nil means contract creation+ Amount *big.Int `json:"value" gencodec:"required"`+ Payload []byte `json:"input" gencodec:"required"`+ + // Signature values+ V *big.Int `json:"v" gencodec:"required"`+ R *big.Int `json:"r" gencodec:"required"`+ S *big.Int `json:"s" gencodec:"required"`+ }+ + // EncodeRLP implements rlp.Encoder+ func (tx *OldTransaction) EncodeRLP(w io.Writer) error {+ return rlp.Encode(w, &tx.data)+ }+ + // DecodeRLP implements rlp.Decoder+ func (tx *OldTransaction) DecodeRLP(s *rlp.Stream) error {+ return s.Decode(&tx.data)+ }+ + // AsTransaction returns the OldTransaction as a Transaction.+ func (tx *OldTransaction) AsTransaction() *Transaction {+ d := txdata{+ AccountNonce: tx.data.AccountNonce,+ Recipient: tx.data.Recipient,+ Payload: tx.data.Payload,+ Amount: tx.data.Amount,+ GasLimit: tx.data.GasLimit,+ Price: tx.data.Price,+ Metadata: nil,+ MetadataLimit: new(big.Int),+ IsOld: 1,+ V: tx.data.V,+ R: tx.data.R,+ S: tx.data.S,+ }+ + return &Transaction{data: d}+ }+ + func CreateOldTransaction(nonce uint64, to common.Address, amount *big.Int, gasLimit uint64, gasPrice *big.Int, data []byte) *OldTransaction {+ return createOldTransaction(nonce, &to, amount, gasLimit, gasPrice, data)+ }+ + func CreateOldContractCreation(nonce uint64, amount *big.Int, gasLimit uint64, gasPrice *big.Int, data []byte) *OldTransaction {+ return createOldTransaction(nonce, nil, amount, gasLimit, gasPrice, data)+ }+ + func createOldTransaction(nonce uint64, to *common.Address, amount *big.Int, gasLimit uint64, gasPrice *big.Int, data []byte) *OldTransaction {+ if len(data) > 0 {+ data = common.CopyBytes(data)+ }+ d := oldtxdata{+ AccountNonce: nonce,+ Recipient: to,+ Payload: data,+ Amount: new(big.Int),+ GasLimit: gasLimit,+ Price: new(big.Int),+ V: new(big.Int),+ R: new(big.Int),+ S: new(big.Int),+ }+ if amount != nil {+ d.Amount.Set(amount)+ }+ if gasPrice != nil {+ d.Price.Set(gasPrice)+ }+ + return &OldTransaction{data: d}+ }core/types/old_transaction_test.go diff --git a/core/types/old_transaction_test.go b/core/types/old_transaction_test.go
new file mode 100644
index 0000000..61edc8b
--- /dev/null
+++ b/core/types/old_transaction_test.go
@@ -0,0 +1,43 @@
+ // Copyright 2018 ... iolite.TODO+ package types+ + import (+ "bytes"+ "testing"+ + "github.com/ethereum/go-ethereum/common"+ "github.com/ethereum/go-ethereum/common/hexutil"+ "github.com/ethereum/go-ethereum/rlp"+ )+ + func TestNewTransaction(t *testing.T) {+ var tx Transaction+ err := rlp.Decode(bytes.NewReader(common.Hex2Bytes("f8a08183850430e23400833d090094c01bab898cc6aa51273a7a31bae1a32e5cbc517b8502540be40080b3f2d894c01bab898cc6aa51273a7a31bae1a32e5cbc517b822b67d894f0476fab07ee687f7f1feeb41703b7da737802628256ce801ca00e9f4ee0174f50425613f3707b9d7e5c439b295323a0d1da614e4ede558463d1a0258dfe621c94691f7fff3d0db08ba7eeef84bfb3e407cf53da40e44a4e72bfe4")), &tx)+ if err != nil {+ t.Error(err)+ t.FailNow()+ }+ + metadata := hexutil.Bytes(tx.Metadata()).String()+ should := "0xf2d894c01bab898cc6aa51273a7a31bae1a32e5cbc517b822b67d894f0476fab07ee687f7f1feeb41703b7da737802628256ce"+ if metadata != should {+ t.Errorf("Metadata mismatch, got %s, should %s", metadata, should)+ t.FailNow()+ }+ }+ + func TestOldTransaction(t *testing.T) {+ var tx OldTransaction+ if err != nil {+ t.Error(err)+ t.FailNow()+ }+ + metadata := hexutil.Bytes(tx.AsTransaction().Metadata()).String()+ should := "0x"+ if metadata != should {+ t.Errorf("Metadata mismatch, got %s, should %s", metadata, should)+ t.FailNow()+ }+ }
metaLogs field addedmetaGasUsed field added
diff --git a/core/types/receipt.go b/core/types/receipt.go
index 613f03d..5a625b0 100644
--- a/core/types/receipt.go
+++ b/core/types/receipt.go
@@ -20,10 +20,12 @@ import (
"bytes"
"fmt"
"io"
+ "math/big"+ "github.com/ethereum/go-ethereum/log"@@ -45,16 +47,18 @@ const (
// Receipt represents the results of a transaction.
type Receipt struct {
// Consensus fields
- PostState []byte `json:"root"`- Status uint `json:"status"`- CumulativeGasUsed uint64 `json:"cumulativeGasUsed" gencodec:"required"`- Bloom Bloom `json:"logsBloom" gencodec:"required"`- Logs []*Log `json:"logs" gencodec:"required"`+ PostState []byte `json:"root"`+ Status uint `json:"status"`+ CumulativeGasUsed uint64 `json:"cumulativeGasUsed" gencodec:"required"`+ Bloom Bloom `json:"logsBloom" gencodec:"required"`+ Logs []*Log `json:"logs" gencodec:"required"`+ MetaLogs []*MetaLog `json:"metaLogs" gencodec:"required"`+ MetaGasUsed uint64 `json:"metaGasUsed" gencodec:"required"`@@ -62,6 +66,7 @@ type receiptMarshaling struct {
Status hexutil.Uint
CumulativeGasUsed hexutil.Uint64
GasUsed hexutil.Uint64
+ MetaGasUsed hexutil.Uint64@@ -70,6 +75,7 @@ type receiptRLP struct {
CumulativeGasUsed uint64
Bloom Bloom
Logs []*Log
+ MetaLogs []*MetaLog@@ -79,7 +85,9 @@ type receiptStorageRLP struct {
TxHash common.Hash
ContractAddress common.Address
Logs []*LogForStorage
+ MetaLogs []*MetaLog+ MetaGasUsed uint64@@ -96,7 +104,7 @@ func NewReceipt(root []byte, failed bool, cumulativeGasUsed uint64) *Receipt {
// EncodeRLP implements rlp.Encoder, and flattens the consensus fields of a receipt
// into an RLP stream. If no post state is present, byzantium fork is assumed.
func (r *Receipt) EncodeRLP(w io.Writer) error {
- return rlp.Encode(w, &receiptRLP{r.statusEncoding(), r.CumulativeGasUsed, r.Bloom, r.Logs})+ return rlp.Encode(w, &receiptRLP{r.statusEncoding(), r.CumulativeGasUsed, r.Bloom, r.Logs, r.MetaLogs})@@ -110,6 +118,7 @@ func (r *Receipt) DecodeRLP(s *rlp.Stream) error {
return err
}
r.CumulativeGasUsed, r.Bloom, r.Logs = dec.CumulativeGasUsed, dec.Bloom, dec.Logs
+ r.MetaLogs = dec.MetaLogs@@ -146,6 +155,15 @@ func (r *Receipt) Size() common.StorageSize {
for _, log := range r.Logs {
size += common.StorageSize(len(log.Topics)*common.HashLength + len(log.Data))
}
+ + size += common.StorageSize(len(r.MetaLogs)) * common.StorageSize(unsafe.Sizeof(MetaLog{}))+ for _, metalog := range r.MetaLogs {+ size += common.StorageSize(common.AddressLength)+ size += common.StorageSize(len(metalog.Amount.Bits())) * common.StorageSize(unsafe.Sizeof(big.Word(0)))+ }+ + //iolite.TODO: Test during synchronization of the blockchain+ log.Iolite("Receipt", "Size", size)@@ -163,7 +181,9 @@ func (r *ReceiptForStorage) EncodeRLP(w io.Writer) error {
TxHash: r.TxHash,
ContractAddress: r.ContractAddress,
Logs: make([]*LogForStorage, len(r.Logs)),
+ MetaLogs: r.MetaLogs,+ MetaGasUsed: r.MetaGasUsed,@@ -187,6 +207,8 @@ func (r *ReceiptForStorage) DecodeRLP(s *rlp.Stream) error {
for i, log := range dec.Logs {
r.Logs[i] = (*Log)(log)
}
+ r.MetaLogs = dec.MetaLogs+ r.MetaGasUsed = dec.MetaGasUseddiff --git a/core/types/transaction.go b/core/types/transaction.go
index 70d757c..5340be7 100644
--- a/core/types/transaction.go
+++ b/core/types/transaction.go
@@ -54,12 +54,16 @@ type Transaction struct {
}
type txdata struct {
- AccountNonce uint64 `json:"nonce" gencodec:"required"`- Price *big.Int `json:"gasPrice" gencodec:"required"`- GasLimit uint64 `json:"gas" gencodec:"required"`- Recipient *common.Address `json:"to" rlp:"nil"` // nil means contract creation- Amount *big.Int `json:"value" gencodec:"required"`- Payload []byte `json:"input" gencodec:"required"`+ AccountNonce uint64 `json:"nonce" gencodec:"required"`+ Price *big.Int `json:"gasPrice" gencodec:"required"`+ GasLimit uint64 `json:"gas" gencodec:"required"`+ Recipient *common.Address `json:"to" rlp:"nil"` // nil means contract creation+ Amount *big.Int `json:"value" gencodec:"required"`+ Payload []byte `json:"input" gencodec:"required"`+ Metadata []byte `json:"metadata" gencodec:"required"`+ MetadataLimit *big.Int `json:"metadataLimit" gencodec:"required"`+ + IsOld uint `json:"isOld" gencodec:"required"`@@ -71,14 +75,17 @@ type txdata struct {
}
type txdataMarshaling struct {
- AccountNonce hexutil.Uint64- Price *hexutil.Big- GasLimit hexutil.Uint64- Amount *hexutil.Big- Payload hexutil.Bytes- V *hexutil.Big- R *hexutil.Big- S *hexutil.Big+ AccountNonce hexutil.Uint64+ Price *hexutil.Big+ GasLimit hexutil.Uint64+ Amount *hexutil.Big+ Payload hexutil.Bytes+ Metadata hexutil.Bytes+ MetadataLimit *hexutil.Big+ IsOld hexutil.Uint+ V *hexutil.Big+ R *hexutil.Big+ S *hexutil.Big@@ -94,15 +101,18 @@ func newTransaction(nonce uint64, to *common.Address, amount *big.Int, gasLimit
data = common.CopyBytes(data)
}
d := txdata{
- AccountNonce: nonce,- Recipient: to,- Payload: data,- Amount: new(big.Int),- GasLimit: gasLimit,- Price: new(big.Int),- V: new(big.Int),- R: new(big.Int),- S: new(big.Int),+ AccountNonce: nonce,+ Recipient: to,+ Payload: data,+ Amount: new(big.Int),+ GasLimit: gasLimit,+ Price: new(big.Int),+ Metadata: nil,+ MetadataLimit: new(big.Int),+ IsOld: 0,+ V: new(big.Int),+ R: new(big.Int),+ S: new(big.Int),@@ -177,12 +187,15 @@ 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) 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) Metadata() []byte { return common.CopyBytes(tx.data.Metadata) }+ func (tx *Transaction) MetadataLimit() *big.Int { return new(big.Int).Set(tx.data.MetadataLimit) }+ 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) Nonce() uint64 { return tx.data.AccountNonce }+ func (tx *Transaction) CheckNonce() bool { return true }+ func (tx *Transaction) IsOld() bool { return tx.data.IsOld != 0 }@@ -200,7 +213,12 @@ func (tx *Transaction) Hash() common.Hash {
if hash := tx.hash.Load(); hash != nil {
return hash.(common.Hash)
}
- v := rlpHash(tx)+ var v common.Hash+ if tx.IsOld() {+ v = rlpHash(tx.AsOldTransaction())+ } else {+ v = rlpHash(tx.AsNewIoliteTransaction())+ }@@ -224,13 +242,15 @@ func (tx *Transaction) Size() common.StorageSize {
// XXX Rename message to something less arbitrary?
func (tx *Transaction) AsMessage(s Signer) (Message, error) {
msg := Message{
- nonce: tx.data.AccountNonce,- gasLimit: tx.data.GasLimit,- gasPrice: new(big.Int).Set(tx.data.Price),- to: tx.data.Recipient,- amount: tx.data.Amount,- data: tx.data.Payload,- checkNonce: true,+ nonce: tx.data.AccountNonce,+ gasLimit: tx.data.GasLimit,+ gasPrice: new(big.Int).Set(tx.data.Price),+ to: tx.data.Recipient,+ amount: tx.data.Amount,+ data: tx.data.Payload,+ metadata: tx.data.Metadata,+ metadataLimit: tx.data.MetadataLimit,+ checkNonce: true,@@ -238,6 +258,40 @@ func (tx *Transaction) AsMessage(s Signer) (Message, error) {
return msg, err
}
+ func (tx *Transaction) AsOldTransaction() *OldTransaction {+ d := oldtxdata{+ AccountNonce: tx.data.AccountNonce,+ Recipient: tx.data.Recipient,+ Payload: tx.data.Payload,+ Amount: tx.data.Amount,+ GasLimit: tx.data.GasLimit,+ Price: tx.data.Price,+ V: tx.data.V,+ R: tx.data.R,+ S: tx.data.S,+ }+ + return &OldTransaction{data: d}+ }+ + func (tx *Transaction) AsNewIoliteTransaction() *NewIoliteTransaction {+ d := newtxdata{+ AccountNonce: tx.data.AccountNonce,+ Recipient: tx.data.Recipient,+ Payload: tx.data.Payload,+ Amount: tx.data.Amount,+ GasLimit: tx.data.GasLimit,+ Price: tx.data.Price,+ Metadata: tx.data.Metadata,+ MetadataLimit: tx.data.MetadataLimit,+ V: tx.data.V,+ R: tx.data.R,+ S: tx.data.S,+ }+ + return &NewIoliteTransaction{data: d}+ }+ @@ -386,34 +440,44 @@ func (t *TransactionsByPriceAndNonce) Pop() {
//
// NOTE: In a future PR this will be removed.
type Message struct {
- to *common.Address- from common.Address- nonce uint64- amount *big.Int- gasLimit uint64- gasPrice *big.Int- data []byte- checkNonce bool- }- - func NewMessage(from common.Address, to *common.Address, nonce uint64, amount *big.Int, gasLimit uint64, gasPrice *big.Int, data []byte, checkNonce bool) Message {+ to *common.Address+ from common.Address+ nonce uint64+ amount *big.Int+ gasLimit uint64+ gasPrice *big.Int+ data []byte+ metadata []byte+ metadataLimit *big.Int+ checkNonce bool+ }+ + func CreateNewMessage(from common.Address, to *common.Address, nonce uint64, amount *big.Int, gasLimit uint64, gasPrice *big.Int, data, metadata []byte, metadataLimit *big.Int, checkNonce bool) Message {- from: from,- to: to,- nonce: nonce,- amount: amount,- gasLimit: gasLimit,- gasPrice: gasPrice,- data: data,- checkNonce: checkNonce,+ from: from,+ to: to,+ nonce: nonce,+ amount: amount,+ gasLimit: gasLimit,+ gasPrice: gasPrice,+ data: data,+ metadata: metadata,+ metadataLimit: metadataLimit,+ checkNonce: checkNonce,- func (m Message) From() common.Address { return m.from }- func (m Message) To() *common.Address { return m.to }- func (m Message) GasPrice() *big.Int { return m.gasPrice }- func (m Message) Value() *big.Int { return m.amount }- func (m Message) Gas() uint64 { return m.gasLimit }- func (m Message) Nonce() uint64 { return m.nonce }- func (m Message) Data() []byte { return m.data }- func (m Message) CheckNonce() bool { return m.checkNonce }+ func NewMessage(from common.Address, to *common.Address, nonce uint64, amount *big.Int, gasLimit uint64, gasPrice *big.Int, data []byte, checkNonce bool) Message {+ return CreateNewMessage(from, to, nonce, amount, gasLimit, gasPrice, data, []byte{}, big.NewInt(0), checkNonce)+ }+ + func (m Message) From() common.Address { return m.from }+ func (m Message) To() *common.Address { return m.to }+ func (m Message) GasPrice() *big.Int { return m.gasPrice }+ func (m Message) Value() *big.Int { return m.amount }+ func (m Message) Gas() uint64 { return m.gasLimit }+ func (m Message) Nonce() uint64 { return m.nonce }+ func (m Message) Data() []byte { return m.data }+ func (m Message) Metadata() []byte { return m.metadata }+ func (m Message) MetadataLimit() *big.Int { return m.metadataLimit }+ func (m Message) CheckNonce() bool { return m.checkNonce }core/types/transaction_signing.go
Support for new transactions(Iolite ) and old(Ethereum ) ones
diff --git a/core/types/transaction_signing.go b/core/types/transaction_signing.go
index dfc84fd..9053222 100644
--- a/core/types/transaction_signing.go
+++ b/core/types/transaction_signing.go
@@ -153,6 +153,17 @@ func (s EIP155Signer) SignatureValues(tx *Transaction, sig []byte) (R, S, V *big
// Hash returns the hash to be signed by the sender.
// It does not uniquely identify the transaction.
func (s EIP155Signer) Hash(tx *Transaction) common.Hash {
+ if tx.IsOld() {+ return rlpHash([]interface{}{+ tx.data.AccountNonce,+ tx.data.Price,+ tx.data.GasLimit,+ tx.data.Recipient,+ tx.data.Amount,+ tx.data.Payload,+ s.chainId, uint(0), uint(0),+ })+ }@@ -160,6 +171,8 @@ func (s EIP155Signer) Hash(tx *Transaction) common.Hash {
tx.data.Recipient,
tx.data.Amount,
tx.data.Payload,
+ tx.data.Metadata,+ tx.data.MetadataLimit,@@ -205,6 +218,16 @@ func (fs FrontierSigner) SignatureValues(tx *Transaction, sig []byte) (r, s, v *
// Hash returns the hash to be signed by the sender.
// It does not uniquely identify the transaction.
func (fs FrontierSigner) Hash(tx *Transaction) common.Hash {
+ if tx.IsOld() {+ return rlpHash([]interface{}{+ tx.data.AccountNonce,+ tx.data.Price,+ tx.data.GasLimit,+ tx.data.Recipient,+ tx.data.Amount,+ tx.data.Payload,+ })+ }@@ -212,6 +235,8 @@ func (fs FrontierSigner) Hash(tx *Transaction) common.Hash {
tx.data.Recipient,
tx.data.Amount,
tx.data.Payload,
+ tx.data.Metadata,+ tx.data.MetadataLimit,transaction_signing_test.go diff --git a/core/types/transaction_signing_test.go b/core/types/transaction_signing_test.go
index 689fc38..2e1b492 100644
--- a/core/types/transaction_signing_test.go
+++ b/core/types/transaction_signing_test.go
@@ -94,12 +94,13 @@ func TestEIP155SigningVitalik(t *testing.T) {
} {
signer := NewEIP155Signer(big.NewInt(1))
- var tx *Transaction- err := rlp.DecodeBytes(common.Hex2Bytes(test.txRlp), &tx)+ var oldtx *OldTransaction+ err := rlp.DecodeBytes(common.Hex2Bytes(test.txRlp), &oldtx)+ tx := oldtx.AsTransaction()diff --git a/core/types/transaction_test.go b/core/types/transaction_test.go
index d1861b1..caa7e00 100644
--- a/core/types/transaction_test.go
+++ b/core/types/transaction_test.go
@@ -31,21 +31,21 @@ import (
// The values in those tests are from the Transaction Tests
// at github.com/ethereum/tests.
var (
- emptyTx = NewTransaction(+ emptyTx = CreateOldTransaction(- )+ ).AsTransaction()- rightvrsTx, _ = NewTransaction(+ rightvrsTx, _ = CreateOldTransaction(- ).WithSignature(+ ).AsTransaction().WithSignature(
Support for the modified method signature
diff --git a/eth/api_tracer.go b/eth/api_tracer.go
index 07c4457..78e6f92 100644
--- a/eth/api_tracer.go
+++ b/eth/api_tracer.go
@@ -446,7 +446,7 @@ func (api *PrivateDebugAPI) traceBlock(ctx context.Context, block *types.Block,
vmctx := core.NewEVMContext(msg, block.Header(), api.eth.blockchain, nil)
vmenv := vm.NewEVM(vmctx, statedb, api.config, vm.Config{})
- if _, _, _, err := core.ApplyMessage(vmenv, msg, new(core.GasPool).AddGas(msg.Gas())); err != nil {+ if _, _, _, _, _, err := core.ApplyMessage(vmenv, msg, new(core.GasPool).AddGas(msg.Gas())); err != nil {@@ -588,7 +588,7 @@ func (api *PrivateDebugAPI) traceTx(ctx context.Context, message core.Message, v
// Run the transaction with tracing enabled.
vmenv := vm.NewEVM(vmctx, statedb, api.config, vm.Config{Debug: true, Tracer: tracer})
- ret, gas, failed, err := core.ApplyMessage(vmenv, message, new(core.GasPool).AddGas(message.Gas()))+ _, ret, gas, _, failed, err := core.ApplyMessage(vmenv, message, new(core.GasPool).AddGas(message.Gas()))@@ -637,7 +637,7 @@ func (api *PrivateDebugAPI) computeTxEnv(blockHash common.Hash, txIndex int, ree
}
// Not yet the searched for transaction, execute on top of the current state
vmenv := vm.NewEVM(context, statedb, api.config, vm.Config{})
- if _, _, _, err := core.ApplyMessage(vmenv, msg, new(core.GasPool).AddGas(tx.Gas())); err != nil {+ if _, _, _, _, _, err := core.ApplyMessage(vmenv, msg, new(core.GasPool).AddGas(tx.Gas())); err != nil {
Support for the modified method signature
additional logs
Support metadata fields
diff --git a/internal/ethapi/api.go b/internal/ethapi/api.go
index e2bfbaf..bfa6b31 100644
--- a/internal/ethapi/api.go
+++ b/internal/ethapi/api.go
@@ -604,12 +604,14 @@ func (s *PublicBlockChainAPI) GetStorageAt(ctx context.Context, address common.A
// CallArgs represents the arguments for a call.
type CallArgs struct {
- From common.Address `json:"from"`- To *common.Address `json:"to"`- Gas hexutil.Uint64 `json:"gas"`- GasPrice hexutil.Big `json:"gasPrice"`- Value hexutil.Big `json:"value"`- Data hexutil.Bytes `json:"data"`+ From common.Address `json:"from"`+ To *common.Address `json:"to"`+ Gas hexutil.Uint64 `json:"gas"`+ GasPrice hexutil.Big `json:"gasPrice"`+ Value hexutil.Big `json:"value"`+ Data hexutil.Bytes `json:"data"`+ Metadata hexutil.Bytes `json:"metadata"`+ MetadataLimit hexutil.Big `json:"metadataLimit"`@@ -638,7 +640,7 @@ func (s *PublicBlockChainAPI) doCall(ctx context.Context, args CallArgs, blockNr
}
// Create new call message
- msg := types.NewMessage(addr, args.To, 0, args.Value.ToInt(), gas, gasPrice, args.Data, false)+ msg := types.CreateNewMessage(addr, args.To, 0, args.Value.ToInt(), gas, gasPrice, args.Data, args.Metadata, args.MetadataLimit.ToInt(), false)@@ -667,7 +669,7 @@ func (s *PublicBlockChainAPI) doCall(ctx context.Context, args CallArgs, blockNr
// Setup the gas pool (also for unmetered requests)
// and apply the message.
gp := new(core.GasPool).AddGas(math.MaxUint64)
- res, gas, failed, err := core.ApplyMessage(evm, msg, gp)+ _, res, gas, _, failed, err := core.ApplyMessage(evm, msg, gp)@@ -724,6 +726,7 @@ func (s *PublicBlockChainAPI) EstimateGas(ctx context.Context, args CallArgs) (h
// Reject the transaction as invalid if it still fails at the highest allowance
if hi == cap {
if !executable(hi) {
+ log.Iolite("EstimateGas", "gas required exceeds allowance or always failing transaction", args.Data)@@ -858,6 +861,9 @@ type RPCTransaction struct {
GasPrice *hexutil.Big `json:"gasPrice"`
Hash common.Hash `json:"hash"`
Input hexutil.Bytes `json:"input"`
+ Metadata hexutil.Bytes `json:"metadata"`+ MetadataLimit *hexutil.Big `json:"metadataLimit"`+ IsOld hexutil.Uint `json:"isOld"`@@ -877,18 +883,26 @@ func newRPCTransaction(tx *types.Transaction, blockHash common.Hash, blockNumber
from, _ := types.Sender(signer, tx)
v, r, s := tx.RawSignatureValues()
+ isOld := 0+ if tx.IsOld() {+ isOld = 1+ }+ - From: from,- Gas: hexutil.Uint64(tx.Gas()),- GasPrice: (*hexutil.Big)(tx.GasPrice()),- Hash: tx.Hash(),- Input: hexutil.Bytes(tx.Data()),- Nonce: hexutil.Uint64(tx.Nonce()),- To: tx.To(),- Value: (*hexutil.Big)(tx.Value()),- V: (*hexutil.Big)(v),- R: (*hexutil.Big)(r),- S: (*hexutil.Big)(s),+ From: from,+ Gas: hexutil.Uint64(tx.Gas()),+ GasPrice: (*hexutil.Big)(tx.GasPrice()),+ Hash: tx.Hash(),+ Input: hexutil.Bytes(tx.Data()),+ Metadata: hexutil.Bytes(tx.Metadata()),+ MetadataLimit: (*hexutil.Big)(tx.MetadataLimit()),+ IsOld: hexutil.Uint(isOld),+ Nonce: hexutil.Uint64(tx.Nonce()),+ To: tx.To(),+ Value: (*hexutil.Big)(tx.Value()),+ V: (*hexutil.Big)(v),+ R: (*hexutil.Big)(r),+ S: (*hexutil.Big)(s),@@ -1018,6 +1032,7 @@ func (s *PublicTransactionPoolAPI) GetTransactionByHash(ctx context.Context, has
}
// GetRawTransactionByHash returns the bytes of the transaction for the given hash.
+ // iolite.TODO fix for OldTransaction and NewIoliteTransaction@@ -1038,6 +1053,7 @@ func (s *PublicTransactionPoolAPI) GetTransactionReceipt(ctx context.Context, ha
if tx == nil {
return nil, nil
}
+ @@ -1065,6 +1081,8 @@ func (s *PublicTransactionPoolAPI) GetTransactionReceipt(ctx context.Context, ha
"contractAddress": nil,
"logs": receipt.Logs,
"logsBloom": receipt.Bloom,
+ "metaLogs": receipt.MetaLogs,+ "metaGasUsed": receipt.MetaGasUsed,@@ -1076,6 +1094,9 @@ func (s *PublicTransactionPoolAPI) GetTransactionReceipt(ctx context.Context, ha
if receipt.Logs == nil {
fields["logs"] = [][]*types.Log{}
}
+ + // iolite.TODO: allow metaLogs to be nil?+ @@ -1112,6 +1133,7 @@ type SendTxArgs struct {
// newer name and should be preferred by clients.
Data *hexutil.Bytes `json:"data"`
Input *hexutil.Bytes `json:"input"`
+ // iolite.TODO add metadata support@@ -1170,6 +1192,7 @@ func (args *SendTxArgs) toTransaction() *types.Transaction {
// submitTransaction is a helper function that submits tx to txPool and logs a message.
func submitTransaction(ctx context.Context, b Backend, tx *types.Transaction) (common.Hash, error) {
+ log.Iolite("submitTransaction", "hash", tx.Hash().Hex())@@ -1228,9 +1251,19 @@ func (s *PublicTransactionPoolAPI) SendTransaction(ctx context.Context, args Sen
// The sender is responsible for signing the transaction and using the correct nonce.
func (s *PublicTransactionPoolAPI) SendRawTransaction(ctx context.Context, encodedTx hexutil.Bytes) (common.Hash, error) {
tx := new(types.Transaction)
- if err := rlp.DecodeBytes(encodedTx, tx); err != nil {- return common.Hash{}, err+ oldtx := new(types.OldTransaction)+ newtx := new(types.NewIoliteTransaction)+ + if err := rlp.DecodeBytes(encodedTx, oldtx); err != nil {+ if err := rlp.DecodeBytes(encodedTx, newtx); err != nil {+ return common.Hash{}, err+ } else {+ tx = newtx.AsTransaction()+ }+ } else {+ tx = oldtx.AsTransaction()+ log.Iolite("SendRawTransaction", "fullhash", tx.Hash().Hex(), "metadata", hexutil.Encode(tx.Metadata()))
Support for the modified method signature
diff --git a/les/odr_test.go b/les/odr_test.go
index 88e121c..fbe411c 100644
--- a/les/odr_test.go
+++ b/les/odr_test.go
@@ -135,7 +135,7 @@ func odrContractCall(ctx context.Context, db ethdb.Database, config *params.Chai
//vmenv := core.NewEnv(statedb, config, bc, msg, header, vm.Config{})
gp := new(core.GasPool).AddGas(math.MaxUint64)
- ret, _, _, _ := core.ApplyMessage(vmenv, msg, gp)+ _, ret, _, _, _, _ := core.ApplyMessage(vmenv, msg, gp)@@ -146,7 +146,7 @@ func odrContractCall(ctx context.Context, db ethdb.Database, config *params.Chai
context := core.NewEVMContext(msg, header, lc, nil)
vmenv := vm.NewEVM(context, state, config, vm.Config{})
gp := new(core.GasPool).AddGas(math.MaxUint64)
- ret, _, _, _ := core.ApplyMessage(vmenv, msg, gp)+ _, ret, _, _, _, _ := core.ApplyMessage(vmenv, msg, gp)
Support for the modified method signature
diff --git a/light/odr_test.go b/light/odr_test.go
index d3f9374..7db343e 100644
--- a/light/odr_test.go
+++ b/light/odr_test.go
@@ -180,7 +180,7 @@ func odrContractCall(ctx context.Context, db ethdb.Database, bc *core.BlockChain
context := core.NewEVMContext(msg, header, chain, nil)
vmenv := vm.NewEVM(context, st, config, vm.Config{})
gp := new(core.GasPool).AddGas(math.MaxUint64)
- ret, _, _, _ := core.ApplyMessage(vmenv, msg, gp)+ _, ret, _, _, _, _ := core.ApplyMessage(vmenv, msg, gp)diff --git a/light/txpool.go b/light/txpool.go
index ca41490..baab5ec 100644
--- a/light/txpool.go
+++ b/light/txpool.go
@@ -23,6 +23,7 @@ import (
"time"
"github.com/ethereum/go-ethereum/common"
+ "github.com/ethereum/go-ethereum/common/hexutil"@@ -437,6 +438,7 @@ func (self *TxPool) Add(ctx context.Context, tx *types.Transaction) error {
//fmt.Println("Send", tx.Hash())
self.relay.Send(types.Transactions{tx})
+ log.Iolite("Light: Add to txpool", "data", hexutil.Encode(data))diff --git a/log/format.go b/log/format.go
index 0b07abb..bd3676f 100644
--- a/log/format.go
+++ b/log/format.go
@@ -96,6 +96,8 @@ func TerminalFormat(usecolor bool) Format {
color = 33
case LvlInfo:
color = 32
+ case LvlIolite:+ color = 95diff --git a/log/logger.go b/log/logger.go
index 15c83a9..1657a67 100644
--- a/log/logger.go
+++ b/log/logger.go
@@ -20,6 +20,7 @@ const (
LvlError
LvlWarn
LvlInfo
+ LvlIolite@@ -31,6 +32,8 @@ func (l Lvl) AlignedString() string {
return "TRACE"
case LvlDebug:
return "DEBUG"
+ case LvlIolite:+ return "ILT "@@ -51,6 +54,8 @@ func (l Lvl) String() string {
return "trce"
case LvlDebug:
return "dbug"
+ case LvlIolite:+ return "ilt"@@ -72,6 +77,8 @@ func LvlFromString(lvlString string) (Lvl, error) {
return LvlTrace, nil
case "debug", "dbug":
return LvlDebug, nil
+ case "iolite", "ilt":+ return LvlIolite, nil@@ -115,6 +122,7 @@ type Logger interface {
// Log a message at the given level with context key/value pairs
Trace(msg string, ctx ...interface{})
Debug(msg string, ctx ...interface{})
+ Iolite(msg string, ctx ...interface{})@@ -163,6 +171,10 @@ func (l *logger) Debug(msg string, ctx ...interface{}) {
l.write(msg, LvlDebug, ctx)
}
+ func (l *logger) Iolite(msg string, ctx ...interface{}) {+ l.write(msg, LvlIolite, ctx)+ }+ diff --git a/log/root.go b/log/root.go
index 71b8cef..1c62287 100644
--- a/log/root.go
+++ b/log/root.go
@@ -39,6 +39,11 @@ func Debug(msg string, ctx ...interface{}) {
root.write(msg, LvlDebug, ctx)
}
+ // Iolite is a convenient alias for Root().Iolite+ func Iolite(msg string, ctx ...interface{}) {+ root.write(msg, LvlIolite, ctx)+ }+ diff --git a/log/syslog.go b/log/syslog.go
index 71a17b3..62e67c7 100644
--- a/log/syslog.go
+++ b/log/syslog.go
@@ -36,6 +36,8 @@ func sharedSyslog(fmtr Format, sysWr *syslog.Writer, err error) (Handler, error)
syslogFn = sysWr.Warning
case LvlInfo:
syslogFn = sysWr.Info
+ case LvlIolite:+ syslogFn = sysWr.Infodiff --git a/node/node.go b/node/node.go
index b02aecf..5b1fa1f 100644
--- a/node/node.go
+++ b/node/node.go
@@ -287,7 +287,7 @@ func (n *Node) startInProc(apis []rpc.API) error {
if err := handler.RegisterName(api.Namespace, api.Service); err != nil {
return err
}
- n.log.Debug("InProc registered", "service", api.Service, "namespace", api.Namespace)+ n.log.Info("InProc registered", "service", api.Service, "namespace", api.Namespace)
Support for the modified method signature
diff --git a/tests/state_test_util.go b/tests/state_test_util.go
index 3b761bd..faf62a8 100644
--- a/tests/state_test_util.go
+++ b/tests/state_test_util.go
@@ -141,7 +141,7 @@ func (t *StateTest) Run(subtest StateSubtest, vmconfig vm.Config) (*state.StateD
gaspool := new(core.GasPool)
gaspool.AddGas(block.GasLimit())
snapshot := statedb.Snapshot()
- if _, _, _, err := core.ApplyMessage(evm, msg, gaspool); err != nil {+ if _, _, _, _, _, err := core.ApplyMessage(evm, msg, gaspool); err != nil {