diff --git a/cmd/geth/consolecmd_test.go b/cmd/geth/consolecmd_test.go
index 067eee2f23..b2aed43bc1 100644
--- a/cmd/geth/consolecmd_test.go
+++ b/cmd/geth/consolecmd_test.go
@@ -32,7 +32,7 @@ import (
 )
 
 const (
-	ipcAPIs  = "admin:1.0 debug:1.0 eth:1.0 ethash:1.0 miner:1.0 net:1.0 personal:1.0 rpc:1.0 txpool:1.0 web3:1.0"
+	ipcAPIs  = "admin:1.0 debug:1.0 eth:1.0 ethash:1.0 miner:1.0 net:1.0 personal:1.0 rpc:1.0 trace:1.0 txpool:1.0 web3:1.0"
 	httpAPIs = "eth:1.0 net:1.0 rpc:1.0 web3:1.0"
 )
 
diff --git a/consensus/ethash/consensus.go b/consensus/ethash/consensus.go
index 13fc5ae298..8322f76708 100644
--- a/consensus/ethash/consensus.go
+++ b/consensus/ethash/consensus.go
@@ -584,31 +584,44 @@ var (
 	big32 = big.NewInt(32)
 )
 
-// AccumulateRewards credits the coinbase of the given block with the mining
-// reward. The total reward consists of the static block reward and rewards for
-// included uncles. The coinbase of each uncle block is also rewarded.
-func accumulateRewards(config ctypes.ChainConfigurator, state *state.StateDB, header *types.Header, uncles []*types.Header) {
+// GetRewards calculates the mining reward.
+// The total reward consists of the static block reward and rewards for
+// included uncles. The coinbase of each uncle block is also calculated.
+func GetRewards(config ctypes.ChainConfigurator, header *types.Header, uncles []*types.Header) (*big.Int, []*big.Int) {
 	if config.IsEnabled(config.GetEthashECIP1017Transition, header.Number) {
-		ecip1017BlockReward(config, state, header, uncles)
-		return
+		return ecip1017BlockReward(config, header, uncles)
 	}
 
 	blockReward := ctypes.EthashBlockReward(config, header.Number)
 
 	// Accumulate the rewards for the miner and any included uncles
+	uncleRewards := make([]*big.Int, len(uncles))
 	reward := new(big.Int).Set(blockReward)
 	r := new(big.Int)
-	for _, uncle := range uncles {
+	for i, uncle := range uncles {
 		r.Add(uncle.Number, big8)
 		r.Sub(r, header.Number)
 		r.Mul(r, blockReward)
 		r.Div(r, big8)
-		state.AddBalance(uncle.Coinbase, r)
+
+		ur := new(big.Int).Set(r)
+		uncleRewards[i] = ur
 
 		r.Div(blockReward, big32)
 		reward.Add(reward, r)
 	}
-	state.AddBalance(header.Coinbase, reward)
+
+	return reward, uncleRewards
+}
+
+// accumulateRewards credits the coinbase of the given block with the mining
+// reward. The coinbase of each uncle block is also rewarded.
+func accumulateRewards(config ctypes.ChainConfigurator, state *state.StateDB, header *types.Header, uncles []*types.Header) {
+	minerReward, uncleRewards := GetRewards(config, header, uncles)
+	for i, uncle := range uncles {
+		state.AddBalance(uncle.Coinbase, uncleRewards[i])
+	}
+	state.AddBalance(header.Coinbase, minerReward)
 }
 
 // As of "Era 2" (zero-index era 1), uncle miners and winners are rewarded equally for each included block.
diff --git a/consensus/ethash/consensus_classic.go b/consensus/ethash/consensus_classic.go
index 179619186b..b472c9394f 100644
--- a/consensus/ethash/consensus_classic.go
+++ b/consensus/ethash/consensus_classic.go
@@ -18,13 +18,12 @@ package ethash
 import (
 	"math/big"
 
-	"github.com/ethereum/go-ethereum/core/state"
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/params/types/ctypes"
 	"github.com/ethereum/go-ethereum/params/vars"
 )
 
-func ecip1017BlockReward(config ctypes.ChainConfigurator, state *state.StateDB, header *types.Header, uncles []*types.Header) {
+func ecip1017BlockReward(config ctypes.ChainConfigurator, header *types.Header, uncles []*types.Header) (*big.Int, []*big.Int) {
 	blockReward := vars.FrontierBlockReward
 
 	// Ensure value 'era' is configured.
@@ -33,13 +32,15 @@ func ecip1017BlockReward(config ctypes.ChainConfigurator, state *state.StateDB,
 	wr := GetBlockWinnerRewardByEra(era, blockReward)                    // wr "winner reward". 5, 4, 3.2, 2.56, ...
 	wurs := GetBlockWinnerRewardForUnclesByEra(era, uncles, blockReward) // wurs "winner uncle rewards"
 	wr.Add(wr, wurs)
-	state.AddBalance(header.Coinbase, wr) // $$
 
 	// Reward uncle miners.
-	for _, uncle := range uncles {
+	uncleRewards := make([]*big.Int, len(uncles))
+	for i, uncle := range uncles {
 		ur := GetBlockUncleRewardByEra(era, header, uncle, blockReward)
-		state.AddBalance(uncle.Coinbase, ur) // $$
+		uncleRewards[i] = ur
 	}
+
+	return wr, uncleRewards
 }
 
 func ecip1010Explosion(config ctypes.ChainConfigurator, next *big.Int, exPeriodRef *big.Int) {
diff --git a/core/vm/evm.go b/core/vm/evm.go
index 015f7ec368..2fd7eb543a 100644
--- a/core/vm/evm.go
+++ b/core/vm/evm.go
@@ -121,10 +121,13 @@ type EVM struct {
 	// abort is used to abort the EVM calling operations
 	// NOTE: must be set atomically
 	abort int32
-	// callGasTemp holds the gas available for the current call. This is needed because the
+	// CallGasTemp holds the gas available for the current call. This is needed because the
 	// available gas is calculated in gasCall* according to the 63/64 rule and later
 	// applied in opCall*.
-	callGasTemp uint64
+	CallGasTemp uint64
+	// callErrorTemp holds any errors caused during the execution of system opcodes (0xf0)
+	// NOTE: it's being used only for tracers
+	CallErrorTemp error
 }
 
 // NewEVM returns a new EVM. The returned EVM is not thread safe and should
diff --git a/core/vm/gas.go b/core/vm/gas.go
index 5cf1d852d2..2164871eb7 100644
--- a/core/vm/gas.go
+++ b/core/vm/gas.go
@@ -30,6 +30,18 @@ const (
 	GasExtStep     uint64 = 20
 )
 
+// createGas returns the actual gas available for the call.
+//
+// The cost of gas was changed during the homestead price change HF.
+// As part of EIP 150 (TangerineWhistle), the returned gas is gas - gas * 63 / 64.
+func createGasEip150(isEip150 bool, availableGas uint64) (uint64, error) {
+	if isEip150 {
+		gas := availableGas - availableGas/64
+		return gas, nil
+	}
+	return availableGas, nil
+}
+
 // callGas returns the actual gas cost of the call.
 //
 // The cost of gas was changed during the homestead price change HF.
diff --git a/core/vm/gas_table.go b/core/vm/gas_table.go
index 348e2b7103..5632d4fac4 100644
--- a/core/vm/gas_table.go
+++ b/core/vm/gas_table.go
@@ -283,9 +283,28 @@ var (
 	gasMLoad   = pureMemoryGascost
 	gasMStore8 = pureMemoryGascost
 	gasMStore  = pureMemoryGascost
-	gasCreate  = pureMemoryGascost
 )
 
+func gasCreate(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (uint64, error) {
+	var overflow bool
+	gas, err := memoryGasCost(mem, memorySize)
+	if err != nil {
+		return 0, err
+	}
+	remainingGasTemp, overflow := math.SafeSub(contract.Gas, gas)
+	if overflow {
+		return 0, ErrGasUintOverflow
+	}
+	evm.CallGasTemp, err = createGasEip150(evm.ChainConfig().IsEnabled(evm.chainConfig.GetEIP150Transition, evm.BlockNumber), remainingGasTemp)
+	if err != nil {
+		return 0, err
+	}
+	if gas, overflow = math.SafeAdd(gas, evm.CallGasTemp); overflow {
+		return 0, ErrGasUintOverflow
+	}
+	return gas, nil
+}
+
 func gasCreate2(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize uint64) (uint64, error) {
 	gas, err := memoryGasCost(mem, memorySize)
 	if err != nil {
@@ -301,6 +320,17 @@ func gasCreate2(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memoryS
 	if gas, overflow = math.SafeAdd(gas, wordGas); overflow {
 		return 0, ErrGasUintOverflow
 	}
+	remainingGasTemp, overflow := math.SafeSub(contract.Gas, gas)
+	if overflow {
+		return 0, ErrGasUintOverflow
+	}
+	evm.CallGasTemp, err = createGasEip150(evm.ChainConfig().IsEnabled(evm.chainConfig.GetEIP150Transition, evm.BlockNumber), remainingGasTemp)
+	if err != nil {
+		return 0, err
+	}
+	if gas, overflow = math.SafeAdd(gas, evm.CallGasTemp); overflow {
+		return 0, ErrGasUintOverflow
+	}
 	return gas, nil
 }
 
@@ -356,11 +386,11 @@ func gasCall(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memorySize
 		return 0, ErrGasUintOverflow
 	}
 
-	evm.callGasTemp, err = callGas(evm.ChainConfig().IsEnabled(evm.chainConfig.GetEIP150Transition, evm.BlockNumber), contract.Gas, gas, stack.Back(0))
+	evm.CallGasTemp, err = callGas(evm.ChainConfig().IsEnabled(evm.chainConfig.GetEIP150Transition, evm.BlockNumber), contract.Gas, gas, stack.Back(0))
 	if err != nil {
 		return 0, err
 	}
-	if gas, overflow = math.SafeAdd(gas, evm.callGasTemp); overflow {
+	if gas, overflow = math.SafeAdd(gas, evm.CallGasTemp); overflow {
 		return 0, ErrGasUintOverflow
 	}
 	return gas, nil
@@ -381,11 +411,11 @@ func gasCallCode(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memory
 	if gas, overflow = math.SafeAdd(gas, memoryGas); overflow {
 		return 0, ErrGasUintOverflow
 	}
-	evm.callGasTemp, err = callGas(evm.ChainConfig().IsEnabled(evm.chainConfig.GetEIP150Transition, evm.BlockNumber), contract.Gas, gas, stack.Back(0))
+	evm.CallGasTemp, err = callGas(evm.ChainConfig().IsEnabled(evm.chainConfig.GetEIP150Transition, evm.BlockNumber), contract.Gas, gas, stack.Back(0))
 	if err != nil {
 		return 0, err
 	}
-	if gas, overflow = math.SafeAdd(gas, evm.callGasTemp); overflow {
+	if gas, overflow = math.SafeAdd(gas, evm.CallGasTemp); overflow {
 		return 0, ErrGasUintOverflow
 	}
 	return gas, nil
@@ -396,12 +426,12 @@ func gasDelegateCall(evm *EVM, contract *Contract, stack *Stack, mem *Memory, me
 	if err != nil {
 		return 0, err
 	}
-	evm.callGasTemp, err = callGas(evm.ChainConfig().IsEnabled(evm.chainConfig.GetEIP150Transition, evm.BlockNumber), contract.Gas, gas, stack.Back(0))
+	evm.CallGasTemp, err = callGas(evm.ChainConfig().IsEnabled(evm.chainConfig.GetEIP150Transition, evm.BlockNumber), contract.Gas, gas, stack.Back(0))
 	if err != nil {
 		return 0, err
 	}
 	var overflow bool
-	if gas, overflow = math.SafeAdd(gas, evm.callGasTemp); overflow {
+	if gas, overflow = math.SafeAdd(gas, evm.CallGasTemp); overflow {
 		return 0, ErrGasUintOverflow
 	}
 	return gas, nil
@@ -412,12 +442,12 @@ func gasStaticCall(evm *EVM, contract *Contract, stack *Stack, mem *Memory, memo
 	if err != nil {
 		return 0, err
 	}
-	evm.callGasTemp, err = callGas(evm.ChainConfig().IsEnabled(evm.chainConfig.GetEIP150Transition, evm.BlockNumber), contract.Gas, gas, stack.Back(0))
+	evm.CallGasTemp, err = callGas(evm.ChainConfig().IsEnabled(evm.chainConfig.GetEIP150Transition, evm.BlockNumber), contract.Gas, gas, stack.Back(0))
 	if err != nil {
 		return 0, err
 	}
 	var overflow bool
-	if gas, overflow = math.SafeAdd(gas, evm.callGasTemp); overflow {
+	if gas, overflow = math.SafeAdd(gas, evm.CallGasTemp); overflow {
 		return 0, ErrGasUintOverflow
 	}
 	return gas, nil
diff --git a/core/vm/instructions.go b/core/vm/instructions.go
index 5562f752c3..0355ac4e99 100644
--- a/core/vm/instructions.go
+++ b/core/vm/instructions.go
@@ -599,15 +599,11 @@ func opCreate(pc *uint64, interpreter *EVMInterpreter, callContext *callCtx) ([]
 		value        = callContext.stack.pop()
 		offset, size = callContext.stack.pop(), callContext.stack.pop()
 		input        = callContext.memory.GetCopy(int64(offset.Uint64()), int64(size.Uint64()))
-		gas          = callContext.contract.Gas
+		gas          = interpreter.evm.CallGasTemp
 	)
-	if interpreter.evm.ChainConfig().IsEnabled(interpreter.evm.chainConfig.GetEIP150Transition, interpreter.evm.BlockNumber) {
-		gas -= gas / 64
-	}
 	// reuse size int for stackvalue
 	stackvalue := size
 
-	callContext.contract.UseGas(gas)
 	//TODO: use uint256.Int instead of converting with toBig()
 	var bigVal = big0
 	if !value.IsZero() {
@@ -621,8 +617,10 @@ func opCreate(pc *uint64, interpreter *EVMInterpreter, callContext *callCtx) ([]
 	// ignore this error and pretend the operation was successful.
 	if interpreter.evm.ChainConfig().IsEnabled(interpreter.evm.chainConfig.GetEIP2Transition, interpreter.evm.BlockNumber) && suberr == ErrCodeStoreOutOfGas {
 		stackvalue.Clear()
+		interpreter.evm.CallErrorTemp = suberr // temp storage, for debug tracing
 	} else if suberr != nil && suberr != ErrCodeStoreOutOfGas {
 		stackvalue.Clear()
+		interpreter.evm.CallErrorTemp = suberr // temp storage, for debug tracing
 	} else {
 		stackvalue.SetBytes(addr.Bytes())
 	}
@@ -641,12 +639,8 @@ func opCreate2(pc *uint64, interpreter *EVMInterpreter, callContext *callCtx) ([
 		offset, size = callContext.stack.pop(), callContext.stack.pop()
 		salt         = callContext.stack.pop()
 		input        = callContext.memory.GetCopy(int64(offset.Uint64()), int64(size.Uint64()))
-		gas          = callContext.contract.Gas
+		gas          = interpreter.evm.CallGasTemp
 	)
-
-	// Apply EIP150
-	gas -= gas / 64
-	callContext.contract.UseGas(gas)
 	// reuse size int for stackvalue
 	stackvalue := size
 	//TODO: use uint256.Int instead of converting with toBig()
@@ -659,6 +653,7 @@ func opCreate2(pc *uint64, interpreter *EVMInterpreter, callContext *callCtx) ([
 	// Push item on the stack based on the returned error.
 	if suberr != nil {
 		stackvalue.Clear()
+		interpreter.evm.CallErrorTemp = suberr // temp storage, for debug tracing
 	} else {
 		stackvalue.SetBytes(addr.Bytes())
 	}
@@ -673,10 +668,10 @@ func opCreate2(pc *uint64, interpreter *EVMInterpreter, callContext *callCtx) ([
 
 func opCall(pc *uint64, interpreter *EVMInterpreter, callContext *callCtx) ([]byte, error) {
 	stack := callContext.stack
-	// Pop gas. The actual gas in interpreter.evm.callGasTemp.
+	// Pop gas. The actual gas in interpreter.evm.CallGasTemp.
 	// We can use this as a temporary value
 	temp := stack.pop()
-	gas := interpreter.evm.callGasTemp
+	gas := interpreter.evm.CallGasTemp
 	// Pop other call parameters.
 	addr, value, inOffset, inSize, retOffset, retSize := stack.pop(), stack.pop(), stack.pop(), stack.pop(), stack.pop(), stack.pop()
 	toAddr := common.Address(addr.Bytes20())
@@ -696,6 +691,7 @@ func opCall(pc *uint64, interpreter *EVMInterpreter, callContext *callCtx) ([]by
 
 	if err != nil {
 		temp.Clear()
+		interpreter.evm.CallErrorTemp = err // temp storage, for debug tracing
 	} else {
 		temp.SetOne()
 	}
@@ -709,11 +705,11 @@ func opCall(pc *uint64, interpreter *EVMInterpreter, callContext *callCtx) ([]by
 }
 
 func opCallCode(pc *uint64, interpreter *EVMInterpreter, callContext *callCtx) ([]byte, error) {
-	// Pop gas. The actual gas is in interpreter.evm.callGasTemp.
+	// Pop gas. The actual gas is in interpreter.evm.CallGasTemp.
 	stack := callContext.stack
 	// We use it as a temporary value
 	temp := stack.pop()
-	gas := interpreter.evm.callGasTemp
+	gas := interpreter.evm.CallGasTemp
 	// Pop other call parameters.
 	addr, value, inOffset, inSize, retOffset, retSize := stack.pop(), stack.pop(), stack.pop(), stack.pop(), stack.pop(), stack.pop()
 	toAddr := common.Address(addr.Bytes20())
@@ -730,6 +726,7 @@ func opCallCode(pc *uint64, interpreter *EVMInterpreter, callContext *callCtx) (
 	ret, returnGas, err := interpreter.evm.CallCode(callContext.contract, toAddr, args, gas, bigVal)
 	if err != nil {
 		temp.Clear()
+		interpreter.evm.CallErrorTemp = err // temp storage, for debug tracing
 	} else {
 		temp.SetOne()
 	}
@@ -744,10 +741,10 @@ func opCallCode(pc *uint64, interpreter *EVMInterpreter, callContext *callCtx) (
 
 func opDelegateCall(pc *uint64, interpreter *EVMInterpreter, callContext *callCtx) ([]byte, error) {
 	stack := callContext.stack
-	// Pop gas. The actual gas is in interpreter.evm.callGasTemp.
+	// Pop gas. The actual gas is in interpreter.evm.CallGasTemp.
 	// We use it as a temporary value
 	temp := stack.pop()
-	gas := interpreter.evm.callGasTemp
+	gas := interpreter.evm.CallGasTemp
 	// Pop other call parameters.
 	addr, inOffset, inSize, retOffset, retSize := stack.pop(), stack.pop(), stack.pop(), stack.pop(), stack.pop()
 	toAddr := common.Address(addr.Bytes20())
@@ -757,6 +754,7 @@ func opDelegateCall(pc *uint64, interpreter *EVMInterpreter, callContext *callCt
 	ret, returnGas, err := interpreter.evm.DelegateCall(callContext.contract, toAddr, args, gas)
 	if err != nil {
 		temp.Clear()
+		interpreter.evm.CallErrorTemp = err // temp storage, for debug tracing
 	} else {
 		temp.SetOne()
 	}
@@ -770,11 +768,11 @@ func opDelegateCall(pc *uint64, interpreter *EVMInterpreter, callContext *callCt
 }
 
 func opStaticCall(pc *uint64, interpreter *EVMInterpreter, callContext *callCtx) ([]byte, error) {
-	// Pop gas. The actual gas is in interpreter.evm.callGasTemp.
+	// Pop gas. The actual gas is in interpreter.evm.CallGasTemp.
 	stack := callContext.stack
 	// We use it as a temporary value
 	temp := stack.pop()
-	gas := interpreter.evm.callGasTemp
+	gas := interpreter.evm.CallGasTemp
 	// Pop other call parameters.
 	addr, inOffset, inSize, retOffset, retSize := stack.pop(), stack.pop(), stack.pop(), stack.pop(), stack.pop()
 	toAddr := common.Address(addr.Bytes20())
@@ -784,6 +782,7 @@ func opStaticCall(pc *uint64, interpreter *EVMInterpreter, callContext *callCtx)
 	ret, returnGas, err := interpreter.evm.StaticCall(callContext.contract, toAddr, args, gas)
 	if err != nil {
 		temp.Clear()
+		interpreter.evm.CallErrorTemp = err // temp storage, for debug tracing
 	} else {
 		temp.SetOne()
 	}
diff --git a/core/vm/interpreter.go b/core/vm/interpreter.go
index e61d69cd24..0df124224a 100644
--- a/core/vm/interpreter.go
+++ b/core/vm/interpreter.go
@@ -200,6 +200,9 @@ func (in *EVMInterpreter) Run(contract *Contract, input []byte, readOnly bool) (
 			logged, pcCopy, gasCopy = false, pc, contract.Gas
 		}
 
+		// Clean up the CallGasTemp on every iteration, as you never know how it might be used in the future, causing false positives
+		in.evm.CallGasTemp = 0
+
 		// Get the operation from the jump table and validate the stack to ensure there are
 		// enough stack items available to perform the operation.
 		op = contract.GetOp(pc)
@@ -246,6 +249,7 @@ func (in *EVMInterpreter) Run(contract *Contract, input []byte, readOnly bool) (
 				return nil, ErrGasUintOverflow
 			}
 		}
+
 		// Dynamic portion of gas
 		// consume the gas and return an error if not enough gas is available.
 		// cost is explicitly set so that the capture state defer method can get the proper cost
diff --git a/eth/api.go b/eth/api.go
index 462c25bad8..4ae042b0af 100644
--- a/eth/api.go
+++ b/eth/api.go
@@ -548,3 +548,15 @@ func (api *PrivateDebugAPI) getModifiedAccounts(startBlock, endBlock *types.Bloc
 func (api *PrivateDebugAPI) RemovePendingTransaction(hash common.Hash) (*types.Transaction, error) {
 	return api.eth.txPool.RemoveTx(hash), nil
 }
+
+// PrivateTraceAPI is the collection of Ethereum full node APIs exposed over
+// the private debugging endpoint.
+type PrivateTraceAPI struct {
+	eth *Ethereum
+}
+
+// NewPrivateTraceAPI creates a new API definition for the full node-related
+// private debug methods of the Ethereum service.
+func NewPrivateTraceAPI(eth *Ethereum) *PrivateTraceAPI {
+	return &PrivateTraceAPI{eth: eth}
+}
diff --git a/eth/api_tracer.go b/eth/api_tracer.go
index cc0a7b93f2..66314c0bd2 100644
--- a/eth/api_tracer.go
+++ b/eth/api_tracer.go
@@ -95,8 +95,9 @@ type blockTraceResult struct {
 // txTraceTask represents a single transaction trace task when an entire block
 // is being traced.
 type txTraceTask struct {
-	statedb *state.StateDB // Intermediate state prepped for tracing
-	index   int            // Transaction offset in the block
+	statedb          *state.StateDB // Intermediate state prepped for tracing
+	index            int            // Transaction offset in the block
+	taskExtraContext map[string]interface{}
 }
 
 // TraceChain returns the structured logs created during the execution of EVM
@@ -208,7 +209,7 @@ func (api *PrivateDebugAPI) traceChain(ctx context.Context, start, end *types.Bl
 					msg, _ := tx.AsMessage(signer)
 					vmctx := core.NewEVMContext(msg, task.block.Header(), api.eth.blockchain, nil)
 
-					res, err := api.traceTx(ctx, msg, vmctx, task.statedb, config)
+					res, err := traceTx(ctx, api.eth, msg, vmctx, task.statedb, nil, config)
 					if err != nil {
 						task.results[i] = &txTraceResult{Error: err.Error()}
 						log.Warn("Tracing failed", "hash", tx.Hash(), "block", task.block.NumberU64(), "err", err)
@@ -352,23 +353,29 @@ func (api *PrivateDebugAPI) traceChain(ctx context.Context, start, end *types.Bl
 
 // TraceBlockByNumber returns the structured logs created during the execution of
 // EVM and returns them as a JSON object.
-func (api *PrivateDebugAPI) TraceBlockByNumber(ctx context.Context, number rpc.BlockNumber, config *TraceConfig) ([]*txTraceResult, error) {
+func traceBlockByNumber(ctx context.Context, eth *Ethereum, number rpc.BlockNumber, config *TraceConfig) ([]*txTraceResult, error) {
 	// Fetch the block that we want to trace
 	var block *types.Block
 
 	switch number {
 	case rpc.PendingBlockNumber:
-		block = api.eth.miner.PendingBlock()
+		block = eth.miner.PendingBlock()
 	case rpc.LatestBlockNumber:
-		block = api.eth.blockchain.CurrentBlock()
+		block = eth.blockchain.CurrentBlock()
 	default:
-		block = api.eth.blockchain.GetBlockByNumber(uint64(number))
+		block = eth.blockchain.GetBlockByNumber(uint64(number))
 	}
 	// Trace the block if it was found
 	if block == nil {
 		return nil, fmt.Errorf("block #%d not found", number)
 	}
-	return api.traceBlock(ctx, block, config)
+	return traceBlock(ctx, eth, block, config)
+}
+
+// TraceBlockByNumber returns the structured logs created during the execution of
+// EVM and returns them as a JSON object.
+func (api *PrivateDebugAPI) TraceBlockByNumber(ctx context.Context, number rpc.BlockNumber, config *TraceConfig) ([]*txTraceResult, error) {
+	return traceBlockByNumber(ctx, api.eth, number, config)
 }
 
 // TraceBlockByHash returns the structured logs created during the execution of
@@ -381,14 +388,20 @@ func (api *PrivateDebugAPI) TraceBlockByHash(ctx context.Context, hash common.Ha
 	return api.traceBlock(ctx, block, config)
 }
 
-// TraceBlock returns the structured logs created during the execution of EVM
+// traceBlockRLP returns the structured logs created during the execution of EVM
 // and returns them as a JSON object.
-func (api *PrivateDebugAPI) TraceBlock(ctx context.Context, blob []byte, config *TraceConfig) ([]*txTraceResult, error) {
+func traceBlockRLP(ctx context.Context, eth *Ethereum, blob []byte, config *TraceConfig) ([]*txTraceResult, error) {
 	block := new(types.Block)
 	if err := rlp.Decode(bytes.NewReader(blob), block); err != nil {
 		return nil, fmt.Errorf("could not decode block: %v", err)
 	}
-	return api.traceBlock(ctx, block, config)
+	return traceBlock(ctx, eth, block, config)
+}
+
+// TraceBlock returns the structured logs created during the execution of EVM
+// and returns them as a JSON object.
+func (api *PrivateDebugAPI) TraceBlock(ctx context.Context, blob []byte, config *TraceConfig) ([]*txTraceResult, error) {
+	return traceBlockRLP(ctx, api.eth, blob, config)
 }
 
 // TraceBlockFromFile returns the structured logs created during the execution of
@@ -441,12 +454,12 @@ func (api *PrivateDebugAPI) StandardTraceBadBlockToFile(ctx context.Context, has
 // traceBlock configures a new tracer according to the provided configuration, and
 // executes all the transactions contained within. The return value will be one item
 // per transaction, dependent on the requestd tracer.
-func (api *PrivateDebugAPI) traceBlock(ctx context.Context, block *types.Block, config *TraceConfig) ([]*txTraceResult, error) {
+func traceBlock(ctx context.Context, eth *Ethereum, block *types.Block, config *TraceConfig) ([]*txTraceResult, error) {
 	// Create the parent state database
-	if err := api.eth.engine.VerifyHeader(api.eth.blockchain, block.Header(), true); err != nil {
+	if err := eth.engine.VerifyHeader(eth.blockchain, block.Header(), true); err != nil {
 		return nil, err
 	}
-	parent := api.eth.blockchain.GetBlock(block.ParentHash(), block.NumberU64()-1)
+	parent := eth.blockchain.GetBlock(block.ParentHash(), block.NumberU64()-1)
 	if parent == nil {
 		return nil, fmt.Errorf("parent %#x not found", block.ParentHash())
 	}
@@ -454,13 +467,13 @@ func (api *PrivateDebugAPI) traceBlock(ctx context.Context, block *types.Block,
 	if config != nil && config.Reexec != nil {
 		reexec = *config.Reexec
 	}
-	statedb, err := api.computeStateDB(parent, reexec)
+	statedb, err := computeStateDB(eth, parent, reexec)
 	if err != nil {
 		return nil, err
 	}
 	// Execute all the transaction contained within the block concurrently
 	var (
-		signer = types.MakeSigner(api.eth.blockchain.Config(), block.Number())
+		signer = types.MakeSigner(eth.blockchain.Config(), block.Number())
 
 		txs     = block.Transactions()
 		results = make([]*txTraceResult, len(txs))
@@ -480,9 +493,9 @@ func (api *PrivateDebugAPI) traceBlock(ctx context.Context, block *types.Block,
 			// Fetch and execute the next transaction trace tasks
 			for task := range jobs {
 				msg, _ := txs[task.index].AsMessage(signer)
-				vmctx := core.NewEVMContext(msg, block.Header(), api.eth.blockchain, nil)
+				vmctx := core.NewEVMContext(msg, block.Header(), eth.blockchain, nil)
 
-				res, err := api.traceTx(ctx, msg, vmctx, task.statedb, config)
+				res, err := traceTx(ctx, eth, msg, vmctx, task.statedb, task.taskExtraContext, config)
 				if err != nil {
 					results[task.index] = &txTraceResult{Error: err.Error()}
 					continue
@@ -494,14 +507,21 @@ func (api *PrivateDebugAPI) traceBlock(ctx context.Context, block *types.Block,
 	// Feed the transactions into the tracers and return
 	var failed error
 	for i, tx := range txs {
+		taskExtraContext := map[string]interface{}{
+			"blockNumber":         block.NumberU64(),
+			"blockHash":           block.Hash().Hex(),
+			"transactionHash":     tx.Hash().Hex(),
+			"transactionPosition": uint64(i),
+		}
+
 		// Send the trace task over for execution
-		jobs <- &txTraceTask{statedb: statedb.Copy(), index: i}
+		jobs <- &txTraceTask{statedb: statedb.Copy(), index: i, taskExtraContext: taskExtraContext}
 
 		// Generate the next state snapshot fast without tracing
 		msg, _ := tx.AsMessage(signer)
-		vmctx := core.NewEVMContext(msg, block.Header(), api.eth.blockchain, nil)
+		vmctx := core.NewEVMContext(msg, block.Header(), eth.blockchain, nil)
 
-		vmenv := vm.NewEVM(vmctx, statedb, api.eth.blockchain.Config(), vm.Config{})
+		vmenv := vm.NewEVM(vmctx, statedb, eth.blockchain.Config(), vm.Config{})
 		if _, err := core.ApplyMessage(vmenv, msg, new(core.GasPool).AddGas(msg.Gas())); err != nil {
 			failed = err
 			break
@@ -520,6 +540,10 @@ func (api *PrivateDebugAPI) traceBlock(ctx context.Context, block *types.Block,
 	return results, nil
 }
 
+func (api *PrivateDebugAPI) traceBlock(ctx context.Context, block *types.Block, config *TraceConfig) ([]*txTraceResult, error) {
+	return traceBlock(ctx, api.eth, block, config)
+}
+
 // standardTraceBlockToFile configures a new tracer which uses standard JSON output,
 // and traces either a full block or an individual transaction. The return value will
 // be one filename per transaction traced.
@@ -542,7 +566,7 @@ func (api *PrivateDebugAPI) standardTraceBlockToFile(ctx context.Context, block
 	if config != nil && config.Reexec != nil {
 		reexec = *config.Reexec
 	}
-	statedb, err := api.computeStateDB(parent, reexec)
+	statedb, err := computeStateDB(api.eth, parent, reexec)
 	if err != nil {
 		return nil, err
 	}
@@ -633,18 +657,18 @@ func containsTx(block *types.Block, hash common.Hash) bool {
 // computeStateDB retrieves the state database associated with a certain block.
 // If no state is locally available for the given block, a number of blocks are
 // attempted to be reexecuted to generate the desired state.
-func (api *PrivateDebugAPI) computeStateDB(block *types.Block, reexec uint64) (*state.StateDB, error) {
+func computeStateDB(eth *Ethereum, block *types.Block, reexec uint64) (*state.StateDB, error) {
 	// If we have the state fully available, use that
-	statedb, err := api.eth.blockchain.StateAt(block.Root())
+	statedb, err := eth.blockchain.StateAt(block.Root())
 	if err == nil {
 		return statedb, nil
 	}
 	// Otherwise try to reexec blocks until we find a state or reach our limit
 	origin := block.NumberU64()
-	database := state.NewDatabaseWithCache(api.eth.ChainDb(), 16, "")
+	database := state.NewDatabaseWithCache(eth.ChainDb(), 16, "")
 
 	for i := uint64(0); i < reexec; i++ {
-		block = api.eth.blockchain.GetBlock(block.ParentHash(), block.NumberU64()-1)
+		block = eth.blockchain.GetBlock(block.ParentHash(), block.NumberU64()-1)
 		if block == nil {
 			break
 		}
@@ -673,15 +697,15 @@ func (api *PrivateDebugAPI) computeStateDB(block *types.Block, reexec uint64) (*
 			logged = time.Now()
 		}
 		// Retrieve the next block to regenerate and process it
-		if block = api.eth.blockchain.GetBlockByNumber(block.NumberU64() + 1); block == nil {
+		if block = eth.blockchain.GetBlockByNumber(block.NumberU64() + 1); block == nil {
 			return nil, fmt.Errorf("block #%d not found", block.NumberU64()+1)
 		}
-		_, _, _, err := api.eth.blockchain.Processor().Process(block, statedb, vm.Config{})
+		_, _, _, err := eth.blockchain.Processor().Process(block, statedb, vm.Config{})
 		if err != nil {
 			return nil, fmt.Errorf("processing block %d failed: %v", block.NumberU64(), err)
 		}
 		// Finalize the state so any modifications are written to the trie
-		root, err := statedb.Commit(api.eth.blockchain.Config().IsEnabled(api.eth.blockchain.Config().GetEIP161dTransition, block.Number()))
+		root, err := statedb.Commit(eth.blockchain.Config().IsEnabled(eth.blockchain.Config().GetEIP161dTransition, block.Number()))
 		if err != nil {
 			return nil, err
 		}
@@ -699,11 +723,15 @@ func (api *PrivateDebugAPI) computeStateDB(block *types.Block, reexec uint64) (*
 	return statedb, nil
 }
 
-// TraceTransaction returns the structured logs created during the execution of EVM
+func (api *PrivateDebugAPI) computeStateDB(block *types.Block, reexec uint64) (*state.StateDB, error) {
+	return computeStateDB(api.eth, block, reexec)
+}
+
+// traceTransaction returns the structured logs created during the execution of EVM
 // and returns them as a JSON object.
-func (api *PrivateDebugAPI) TraceTransaction(ctx context.Context, hash common.Hash, config *TraceConfig) (interface{}, error) {
+func traceTransaction(ctx context.Context, eth *Ethereum, hash common.Hash, config *TraceConfig) (interface{}, error) {
 	// Retrieve the transaction and assemble its EVM context
-	tx, blockHash, _, index := rawdb.ReadTransaction(api.eth.ChainDb(), hash)
+	tx, blockHash, _, index := rawdb.ReadTransaction(eth.ChainDb(), hash)
 	if tx == nil {
 		return nil, fmt.Errorf("transaction %#x not found", hash)
 	}
@@ -712,16 +740,30 @@ func (api *PrivateDebugAPI) TraceTransaction(ctx context.Context, hash common.Ha
 		reexec = *config.Reexec
 	}
 	// Retrieve the block
-	block := api.eth.blockchain.GetBlockByHash(blockHash)
+	block := eth.blockchain.GetBlockByHash(blockHash)
 	if block == nil {
 		return nil, fmt.Errorf("block %#x not found", blockHash)
 	}
-	msg, vmctx, statedb, err := api.computeTxEnv(block, int(index), reexec)
+	msg, vmctx, statedb, err := computeTxEnv(eth, block, int(index), reexec)
 	if err != nil {
 		return nil, err
 	}
+
+	taskExtraContext := map[string]interface{}{
+		"blockNumber":         block.NumberU64(),
+		"blockHash":           blockHash.Hex(),
+		"transactionHash":     tx.Hash().Hex(),
+		"transactionPosition": index,
+	}
+
 	// Trace the transaction and return
-	return api.traceTx(ctx, msg, vmctx, statedb, config)
+	return traceTx(ctx, eth, msg, vmctx, statedb, taskExtraContext, config)
+}
+
+// TraceTransaction returns the structured logs created during the execution of EVM
+// and returns them as a JSON object.
+func (api *PrivateDebugAPI) TraceTransaction(ctx context.Context, hash common.Hash, config *TraceConfig) (interface{}, error) {
+	return traceTransaction(ctx, api.eth, hash, config)
 }
 
 // TraceCall lets you trace a given eth_call. It collects the structured logs created during the execution of EVM
@@ -761,7 +803,7 @@ func (api *PrivateDebugAPI) TraceCall(ctx context.Context, args ethapi.CallArgs,
 // traceTx configures a new tracer according to the provided configuration, and
 // executes the given message in the provided environment. The return value will
 // be tracer dependent.
-func (api *PrivateDebugAPI) traceTx(ctx context.Context, message core.Message, vmctx vm.Context, statedb *state.StateDB, config *TraceConfig) (interface{}, error) {
+func traceTx(ctx context.Context, eth *Ethereum, message core.Message, vmctx vm.Context, statedb *state.StateDB, extraContext map[string]interface{}, config *TraceConfig) (interface{}, error) {
 	// Assemble the structured logger or the JavaScript tracer
 	var (
 		tracer vm.Tracer
@@ -788,6 +830,10 @@ func (api *PrivateDebugAPI) traceTx(ctx context.Context, message core.Message, v
 		}()
 		defer cancel()
 
+		if extraContext != nil {
+			tracer.(*tracers.Tracer).CaptureExtraContext(extraContext)
+		}
+
 	case config == nil:
 		tracer = vm.NewStructLogger(nil)
 
@@ -795,7 +841,7 @@ func (api *PrivateDebugAPI) traceTx(ctx context.Context, message core.Message, v
 		tracer = vm.NewStructLogger(config.LogConfig)
 	}
 	// Run the transaction with tracing enabled.
-	vmenv := vm.NewEVM(vmctx, statedb, api.eth.blockchain.Config(), vm.Config{Debug: true, Tracer: tracer})
+	vmenv := vm.NewEVM(vmctx, statedb, eth.blockchain.Config(), vm.Config{Debug: true, Tracer: tracer})
 
 	result, err := core.ApplyMessage(vmenv, message, new(core.GasPool).AddGas(message.Gas()))
 	if err != nil {
@@ -824,14 +870,21 @@ func (api *PrivateDebugAPI) traceTx(ctx context.Context, message core.Message, v
 	}
 }
 
+// traceTx configures a new tracer according to the provided configuration, and
+// executes the given message in the provided environment. The return value will
+// be tracer dependent.
+func (api *PrivateDebugAPI) traceTx(ctx context.Context, message core.Message, vmctx vm.Context, statedb *state.StateDB, config *TraceConfig) (interface{}, error) {
+	return traceTx(ctx, api.eth, message, vmctx, statedb, nil, config)
+}
+
 // computeTxEnv returns the execution environment of a certain transaction.
-func (api *PrivateDebugAPI) computeTxEnv(block *types.Block, txIndex int, reexec uint64) (core.Message, vm.Context, *state.StateDB, error) {
+func computeTxEnv(eth *Ethereum, block *types.Block, txIndex int, reexec uint64) (core.Message, vm.Context, *state.StateDB, error) {
 	// Create the parent state database
-	parent := api.eth.blockchain.GetBlock(block.ParentHash(), block.NumberU64()-1)
+	parent := eth.blockchain.GetBlock(block.ParentHash(), block.NumberU64()-1)
 	if parent == nil {
 		return nil, vm.Context{}, nil, fmt.Errorf("parent %#x not found", block.ParentHash())
 	}
-	statedb, err := api.computeStateDB(parent, reexec)
+	statedb, err := computeStateDB(eth, parent, reexec)
 	if err != nil {
 		return nil, vm.Context{}, nil, err
 	}
@@ -841,17 +894,17 @@ func (api *PrivateDebugAPI) computeTxEnv(block *types.Block, txIndex int, reexec
 	}
 
 	// Recompute transactions up to the target index.
-	signer := types.MakeSigner(api.eth.blockchain.Config(), block.Number())
+	signer := types.MakeSigner(eth.blockchain.Config(), block.Number())
 
 	for idx, tx := range block.Transactions() {
 		// Assemble the transaction call message and return if the requested offset
 		msg, _ := tx.AsMessage(signer)
-		context := core.NewEVMContext(msg, block.Header(), api.eth.blockchain, nil)
+		context := core.NewEVMContext(msg, block.Header(), eth.blockchain, nil)
 		if idx == txIndex {
 			return msg, context, statedb, nil
 		}
 		// Not yet the searched for transaction, execute on top of the current state
-		vmenv := vm.NewEVM(context, statedb, api.eth.blockchain.Config(), vm.Config{})
+		vmenv := vm.NewEVM(context, statedb, eth.blockchain.Config(), vm.Config{})
 		if _, err := core.ApplyMessage(vmenv, msg, new(core.GasPool).AddGas(tx.Gas())); err != nil {
 			return nil, vm.Context{}, nil, fmt.Errorf("transaction %#x failed: %v", tx.Hash(), err)
 		}
@@ -861,3 +914,7 @@ func (api *PrivateDebugAPI) computeTxEnv(block *types.Block, txIndex int, reexec
 	}
 	return nil, vm.Context{}, nil, fmt.Errorf("transaction index %d out of range for block %#x", txIndex, block.Hash())
 }
+
+func (api *PrivateDebugAPI) computeTxEnv(block *types.Block, txIndex int, reexec uint64) (core.Message, vm.Context, *state.StateDB, error) {
+	return computeTxEnv(api.eth, block, txIndex, reexec)
+}
diff --git a/eth/api_tracer_parity.go b/eth/api_tracer_parity.go
new file mode 100644
index 0000000000..c49d30f6a8
--- /dev/null
+++ b/eth/api_tracer_parity.go
@@ -0,0 +1,177 @@
+// 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 eth
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/common/hexutil"
+	"github.com/ethereum/go-ethereum/consensus/ethash"
+	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/internal/ethapi"
+	"github.com/ethereum/go-ethereum/rpc"
+)
+
+// ParityTrace A trace in the desired format (Parity/OpenEtherum) See: https://Parity.github.io/wiki/JSONRPC-trace-module
+type ParityTrace struct {
+	Action              TraceRewardAction `json:"action"`
+	BlockHash           common.Hash       `json:"blockHash"`
+	BlockNumber         uint64            `json:"blockNumber"`
+	Error               string            `json:"error,omitempty"`
+	Result              interface{}       `json:"result"`
+	Subtraces           int               `json:"subtraces"`
+	TraceAddress        []int             `json:"traceAddress"`
+	TransactionHash     *common.Hash      `json:"transactionHash"`
+	TransactionPosition *uint64           `json:"transactionPosition"`
+	Type                string            `json:"type"`
+}
+
+// TraceRewardAction An Parity formatted trace reward action
+type TraceRewardAction struct {
+	Value      *hexutil.Big    `json:"value,omitempty"`
+	Author     *common.Address `json:"author,omitempty"`
+	RewardType string          `json:"rewardType,omitempty"`
+}
+
+// setConfigTracerToParity forces the Tracer to the Parity one
+func setConfigTracerToParity(config *TraceConfig) *TraceConfig {
+	if config == nil {
+		config = &TraceConfig{}
+	}
+
+	tracer := "callTracerParity"
+	config.Tracer = &tracer
+	return config
+}
+
+func traceBlockReward(ctx context.Context, eth *Ethereum, block *types.Block, config *TraceConfig) (*ParityTrace, error) {
+	chainConfig := eth.blockchain.Config()
+	minerReward, _ := ethash.GetRewards(chainConfig, block.Header(), block.Uncles())
+
+	coinbase := block.Coinbase()
+
+	tr := &ParityTrace{
+		Type: "reward",
+		Action: TraceRewardAction{
+			Value:      (*hexutil.Big)(minerReward),
+			Author:     &coinbase,
+			RewardType: "block",
+		},
+		TraceAddress: []int{},
+		BlockHash:    block.Hash(),
+		BlockNumber:  block.NumberU64(),
+	}
+
+	return tr, nil
+}
+
+func traceBlockUncleRewards(ctx context.Context, eth *Ethereum, block *types.Block, config *TraceConfig) ([]*ParityTrace, error) {
+	chainConfig := eth.blockchain.Config()
+	_, uncleRewards := ethash.GetRewards(chainConfig, block.Header(), block.Uncles())
+
+	results := make([]*ParityTrace, len(uncleRewards))
+	for i, uncle := range block.Uncles() {
+		if i < len(uncleRewards) {
+			coinbase := uncle.Coinbase
+
+			results[i] = &ParityTrace{
+				Type: "reward",
+				Action: TraceRewardAction{
+					Value:      (*hexutil.Big)(uncleRewards[i]),
+					Author:     &coinbase,
+					RewardType: "uncle",
+				},
+				TraceAddress: []int{},
+				BlockNumber:  block.NumberU64(),
+				BlockHash:    block.Hash(),
+			}
+		}
+	}
+
+	return results, nil
+}
+
+// Block returns the structured logs created during the execution of
+// EVM and returns them as a JSON object.
+// The correct name will be TraceBlockByNumber, though we want to be compatible with Parity trace module.
+func (api *PrivateTraceAPI) Block(ctx context.Context, number rpc.BlockNumber, config *TraceConfig) ([]interface{}, error) {
+	// Fetch the block that we want to trace
+	var block *types.Block
+
+	switch number {
+	case rpc.PendingBlockNumber:
+		block = api.eth.miner.PendingBlock()
+	case rpc.LatestBlockNumber:
+		block = api.eth.blockchain.CurrentBlock()
+	default:
+		block = api.eth.blockchain.GetBlockByNumber(uint64(number))
+	}
+	// Trace the block if it was found
+	if block == nil {
+		return nil, fmt.Errorf("block #%d not found", number)
+	}
+
+	config = setConfigTracerToParity(config)
+
+	traceResults, err := traceBlockByNumber(ctx, api.eth, number, config)
+	if err != nil {
+		return nil, err
+	}
+
+	traceReward, err := traceBlockReward(ctx, api.eth, block, config)
+	if err != nil {
+		return nil, err
+	}
+
+	traceUncleRewards, err := traceBlockUncleRewards(ctx, api.eth, block, config)
+	if err != nil {
+		return nil, err
+	}
+
+	results := []interface{}{}
+
+	for _, result := range traceResults {
+		var tmp []interface{}
+		if err := json.Unmarshal(result.Result.(json.RawMessage), &tmp); err != nil {
+			return nil, err
+		}
+		results = append(results, tmp...)
+	}
+
+	results = append(results, traceReward)
+
+	for _, uncleReward := range traceUncleRewards {
+		results = append(results, uncleReward)
+	}
+
+	return results, nil
+}
+
+// Transaction returns the structured logs created during the execution of EVM
+// and returns them as a JSON object.
+func (api *PrivateTraceAPI) Transaction(ctx context.Context, hash common.Hash, config *TraceConfig) (interface{}, error) {
+	config = setConfigTracerToParity(config)
+	return traceTransaction(ctx, api.eth, hash, config)
+}
+
+func (api *PrivateTraceAPI) Filter(ctx context.Context, args ethapi.CallArgs, config *TraceConfig) ([]*txTraceResult, error) {
+	// config = setConfigTracerToParity(config)
+	return nil, nil
+}
diff --git a/eth/api_tracer_parity_test.go b/eth/api_tracer_parity_test.go
new file mode 100644
index 0000000000..b5543f1e50
--- /dev/null
+++ b/eth/api_tracer_parity_test.go
@@ -0,0 +1,41 @@
+package eth
+
+import (
+	"testing"
+)
+
+// BenchmarkTraceResultsAppend1 compares performance against BenchmarkTraceResultsAppend2,
+// comparing the performance of different ways of appending items to slices.
+// This is used in PrivateTraceAPI#Block appending results to the traceResults value.
+func BenchmarkTraceResultsAppend1(b *testing.B) {
+	traceResults := []interface{}{}
+	for i := 0; i < 10000; i++ {
+		traceResults = append(traceResults, i)
+	}
+
+	b.ResetTimer()
+
+	for i := 0; i < b.N; i++ {
+		// results := make([]interface{}, len(traceResults))
+		results := []interface{}{}
+		for _, it := range traceResults { // nolint:gosimple
+			results = append(results, it)
+		}
+	}
+}
+
+// BenchmarkTraceResultsAppend2 (see comment for BenchmarkTraceResultsAppend1).
+func BenchmarkTraceResultsAppend2(b *testing.B) {
+	traceResults := []interface{}{}
+	for i := 0; i < 10000; i++ {
+		traceResults = append(traceResults, i)
+	}
+
+	b.ResetTimer()
+
+	for i := 0; i < b.N; i++ {
+		// results := make([]interface{}, len(traceResults))
+		results := []interface{}{}
+		results = append(results, traceResults...) // nolint:ineffassign
+	}
+}
diff --git a/eth/backend.go b/eth/backend.go
index 250091baf5..f253c3aad6 100644
--- a/eth/backend.go
+++ b/eth/backend.go
@@ -341,6 +341,10 @@ func (s *Ethereum) APIs() []rpc.API {
 			Namespace: "debug",
 			Version:   "1.0",
 			Service:   NewPrivateDebugAPI(s),
+		}, {
+			Namespace: "trace",
+			Version:   "1.0",
+			Service:   NewPrivateTraceAPI(s),
 		}, {
 			Namespace: "net",
 			Version:   "1.0",
diff --git a/eth/tracers/internal/tracers/assets.go b/eth/tracers/internal/tracers/assets.go
index 432398ebb5..44d9b8b3c7 100644
--- a/eth/tracers/internal/tracers/assets.go
+++ b/eth/tracers/internal/tracers/assets.go
@@ -1,21 +1,20 @@
-// Code generated by go-bindata. DO NOT EDIT.
+// Package tracers Code generated by go-bindata. (@generated) DO NOT EDIT.
 // sources:
-// 4byte_tracer.js (2.933kB)
-// bigram_tracer.js (1.712kB)
-// call_tracer.js (8.956kB)
-// evmdis_tracer.js (4.195kB)
-// noop_tracer.js (1.271kB)
-// opcount_tracer.js (1.372kB)
-// prestate_tracer.js (4.234kB)
-// trigram_tracer.js (1.788kB)
-// unigram_tracer.js (1.51kB)
-
+// 4byte_tracer.js
+// bigram_tracer.js
+// call_tracer.js
+// call_tracer_parity.js
+// evmdis_tracer.js
+// noop_tracer.js
+// opcount_tracer.js
+// prestate_tracer.js
+// trigram_tracer.js
+// unigram_tracer.js
 package tracers
 
 import (
 	"bytes"
 	"compress/gzip"
-	"crypto/sha256"
 	"fmt"
 	"io"
 	"io/ioutil"
@@ -46,9 +45,8 @@ func bindataRead(data []byte, name string) ([]byte, error) {
 }
 
 type asset struct {
-	bytes  []byte
-	info   os.FileInfo
-	digest [sha256.Size]byte
+	bytes []byte
+	info  os.FileInfo
 }
 
 type bindataFileInfo struct {
@@ -58,21 +56,32 @@ type bindataFileInfo struct {
 	modTime time.Time
 }
 
+// Name return file name
 func (fi bindataFileInfo) Name() string {
 	return fi.name
 }
+
+// Size return file size
 func (fi bindataFileInfo) Size() int64 {
 	return fi.size
 }
+
+// Mode return file mode
 func (fi bindataFileInfo) Mode() os.FileMode {
 	return fi.mode
 }
+
+// ModTime return file modify time
 func (fi bindataFileInfo) ModTime() time.Time {
 	return fi.modTime
 }
+
+// IsDir return file whether a directory
 func (fi bindataFileInfo) IsDir() bool {
-	return false
+	return fi.mode&os.ModeDir != 0
 }
+
+// Sys return file is sys mode
 func (fi bindataFileInfo) Sys() interface{} {
 	return nil
 }
@@ -93,7 +102,7 @@ func _4byte_tracerJs() (*asset, error) {
 	}
 
 	info := bindataFileInfo{name: "4byte_tracer.js", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)}
-	a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xb4, 0xc5, 0x48, 0x2d, 0xd9, 0x43, 0x95, 0x93, 0x3b, 0x93, 0x2c, 0x47, 0x8c, 0x84, 0x32, 0x3c, 0x8b, 0x2e, 0xf3, 0x72, 0xc4, 0x57, 0xe6, 0x3a, 0xb3, 0xdf, 0x1d, 0xbf, 0x45, 0x3, 0xfc, 0xa}}
+	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
 
@@ -113,11 +122,11 @@ func bigram_tracerJs() (*asset, error) {
 	}
 
 	info := bindataFileInfo{name: "bigram_tracer.js", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)}
-	a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x77, 0x6c, 0xd, 0x24, 0xf2, 0x49, 0xbd, 0x58, 0x8b, 0xb5, 0xd1, 0xc9, 0xcd, 0xcf, 0x5b, 0x3e, 0x5c, 0xfb, 0x14, 0x50, 0xe7, 0xe3, 0xb9, 0xd1, 0x54, 0x69, 0xe6, 0x5e, 0x45, 0xa6, 0x2c, 0x6c}}
+	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
 
-var _call_tracerJs = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xd4\x5a\xdf\x6f\x1b\x37\xf2\x7f\x96\xfe\x8a\x89\x1f\x6a\x09\x51\x24\x39\xe9\xb7\x5f\xc0\xae\x7a\x50\x1d\x25\x35\xe0\xc6\x81\xad\x34\x08\x82\x3c\x50\xbb\xb3\x12\x6b\x8a\xdc\x92\x5c\xc9\xba\xd6\xff\xfb\x61\x86\xdc\xd5\xae\x24\x3b\xbe\x5e\x71\xe8\xbd\x69\x97\x33\xc3\xe1\xcc\x67\x7e\x71\x35\x18\xc0\xb9\xc9\x37\x56\xce\x17\x1e\x5e\x0e\x4f\xfe\x1f\xa6\x0b\x84\xb9\x79\x81\x7e\x81\x16\x8b\x25\x8c\x0b\xbf\x30\xd6\xb5\x07\x03\x98\x2e\xa4\x83\x4c\x2a\x04\xe9\x20\x17\xd6\x83\xc9\xc0\xef\xd0\x2b\x39\xb3\xc2\x6e\xfa\xed\xc1\x20\xf0\x1c\x5c\x26\x09\x99\x45\x04\x67\x32\xbf\x16\x16\x4f\x61\x63\x0a\x48\x84\x06\x8b\xa9\x74\xde\xca\x59\xe1\x11\xa4\x07\xa1\xd3\x81\xb1\xb0\x34\xa9\xcc\x36\x24\x52\x7a\x28\x74\x8a\x96\xb7\xf6\x68\x97\xae\xd4\xe3\xed\xbb\x0f\x70\x89\xce\xa1\x85\xb7\xa8\xd1\x0a\x05\xef\x8b\x99\x92\x09\x5c\xca\x04\xb5\x43\x10\x0e\x72\x7a\xe3\x16\x98\xc2\x8c\xc5\x11\xe3\x1b\x52\xe5\x26\xaa\x02\x6f\x4c\xa1\x53\xe1\xa5\xd1\x3d\x40\x49\x9a\xc3\x0a\xad\x93\x46\xc3\xab\x72\xab\x28\xb0\x07\xc6\x92\x90\x8e\xf0\x74\x00\x0b\x26\x27\xbe\x2e\x08\xbd\x01\x25\xfc\x96\xf5\x09\x06\xd9\x9e\x3b\x05\xa9\x79\x9b\x85\xc9\x11\xfc\x42\x78\x3a\xf5\x5a\x2a\x05\x33\x84\xc2\x61\x56\xa8\x1e\x49\x9b\x15\x1e\x3e\x5e\x4c\x7f\xba\xfa\x30\x85\xf1\xbb\x4f\xf0\x71\x7c\x7d\x3d\x7e\x37\xfd\x74\x06\x6b\xe9\x17\xa6\xf0\x80\x2b\x0c\xa2\xe4\x32\x57\x12\x53\x58\x0b\x6b\x85\xf6\x1b\x30\x19\x49\xf8\x79\x72\x7d\xfe\xd3\xf8\xdd\x74\xfc\xe3\xc5\xe5\xc5\xf4\x13\x18\x0b\x6f\x2e\xa6\xef\x26\x37\x37\xf0\xe6\xea\x1a\xc6\xf0\x7e\x7c\x3d\xbd\x38\xff\x70\x39\xbe\x86\xf7\x1f\xae\xdf\x5f\xdd\x4c\xfa\x70\x83\xa4\x15\x12\xff\xd7\x6d\x9e\xb1\xf7\x2c\x42\x8a\x5e\x48\xe5\x4a\x4b\x7c\x32\x05\xb8\x85\x29\x54\x0a\x0b\xb1\x42\xb0\x98\xa0\x5c\x61\x0a\x02\x12\x93\x6f\x9e\xec\x54\x92\x25\x94\xd1\x73\x3e\xf3\x83\x80\x84\x8b\x0c\xb4\xf1\x3d\x70\x88\xf0\xfd\xc2\xfb\xfc\x74\x30\x58\xaf\xd7\xfd\xb9\x2e\xfa\xc6\xce\x07\x2a\x88\x73\x83\x1f\xfa\x6d\x92\x99\x08\xa5\xa6\x56\x24\x68\xc9\x39\x02\xb2\x82\xcc\xaf\xcc\x5a\x83\xb7\x42\x3b\x91\x90\xab\xe9\x77\xc2\x60\x14\x1e\xf0\x8e\x9e\xbc\x23\xd0\x82\xc5\xdc\x58\xfa\xad\x54\x89\x33\xa9\x3d\x5a\x2d\x14\xcb\x76\xb0\x14\x29\xc2\x6c\x03\xa2\x2e\xb0\x57\x3f\x0c\xc1\x28\xb8\x1b\xa4\xce\x8c\x5d\x32\x2c\xfb\xed\xdf\xdb\xad\xa8\xa1\xf3\x22\xb9\x25\x05\x49\x7e\x52\x58\x8b\xda\x93\x29\x0b\xeb\xe4\x0a\x99\x04\x02\x4d\xb4\xe7\xe4\x97\x9f\x01\xef\x30\x29\x82\xa4\x56\x25\xe4\x14\x3e\xff\x7e\xff\xa5\xd7\x66\xd1\x29\xba\x04\x75\x8a\x29\x9f\xef\xd6\xc1\x7a\xc1\x16\x85\x35\x1e\xaf\x10\x7e\x2d\x9c\xaf\xd1\x64\xd6\x2c\x41\x68\x30\x05\x21\xbe\x6e\x1d\xa9\xbd\x61\x81\x82\x7e\x6b\xb4\xac\x51\xbf\xdd\xaa\x98\x4f\x21\x13\xca\x61\xdc\xd7\x79\xcc\xe9\x34\x52\xaf\xcc\x2d\x49\x36\x96\x20\x6c\x37\x60\xf2\xc4\xa4\x31\x18\xe8\x1c\xd5\x31\xd0\xf5\xdb\x2d\xe2\x3b\x85\xac\xd0\xbc\x6d\x47\x99\x79\x0f\xd2\x59\x17\x7e\x6f\xb7\x48\xec\xb9\xc8\x7d\x61\x91\xed\x89\xd6\x1a\xeb\x40\x2e\x97\x98\x4a\xe1\x51\x6d\xda\xad\xd6\x4a\xd8\xb0\x00\x23\x50\x66\xde\x9f\xa3\x9f\xd0\x63\xa7\x7b\xd6\x6e\xb5\x64\x06\x9d\xb0\xfa\x6c\x34\xe2\xec\x93\x49\x8d\x69\x10\xdf\xf2\x0b\xe9\xfa\x99\x28\x94\xaf\xf6\x25\xa6\x96\x45\x5f\x58\x4d\x3f\xef\x83\x16\x1f\x11\x8c\x56\x1b\x48\x28\xcb\x88\x19\x85\xa7\xdb\x38\x8f\xcb\x78\x38\xd7\x83\x4c\x38\x32\xa1\xcc\x60\x8d\x90\x5b\x7c\x91\x2c\x90\x7c\xa7\x13\x8c\x5a\xba\x8d\x63\xa7\x8e\x80\x76\xeb\x9b\xbc\xef\xcd\xbb\x62\x39\x43\xdb\xe9\xc2\x37\x30\xbc\xcb\x86\x5d\x18\x8d\xf8\x47\xa9\x7b\xe4\x89\xfa\x92\x14\x93\xc7\x83\x32\xff\x8d\xb7\x52\xcf\xc3\x59\xa3\xae\x17\x19\x08\xd0\xb8\x86\xc4\x68\x06\x35\x79\x65\x86\x52\xcf\x21\xb1\x28\x3c\xa6\x3d\x10\x69\x0a\xde\x04\xe4\x55\x38\x6b\x6e\x09\xdf\x7c\x03\x1d\xda\x6c\x04\xc7\xe7\xd7\x93\xf1\x74\x72\x0c\x7f\xfc\x01\xe1\xcd\x51\x78\xf3\xf2\xa8\x5b\xd3\x4c\xea\xab\x2c\x8b\xca\xb1\xc0\x7e\x8e\x78\xdb\x39\xe9\xf6\x57\x42\x15\x78\x95\x05\x35\x23\xed\x44\xa7\x30\x8a\x3c\xcf\x77\x79\x5e\x36\x78\x88\x69\x30\x80\xb1\x73\xb8\x9c\x29\xdc\x0f\xc8\x18\xb1\x1c\xbc\xce\x53\xc6\x22\xf4\x25\x66\x99\x2b\x24\x54\x95\xbb\x46\xf3\xb3\xc6\x2d\xbf\xc9\xf1\x14\x00\xc0\xe4\x3d\x7e\x41\xb1\xc0\x2f\xbc\xf9\x09\xef\xd8\x47\xa5\x09\x09\x55\xe3\x34\xb5\xe8\x5c\xa7\xdb\x0d\xe4\x52\xe7\x85\x3f\x6d\x90\x2f\x71\x69\xec\xa6\xef\x28\x21\x75\xf8\x68\xbd\x70\xd2\x92\x67\x2e\xdc\x85\x26\x9e\x88\xd4\xb7\xc2\x75\xb6\x4b\xe7\xc6\xf9\xd3\x72\x89\x1e\xca\x35\xb6\x05\xb1\x1d\x0f\xef\x8e\xf7\xad\x35\xec\x6e\x91\x70\xf2\x5d\x97\x58\xee\xcf\x2a\x7c\x57\x69\xa2\x9f\x17\x6e\xd1\x61\x38\x6d\x57\xb7\xa9\x60\x04\xde\x16\x78\x10\xfe\x0c\xa9\x7d\x38\x39\x54\x19\xe5\x12\x6f\x8b\x84\x61\x35\x17\x9c\x69\x38\xd2\x05\x65\x5e\x57\xcc\xd8\xe6\xde\x98\x7d\x74\x45\x70\xdd\x4c\x2e\xdf\xbc\x9e\xdc\x4c\xaf\x3f\x9c\x4f\x8f\x6b\x70\x52\x98\x79\x52\xaa\x79\x06\x85\x7a\xee\x17\xac\x3f\x89\x6b\xae\x7e\x26\x9e\x17\x27\x5f\xc2\x1b\x18\x1d\x08\xf9\xd6\xe3\x1c\xf0\xf9\x0b\xcb\xbe\xdf\x37\x5f\x93\x34\x18\xf3\xaf\x41\x92\x37\x4c\x5c\x92\x7b\x53\x12\x3c\xee\xe7\xbf\x18\x54\xe9\x8c\x28\x7e\x14\x4a\xe8\x04\x1f\xd1\x79\x1f\x6b\xf5\xa4\x79\x20\x0f\x2d\xd1\x2f\x4c\xca\x85\x21\x11\xa1\xb6\x94\x08\x4a\x8d\xc6\x7f\x3f\x1b\x8d\x2f\x2f\x6b\xb9\x88\x9f\xcf\xaf\x5e\xd7\xf3\xd3\xf1\xeb\xc9\xe5\xe4\xed\x78\x3a\xd9\xa5\xbd\x99\x8e\xa7\x17\xe7\xfc\xb6\x4c\x5d\x83\x01\xdc\xdc\xca\x9c\x2b\x0c\xe7\x6d\xb3\xcc\xb9\x55\xae\xf4\x75\x3d\xf0\x0b\x43\x4d\xa8\x8d\x05\x34\x13\x3a\x29\x0b\x9b\x2b\x01\xeb\x0d\xc1\xf5\x21\xe7\x9d\xec\x38\xaf\x82\xb0\x74\xef\x2d\xc6\x4d\xd3\x8e\x37\xa5\x5e\x5b\x83\x06\x34\x72\xf2\xe7\x04\xdb\x79\xfa\x21\xe1\x1f\x30\x84\x53\x38\x89\x59\xf4\x91\x34\xfd\x12\x9e\x93\xf8\x3f\x91\xac\x5f\x1d\xe0\xfc\x7b\xa6\xec\xbd\x40\xfb\xef\xa7\x72\x53\xf8\xab\x2c\x3b\x85\x5d\x23\x7e\xbb\x67\xc4\x8a\xfe\x12\xf5\x3e\xfd\xff\xed\xd1\x6f\xd3\x3e\xa1\xca\xe4\xf0\x6c\x0f\x22\x21\xe9\x3e\xdb\x89\x83\x68\x5c\x6e\xef\x58\x1a\x8c\x1e\x28\x34\x2f\x9b\x18\x7e\x28\x53\xfe\x47\x85\xe6\x60\x9b\x4a\xcd\x68\xb3\x11\xed\x81\x45\x6f\x25\xae\x68\xd4\x3c\x76\x2c\x92\x1a\x76\xb3\xa6\xf4\xd5\x87\x8f\x18\x24\x6a\x44\x4e\x2e\xb1\xc1\xa7\xfe\x8c\x7b\x5e\x6a\xd2\xe3\xa8\xc6\x10\x13\xdc\x87\x5b\x84\xa5\xd8\xd0\xa8\x96\x15\xfa\x76\x03\x73\xe1\x20\xdd\x68\xb1\x94\x89\x0b\xf2\xb8\xb9\xb7\x38\x17\x96\xc5\x5a\xfc\xad\x40\x47\x73\x1f\x01\x59\x24\xbe\x10\x4a\x6d\x60\x2e\x69\x78\x23\xee\xce\xcb\x57\xc3\x21\x38\x2f\x73\xd4\x69\x0f\xbe\x7b\x35\xf8\xee\x5b\xb0\x85\xc2\x6e\xbf\x5d\x2b\x61\xd5\x51\xa3\x37\x68\x21\xa2\xe7\x35\xe6\x7e\xd1\xe9\xc2\x0f\x0f\xd4\xc2\x07\x0a\xdb\x41\x5a\x78\x01\x27\x5f\xfa\xa4\xd7\xa8\x81\xdb\xe0\x49\x40\xe5\x30\x4a\xa3\x81\xf7\xea\xf5\x55\xe7\x56\x58\xa1\xc4\x0c\xbb\xa7\x3c\x00\xb3\xad\xd6\x22\x4e\x40\xe4\x14\xc8\x95\x90\x1a\x44\x92\x98\x42\x7b\x32\x7c\x39\xcc\xa8\x0d\xe5\xf7\x63\x5f\xca\xe3\x59\x51\x24\x09\x3a\x57\xa6\x7b\xf6\x1a\xa9\x23\x96\xc4\x0d\x52\x3b\x99\x62\xcd\x2b\x94\x1d\x0c\xa7\xe6\x48\x41\xa3\x74\x29\x70\x69\x1c\x6d\x32\x43\x58\x5b\x1a\xbc\x9c\xd4\x09\xdf\x3c\xa4\x48\xd6\x76\x60\x34\x08\x50\x86\xaf\x3b\x38\xc6\x41\xd8\xb9\xeb\x87\x7c\x4f\xdb\x52\xce\xd1\x66\xdd\x6f\x02\xb9\x0e\x55\x1e\x71\x76\x5a\x21\x0d\x78\x27\x9d\xe7\x8e\x9a\xb4\x94\x0e\x02\x92\xa5\x9e\xf7\x20\x37\x39\xe7\xe9\xaf\x95\xb3\x98\xac\xaf\x27\xbf\x4c\xae\xab\xc6\xe7\xe9\x4e\x2c\x67\x9e\xa3\x6a\x24\x04\x4b\xf3\x96\xc7\xf4\xe8\xc0\x10\x73\x00\x50\xa3\x07\x00\x45\xf2\xb7\xb5\xf1\x7d\xed\x38\x4a\x38\xbf\x75\xcc\x1c\xc3\x3c\x57\x57\xc0\x15\xca\xbb\x9d\xdc\xbd\x9b\x1c\x4c\x5e\x56\x08\x52\x8a\xd3\x0e\x25\xf6\xdd\x49\xa3\xb1\xb0\x1d\x38\xb6\xf8\xbc\xa8\xd9\x78\xcd\xed\x66\x20\xaa\xa5\x06\x5e\x2f\xfb\x56\x11\xaa\x01\xeb\x6e\x0a\x4f\x70\xa0\xfa\xbd\x4d\x7e\x73\xe1\x3e\x38\xf6\x7a\x4c\x7f\x33\x39\xbf\xd0\xbe\x53\x2e\x5e\x68\x78\x01\xe5\x03\x25\x75\x78\xd1\x88\xa2\x03\xd9\xb1\x95\xa2\x42\x8f\xb0\x15\x71\x06\x3b\xaf\x48\x50\x30\x07\x1b\xcd\xa2\xdf\x2f\xce\xc3\x28\x8d\x0c\xf6\xcc\xa2\xef\xe3\x6f\x85\x50\xae\x33\xac\x9a\x85\x70\x02\x6f\xb8\xbc\x8d\xf6\x3a\x49\xe2\x69\xf6\x8e\x67\x35\xb6\x68\x8d\x92\x2d\x74\x82\xe7\x26\xc5\x47\x25\x44\x11\x31\x6d\x54\xbe\x8c\xc0\x3c\xd4\x7b\xb7\xea\x04\x70\x54\x35\x04\x99\x90\xaa\xb0\x78\x74\x06\x07\xd2\x8e\x2b\x6c\x26\x12\xf6\xa5\x43\xe0\x69\xdd\x81\x33\x4b\x5c\x98\x75\x50\xe0\x50\xf2\xda\x07\x47\x85\x83\x9d\xf2\xc1\xd7\x4e\xc2\x41\xe1\xc4\x1c\x6b\xe0\xa8\x0c\x5e\x3a\xea\xe0\x15\xc2\x9f\x86\xce\xf3\xea\xf1\x09\x28\xba\xff\x6b\xe0\xb1\xe3\xe7\xbd\x3e\xa7\x24\xe2\x6e\xa7\xf6\x50\x2a\x1b\x9a\x91\xbf\x97\xe3\x9f\x1c\x61\xbb\xb4\xe1\x68\x4d\xe2\x70\xc0\x6d\x5f\xf3\x75\xf7\x57\xab\x0f\x79\xfe\xa1\x96\x89\x30\xaa\x7f\xc5\xc4\x6f\x71\xca\x5d\x0e\x3d\xe5\x16\x57\xd2\x14\x54\xc0\xf0\x7f\x69\x1c\xae\x5a\xbe\xfb\x76\xeb\x3e\xde\x0b\xb2\xdf\xea\x17\x83\xeb\x45\xbc\xd7\x0e\xdd\x52\xad\x7c\x18\xae\xad\xf1\xba\x30\x0b\x37\xce\x2d\xe6\x7f\xe4\x82\x30\x06\xba\x37\x39\xb5\x03\xb1\x3a\x29\x8b\x22\xdd\x54\x05\xb1\x17\x1a\x11\x58\x08\x9d\xc6\x61\x44\xa4\xa9\x24\x79\x0c\x42\xd2\x50\xcc\x85\xd4\xed\x83\x66\xfc\x6a\x15\x3e\x84\x8c\xbd\xde\xb6\x5e\x48\xe3\x10\x49\x13\x1f\x6b\xdc\x7e\x42\xc1\xdc\x09\xa2\xdd\xbb\xce\x78\x5d\x6a\xb4\x2b\x96\xdc\x09\x83\x58\x09\xa9\x04\x4d\x5f\xdc\x61\xe9\x14\x12\x85\x42\x87\x2f\x1c\x98\x79\xb3\x42\xeb\xda\x4f\x00\xf9\x9f\xc1\xf8\x4e\x56\x2c\x1f\xa3\x39\x9e\x1e\xb3\x4f\x8d\xd8\x70\xfc\x37\x4a\x78\x1f\xe1\x55\x33\x6f\x88\x2c\xe9\xf9\xe3\x17\x6a\xdf\x7e\x5a\x48\x71\xcf\x44\x34\x3f\xc0\xb0\xd6\x97\xff\x5d\x82\x6c\x1f\x62\x97\x55\x7f\x16\x0f\xef\x8d\xe9\x81\x42\xc1\x53\x52\xf9\x69\xaa\xec\x47\x1f\x1b\xda\xca\xe8\x0d\x1d\xdd\x5e\xf8\xf2\x9d\xde\x02\xcb\x1b\x90\xd0\xda\xcf\x10\x35\x48\x8f\x56\xd0\x3c\x44\xe8\x8a\x5f\x53\x48\x4b\xc7\xe2\xd8\x2f\x92\x82\x2e\x0a\x8e\x9f\x36\xa8\x30\x4b\x3d\xef\xb7\x5b\xe1\x7d\x2d\xde\x13\x7f\xb7\x8d\xf7\x50\x01\x99\x33\xde\x09\x54\x57\x02\x89\xbf\xe3\x6e\x91\xc7\xe6\x9d\x7b\x01\x5a\xa3\x57\x61\xa6\xde\xb9\x05\x60\xc6\x78\x13\xb0\x7b\x27\x46\x6b\xfc\xae\x01\x70\x26\x9d\x0b\x17\xc4\xec\x84\x84\xbf\xdb\x8f\x88\x92\x81\x82\xe1\xf4\x30\x03\x2d\x1d\x60\xda\xb9\x99\x20\x62\x7e\x15\x56\x43\x3d\x3f\xad\xaf\x86\x57\xf1\xa0\x72\x59\xb3\x8d\x5c\xb2\x6d\xee\xcf\x0e\x27\xb9\x61\x89\xc7\xc3\xc9\x8c\x6c\x5e\x01\xf6\x01\xd6\xfa\xac\xb1\x4f\xf2\x58\xaa\x64\xe9\x65\x66\x7b\x80\x95\xa5\xd7\x5a\x0e\x7f\xf7\x74\x91\x15\x71\x5d\xc5\x06\x4d\x43\x08\xdf\x36\xee\x2d\x1f\x9a\xb4\x68\x50\x89\x84\x65\x73\x35\x1a\x1d\x0d\xef\xaa\x0f\x23\x31\x57\x35\x68\x4a\x25\x42\x64\x84\xf3\x72\x54\xc8\x7f\x62\xdc\xb6\x1e\x83\xe5\x12\x58\x0c\x1f\x70\xb8\x9b\xa5\x10\x34\x33\x6e\x20\x0a\x47\xa3\xe8\x36\xb6\x52\x74\xd2\x62\x0a\x99\x44\x95\x82\x49\xd1\xf2\xa0\xfb\xab\x33\x3a\x7c\xaa\x43\x2b\x49\x62\xf8\x24\x19\xfe\x1d\xc0\x1f\x4a\xb5\x4c\xd0\x6f\x20\x43\xc1\xdf\xdc\xbc\x81\x5c\x38\x07\x4b\x14\x34\xda\x66\x85\x52\x1b\x30\x36\x45\x12\x5e\xcd\x7a\x14\xd6\x06\x0a\x87\xd6\xc1\x7a\x61\x62\xa9\xe5\x16\x2f\xa7\x6e\x55\xfa\x5e\xbc\xce\x91\x2e\x57\x62\x03\xd2\x53\x59\x8f\x87\xaa\x47\x7a\xf5\xa1\x8b\xbf\x96\x19\x32\xf0\x7e\x98\x97\x53\x61\x33\xce\xf9\x35\x3d\x35\x23\x3c\x0e\x45\xcd\xd8\xde\x5e\x74\x35\x03\xb9\x2c\x3d\xcd\x68\xad\x17\xb2\x66\x48\xf2\x0a\x3f\x35\x83\xb1\xd6\x6a\xf3\x02\x23\xa8\x62\xe0\xa7\x9d\xf0\x64\x2d\x63\x7c\x86\xcf\xba\x15\x39\x3f\xf5\x22\x60\xc8\x8b\x1d\x32\xce\x2d\x6e\x28\x9b\x07\x1b\xd5\x4a\x53\x78\xf1\xf9\x16\x37\x5f\x0e\x57\xa2\x08\xc7\x1a\x5d\x55\x7a\xca\xb0\x08\x6b\x8f\x24\x83\x4a\x0b\x39\x1a\x9e\x81\xfc\xbe\xce\x50\x56\x4f\x90\xcf\x9f\x97\x7b\xd6\xd7\x3f\xcb\x2f\x65\x84\x57\x88\xdf\x59\xef\x36\x34\x8a\x31\x12\x68\x28\x28\xda\xf7\xed\x7f\x05\x00\x00\xff\xff\xfb\x65\x93\x4f\xfc\x22\x00\x00")
+var _call_tracerJs = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xd4\x5a\xdf\x72\xdb\xb6\xd2\xbf\x96\x9e\x62\xe3\x8b\x5a\x9a\x28\x92\x9c\xf4\xeb\x37\x23\x57\x3d\xa3\x3a\x4a\xea\x19\x37\xce\xd8\x4a\x33\x99\x4c\x2e\x20\x72\x29\xa1\x86\x00\x16\x00\x2d\xeb\xb4\x7e\xf7\x33\xbb\x00\x29\x52\x92\x1d\x9f\xb6\x17\x3d\x77\x22\xb1\xbb\x58\xec\xfe\xf6\x1f\xa8\xc1\x00\xce\x4c\xbe\xb1\x72\xb1\xf4\xf0\x72\x78\xf2\xff\x30\x5b\x22\x2c\xcc\x0b\xf4\x4b\xb4\x58\xac\x60\x52\xf8\xa5\xb1\xae\x3d\x18\xc0\x6c\x29\x1d\x64\x52\x21\x48\x07\xb9\xb0\x1e\x4c\x06\x7e\x87\x5e\xc9\xb9\x15\x76\xd3\x6f\x0f\x06\x81\xe7\xe0\x32\x49\xc8\x2c\x22\x38\x93\xf9\xb5\xb0\x38\x82\x8d\x29\x20\x11\x1a\x2c\xa6\xd2\x79\x2b\xe7\x85\x47\x90\x1e\x84\x4e\x07\xc6\xc2\xca\xa4\x32\xdb\x90\x48\xe9\xa1\xd0\x29\x5a\xde\xda\xa3\x5d\xb9\x52\x8f\xb7\xef\x3e\xc0\x05\x3a\x87\x16\xde\xa2\x46\x2b\x14\xbc\x2f\xe6\x4a\x26\x70\x21\x13\xd4\x0e\x41\x38\xc8\xe9\x8d\x5b\x62\x0a\x73\x16\x47\x8c\x6f\x48\x95\xeb\xa8\x0a\xbc\x31\x85\x4e\x85\x97\x46\xf7\x00\x25\x69\x0e\xb7\x68\x9d\x34\x1a\x5e\x95\x5b\x45\x81\x3d\x30\x96\x84\x74\x84\xa7\x03\x58\x30\x39\xf1\x75\x41\xe8\x0d\x28\xe1\xb7\xac\x4f\x30\xc8\xf6\xdc\x29\x48\xcd\xdb\x2c\x4d\x8e\xe0\x97\xc2\xd3\xa9\xd7\x52\x29\x98\x23\x14\x0e\xb3\x42\xf5\x48\xda\xbc\xf0\xf0\xf1\x7c\xf6\xd3\xe5\x87\x19\x4c\xde\x7d\x82\x8f\x93\xab\xab\xc9\xbb\xd9\xa7\x53\x58\x4b\xbf\x34\x85\x07\xbc\xc5\x20\x4a\xae\x72\x25\x31\x85\xb5\xb0\x56\x68\xbf\x01\x93\x91\x84\x9f\xa7\x57\x67\x3f\x4d\xde\xcd\x26\x3f\x9e\x5f\x9c\xcf\x3e\x81\xb1\xf0\xe6\x7c\xf6\x6e\x7a\x7d\x0d\x6f\x2e\xaf\x60\x02\xef\x27\x57\xb3\xf3\xb3\x0f\x17\x93\x2b\x78\xff\xe1\xea\xfd\xe5\xf5\xb4\x0f\xd7\x48\x5a\x21\xf1\x7f\xdd\xe6\x19\x7b\xcf\x22\xa4\xe8\x85\x54\xae\xb4\xc4\x27\x53\x80\x5b\x9a\x42\xa5\xb0\x14\xb7\x08\x16\x13\x94\xb7\x98\x82\x80\xc4\xe4\x9b\x27\x3b\x95\x64\x09\x65\xf4\x82\xcf\xfc\x20\x20\xe1\x3c\x03\x6d\x7c\x0f\x1c\x22\x7c\xbf\xf4\x3e\x1f\x0d\x06\xeb\xf5\xba\xbf\xd0\x45\xdf\xd8\xc5\x40\x05\x71\x6e\xf0\x43\xbf\x4d\x32\x13\xa1\xd4\xcc\x8a\x04\x2d\x39\x47\x40\x56\x90\xf9\x95\x59\x6b\xf0\x56\x68\x27\x12\x72\x35\xfd\x4e\x18\x8c\xc2\x03\xde\xd1\x93\x77\x04\x5a\xb0\x98\x1b\x4b\xbf\x95\x2a\x71\x26\xb5\x47\xab\x85\x62\xd9\x0e\x56\x22\x45\x98\x6f\x40\xd4\x05\xf6\xea\x87\x21\x18\x05\x77\x83\xd4\x99\xb1\x2b\x86\x65\xbf\xfd\x7b\xbb\x15\x35\x74\x5e\x24\x37\xa4\x20\xc9\x4f\x0a\x6b\x51\x7b\x32\x65\x61\x9d\xbc\x45\x26\x81\x40\x13\xed\x39\xfd\xe5\x67\xc0\x3b\x4c\x8a\x20\xa9\x55\x09\x19\xc1\xe7\xdf\xef\xbf\xf4\xda\x2c\x3a\x45\x97\xa0\x4e\x31\xe5\xf3\xdd\x38\x58\x2f\xd9\xa2\xb0\xc6\xe3\x5b\x84\x5f\x0b\xe7\x6b\x34\x99\x35\x2b\x10\x1a\x4c\x41\x88\xaf\x5b\x47\x6a\x6f\x58\xa0\xa0\xdf\x1a\x2d\x6b\xd4\x6f\xb7\x2a\xe6\x11\x64\x42\x39\x8c\xfb\x3a\x8f\x39\x9d\x46\xea\x5b\x73\x43\x92\x8d\x25\x08\xdb\x0d\x98\x3c\x31\x69\x0c\x06\x3a\x47\x75\x0c\x74\xfd\x76\x8b\xf8\x46\x90\x15\x9a\xb7\xed\x28\xb3\xe8\x41\x3a\xef\xc2\xef\xed\x16\x89\x3d\x13\xb9\x2f\x2c\xb2\x3d\xd1\x5a\x63\x1d\xc8\xd5\x0a\x53\x29\x3c\xaa\x4d\xbb\xd5\xba\x15\x36\x2c\xc0\x18\x94\x59\xf4\x17\xe8\xa7\xf4\xd8\xe9\x9e\xb6\x5b\x2d\x99\x41\x27\xac\x3e\x1b\x8f\x39\xfb\x64\x52\x63\x1a\xc4\xb7\xfc\x52\xba\x7e\x26\x0a\xe5\xab\x7d\x89\xa9\x65\xd1\x17\x56\xd3\xcf\xfb\xa0\xc5\x47\x04\xa3\xd5\x06\x12\xca\x32\x62\x4e\xe1\xe9\x36\xce\xe3\x2a\x1e\xce\xf5\x20\x13\x8e\x4c\x28\x33\x58\x23\xe4\x16\x5f\x24\x4b\x24\xdf\xe9\x04\xa3\x96\x6e\xe3\xd8\xa9\x63\xa0\xdd\xfa\x26\xef\x7b\xf3\xae\x58\xcd\xd1\x76\xba\xf0\x0d\x0c\xef\xb2\x61\x17\xc6\x63\xfe\x51\xea\x1e\x79\xa2\xbe\x24\xc5\xe4\xf1\xa0\xcc\x7f\xed\xad\xd4\x8b\x70\xd6\xa8\xeb\x79\x06\x02\x34\xae\x21\x31\x9a\x41\x4d\x5e\x99\xa3\xd4\x0b\x48\x2c\x0a\x8f\x69\x0f\x44\x9a\x82\x37\x01\x79\x15\xce\x9a\x5b\xc2\x37\xdf\x40\x87\x36\x1b\xc3\xf1\xd9\xd5\x74\x32\x9b\x1e\xc3\x1f\x7f\x40\x78\x73\x14\xde\xbc\x3c\xea\xd6\x34\x93\xfa\x32\xcb\xa2\x72\x2c\xb0\x9f\x23\xde\x74\x4e\xba\xfd\x5b\xa1\x0a\xbc\xcc\x82\x9a\x91\x76\xaa\x53\x18\x47\x9e\xe7\xbb\x3c\x2f\x1b\x3c\xc4\x34\x18\xc0\xc4\x39\x5c\xcd\x15\xee\x07\x64\x8c\x58\x0e\x5e\xe7\x29\x63\x11\xfa\x12\xb3\xca\x15\x12\xaa\xca\x5d\xa3\xf9\x59\xe3\x96\xdf\xe4\x38\x02\x00\x30\x79\x8f\x5f\x50\x2c\xf0\x0b\x6f\x7e\xc2\x3b\xf6\x51\x69\x42\x42\xd5\x24\x4d\x2d\x3a\xd7\xe9\x76\x03\xb9\xd4\x79\xe1\x47\x0d\xf2\x15\xae\x8c\xdd\xf4\x1d\x25\xa4\x0e\x1f\xad\x17\x4e\x5a\xf2\x2c\x84\xe3\x1d\x4a\xa4\x4e\x6e\x85\x54\x62\xae\xf0\xad\x70\x9d\x2d\xcd\xb9\x1e\x6d\x69\x9a\x4b\x67\xc6\xf9\x51\xb9\x44\x0f\xe5\x1a\xdb\x8b\xd8\x8e\x87\x77\xc7\xfb\x16\x1d\x76\xb7\x68\x39\xf9\xae\x4b\x2c\xf7\xa7\x55\x0c\x54\xa9\xa4\x9f\x17\x6e\xd9\x61\xc8\x6d\x57\xb7\xe9\x62\x0c\xde\x16\x78\x30\x44\x18\x76\xfb\x90\x73\xa8\x32\xca\x37\xde\x16\x09\x43\x6f\x21\x38\x1b\x71\x36\x10\x94\x9d\x5d\x31\x67\xbf\x78\x63\xf6\x11\x18\x01\x78\x3d\xbd\x78\xf3\x7a\x7a\x3d\xbb\xfa\x70\x36\x3b\xae\x41\x4e\x61\xe6\x49\xa9\xe6\x19\x14\xea\x85\x5f\xb2\xfe\x24\xae\xb9\xfa\x99\x78\x5e\x9c\x7c\x09\x6f\x60\x7c\x20\x2d\xb4\x1e\xe7\x80\xcf\x5f\x58\xf6\xfd\xbe\xf9\x9a\xa4\xc1\x98\x7f\x0f\xda\xbc\x09\xc0\x89\xe4\xde\x94\x04\x8f\xfb\xb9\xfb\xf7\x82\x2a\x9d\x13\xc5\x8f\x42\x09\x9d\xe0\x23\x3a\xef\x63\xad\x9e\x58\x0f\xe4\xaa\x15\xfa\xa5\x49\xb9\x78\x24\x22\xd4\x9f\x12\x41\xa9\xd1\xf8\xdf\x67\xac\xc9\xc5\x45\x2d\x5f\xf1\xf3\xd9\xe5\xeb\x7a\x0e\x3b\x7e\x3d\xbd\x98\xbe\x9d\xcc\xa6\xbb\xb4\xd7\xb3\xc9\xec\xfc\x8c\xdf\x96\xe9\x6d\x30\x80\xeb\x1b\x99\x73\x15\xe2\xdc\x6e\x56\x39\xb7\xd3\x95\xbe\xae\x07\x7e\x69\xa8\x51\xb5\xb1\xc8\x66\x42\x27\x65\xf1\x73\x25\x60\xbd\x21\xb8\x3e\xe4\xbc\x93\x1d\xe7\x55\x10\x96\xee\xbd\xc5\xb8\x69\xda\xf1\xa6\xd4\x6b\x6b\xd0\x80\x46\x2e\x10\x9c\x84\x3b\x4f\x3f\x24\xfc\x0b\x86\x30\x82\x93\x98\x69\x1f\x49\xe5\x2f\xe1\x39\x89\xff\x13\x09\xfd\xd5\x01\xce\x7f\x66\x5a\xdf\x0b\xb4\xbf\x96\xee\xff\x4c\xd4\x99\xc2\x5f\x66\xd9\x08\x76\x8d\xf8\xed\x9e\x11\x2b\xfa\x0b\xd4\xfb\xf4\xff\xb7\x47\xbf\x4d\xfb\x84\x2a\x93\xc3\xb3\x3d\x88\x84\xa4\xfb\x6c\x27\x0e\xa2\x71\xb9\x05\x64\x69\x30\x7e\xa0\xd0\xbc\x6c\x62\xf8\xa1\x4c\xf9\x97\x0a\xcd\xc1\x56\x96\x1a\xd6\x66\xb3\xda\x03\x8b\xde\x4a\xbc\xa5\x71\xf4\xd8\xb1\x48\x6a\xea\xcd\x9a\xd2\x57\x1f\x3e\x62\x90\xa8\x11\x39\xb9\xc4\x21\x80\x7a\x38\xee\x8b\xa9\x91\x8f\xe3\x1c\x43\x4c\x70\xaf\x6e\x11\x56\x62\x43\xe3\x5c\x56\xe8\x9b\x0d\x2c\x84\x83\x74\xa3\xc5\x4a\x26\x2e\xc8\xe3\x01\xc0\xe2\x42\x58\x16\x6b\xf1\xb7\x02\x1d\xcd\x86\x04\x64\x91\xf8\x42\x28\xb5\x81\x85\xa4\x01\x8f\xb8\x3b\x2f\x5f\x0d\x87\xe0\xbc\xcc\x51\xa7\x3d\xf8\xee\xd5\xe0\xbb\x6f\xc1\x16\x0a\xbb\xfd\x76\xad\x84\x55\x47\x8d\xde\xa0\x85\x88\x9e\xd7\x98\xfb\x65\xa7\x0b\x3f\x3c\x50\x0b\x1f\x28\x6c\x07\x69\xe1\x05\x9c\x7c\xe9\x93\x5e\xe3\x06\x6e\x83\x27\x01\x95\xc3\x28\x8d\x86\xe2\xcb\xd7\x97\x9d\x1b\x61\x85\x12\x73\xec\x8e\x78\x48\x66\x5b\xad\x45\x9c\x92\xc8\x29\x90\x2b\x21\x35\x88\x24\x31\x85\xf6\x64\xf8\x72\xe0\x51\x1b\xca\xef\xc7\xbe\x94\xc7\xf3\xa4\x48\x12\x74\xae\x4c\xf7\xec\x35\x52\x47\xac\x88\x1b\xa4\x76\x32\xc5\x9a\x57\x28\x3b\x18\x4e\xcd\x91\x82\xc6\xed\x52\xe0\xca\x38\xda\x64\x8e\xb0\xb6\x34\x9c\x39\xa9\x13\xbe\x9d\x48\x91\xac\xed\xc0\x68\x10\xa0\x0c\x5f\x89\x70\x8c\x83\xb0\x0b\xd7\x0f\xf9\x9e\xb6\xa5\x9c\xa3\xcd\xba\xdf\x04\x72\x1d\xaa\x3c\x06\xed\xb4\x42\x1a\xf0\x4e\x3a\xcf\x5d\x37\x69\x29\x1d\x04\x24\x4b\xbd\xe8\x41\x6e\x72\xce\xd3\x5f\x2b\x67\x31\x59\x5f\x4d\x7f\x99\x5e\x55\x8d\xcf\xd3\x9d\x58\xce\x45\x47\xd5\xd8\x08\x96\x66\x32\x8f\xe9\xd1\x81\x41\xe7\x00\xa0\xc6\x0f\x00\x8a\xe4\x6f\x6b\xe3\xfb\xda\x71\x94\x70\x7e\xeb\x98\x05\x86\x99\xaf\xae\x80\x2b\x94\x77\x3b\xb9\x7b\x37\x39\x98\xbc\xac\x10\xa4\x14\xa7\x1d\x4a\xec\xbb\xd3\x48\x63\x61\x3b\x94\x6c\xf1\x79\x5e\xb3\xf1\x9a\xdb\xcd\x40\x54\x4b\x0d\xbc\x5e\xf6\xad\x22\x54\x03\xd6\xdd\x14\x9e\xe0\x40\xf5\x7b\x9b\xfc\x16\xc2\x7d\x70\xec\xf5\xa3\xe1\xdd\x11\x3c\x87\xb9\x5c\x9c\x6b\xdf\x29\x17\xe1\x45\x65\x43\x8e\x1a\x7a\x2e\xd7\xce\x35\xbc\x80\xf2\x81\x12\x7e\xb7\x7b\x20\x59\xb6\x52\x54\xe8\x11\xb6\x5c\xa7\xb0\xf3\x8a\x78\x83\x75\xd8\x86\x16\xfd\x7e\xad\x1e\x46\x69\x64\xbf\x67\x16\x7d\x1f\x7f\x2b\x84\x72\x9d\x61\xd5\x3b\x84\x03\x79\xc3\xd5\x6e\xbc\xd7\x58\x12\x4f\xb3\x95\x3c\xad\xb1\x45\xe3\x94\x6c\xa1\x31\x3c\x33\x29\x3e\x2a\x21\x8a\x88\x59\xa4\x72\x6d\xc4\xe9\xa1\x56\xbc\x55\x27\x80\xa3\xaa\x3f\xc8\x84\x54\x85\xc5\xa3\x53\x38\x90\x85\x5c\x61\x33\x91\xb0\x6b\x1d\x02\x0f\xf8\x0e\x9c\x59\xe1\xd2\xac\x83\x02\x87\x72\xd9\x3e\x56\x2a\x58\xec\x54\x13\xbe\xa9\x12\x0e\x0a\x27\x16\x58\xc3\x4a\x65\xf0\x0a\x0d\x87\x6e\x1d\xf6\x90\x14\x0b\xe9\x0e\x92\xf6\xd0\x02\xcf\xa1\x86\xb2\x3a\xc8\x0e\xa1\xe8\xfe\xef\x81\xc7\x8e\x9f\xf7\xda\x9e\x92\x88\x9b\x9f\xda\x43\xa9\x6c\xe8\x4d\xfe\x59\x8e\x7f\x72\x84\xed\xd2\x86\xa3\x35\x89\xc3\x01\xb7\x6d\xce\xd7\xdd\x5f\xad\x3e\xe4\xf9\x87\x3a\x28\xc2\xa8\xfe\x15\x13\xbf\xc5\x29\x37\x3d\xf4\x94\x5b\xbc\x95\xa6\xa0\x7a\x86\xff\x4b\xd3\x71\xd5\x01\xde\xb7\x5b\xf7\xf1\x2a\x91\xfd\x56\xbf\x4b\x5c\x2f\xe3\x55\x78\x68\x9e\x6a\xd5\xc4\x70\xa9\x8d\x37\x8c\x59\xb8\xa4\x6e\x31\xff\x23\x77\x8a\x31\xd0\xbd\xc9\xa9\x3b\x88\xc5\x4a\x59\x14\xe9\xa6\xaa\x8f\xbd\xd0\x97\xc0\x52\xe8\x34\xce\x26\x22\x4d\x25\xc9\x63\x10\x92\x86\x62\x21\xa4\x6e\x1f\x34\xe3\x57\x8b\xf2\x21\x64\xec\xb5\xba\xf5\xba\x1a\x67\x4a\x1a\x00\x59\xe3\xf6\x13\xea\xe7\x4e\x10\xed\x5e\x8f\xc6\x1b\x56\xa3\x5d\xb1\xe2\xc6\x18\x44\x79\x1f\x15\x1a\x2e\x9d\x42\xa2\x50\xe8\xf0\x51\x04\x33\x6f\x6e\xd1\xba\xf6\x13\x40\xfe\x67\x30\xbe\x93\x15\xcb\xc7\x68\x8e\xa7\xc7\xec\x53\x23\x36\x1c\xff\x8d\x12\xde\x47\x78\xd5\xcc\x1b\x22\x4b\x7a\xfe\x5e\x86\xda\xb7\x9f\x16\x52\xdc\x42\x11\xcd\x0f\x30\xac\xb5\xe9\xff\x94\x20\xdb\x87\xd8\x45\xd5\xae\xc5\xc3\x7b\x63\x7a\xa0\x50\xf0\xd0\x54\x7e\xcd\x2a\xdb\xd3\xc7\x66\xb8\x32\x7a\x43\x83\xb7\x17\xbe\x7c\xc5\xb7\xc4\xf2\x42\x24\x74\xfa\x73\x44\x0d\xd2\xa3\x15\x34\x1e\x11\xba\xe2\x07\x18\xd2\xd2\xb1\x38\xf6\x8b\xa4\xa0\x8b\x82\xe3\xd7\x10\x2a\xcc\x52\x2f\xfa\xed\x56\x78\x5f\x8b\xf7\xc4\xdf\x6d\xe3\x3d\x54\x40\xe6\x8c\x57\x04\xd5\x0d\x41\xe2\xef\xb8\x79\xe4\x29\x7a\xe7\x9a\x80\xd6\xe8\x55\x18\xb1\x77\x2e\x05\x98\x31\x5e\x0c\xec\x5e\x91\xd1\x1a\xbf\x6b\x00\x9c\x49\xab\xdb\xdf\x9d\x90\xf0\x77\xfb\x11\x51\x32\x50\x30\x8c\x0e\x33\xd0\xd2\x01\xa6\x9d\x8b\x0a\x22\xe6\x57\x61\x35\xd4\xf3\x51\x7d\x35\xbc\x8a\x07\x95\xab\x9a\x6d\xe4\x8a\x6d\x73\x7f\x7a\x38\xc9\x0d\x4b\x3c\x1e\x4e\x66\x64\xf3\x0a\xb0\x0f\xb0\xd6\x47\x8f\x7d\x92\xc7\x52\x25\x4b\x2f\x33\xdb\x03\xac\x2c\xbd\xd6\x72\xf8\xbb\xa7\x8b\xac\x88\xeb\x2a\x36\x68\x1a\x42\xf8\xf2\x71\x6f\xf9\xd0\xe0\x45\x73\x4b\x24\x2c\x9b\xab\xf1\x98\x86\x89\xb2\xf3\x8a\xb9\xaa\x41\x53\x2a\x11\x22\x23\x9c\x97\xa3\x42\xfe\x1b\xe3\xb6\xf5\x18\x2c\x97\xc0\x62\xf8\xe6\xc3\xdd\x2c\x85\xa0\x99\x73\x03\x51\x38\x9a\x4c\xb7\xb1\x95\xa2\x93\x16\x53\xc8\x24\xaa\x14\x4c\x8a\x96\xe7\xde\x5f\x9d\xd1\xe1\xeb\x1e\x5a\x49\x12\xc3\x57\xcc\xf0\x87\x02\xfe\xb6\xaa\x65\x82\x7e\x03\x19\x0a\xfe\x4c\xe7\x0d\xe4\xc2\x39\x58\xa1\xa0\x49\x37\x2b\x94\xda\x80\xb1\x29\x92\xf0\x6a\xf4\xa3\xb0\x36\x50\x38\xb4\x0e\xd6\x4b\x13\x4b\x2d\xb7\x78\x39\x75\xab\xd2\xf7\xe2\xed\x8e\x74\xb9\x12\x1b\x90\x9e\xca\x7a\x3c\x54\x3d\xd2\xab\x6f\x63\xfc\x81\xcd\x90\x81\xf7\xc3\xbc\x1c\x12\x9b\x71\xce\xaf\xe9\xa9\x19\xe1\x71\x28\x6a\xc6\xf6\xf6\xde\xab\x19\xc8\x65\xe9\x69\x46\x6b\xbd\x90\x35\x43\x92\x57\xf8\xa9\x19\x8c\xb5\x56\x9b\x17\x18\x41\x15\x03\x3f\xed\x84\x27\x6b\x19\xe3\x33\x7c\x09\xae\xc8\xf9\xa9\x17\x01\x43\x5e\xec\x90\x71\x6e\x70\x43\xd9\x3c\xd8\xa8\x56\x9a\xc2\x8b\xcf\x37\xb8\xf9\x72\xb8\x12\x45\x38\xd6\xe8\xaa\xd2\x53\x86\x45\x58\x7b\x24\x19\x54\x5a\xc8\xf1\xf0\x14\xe4\xf7\x75\x86\xb2\x7a\x82\x7c\xfe\xbc\xdc\xb3\xbe\xfe\x59\x7e\x29\x23\xbc\x42\xfc\xce\x7a\xb7\xa1\x51\x8c\x91\x40\x43\x41\xd1\xbe\x6f\xff\x27\x00\x00\xff\xff\xeb\xa5\xc4\x0a\x2f\x23\x00\x00")
 
 func call_tracerJsBytes() ([]byte, error) {
 	return bindataRead(
@@ -133,7 +142,27 @@ func call_tracerJs() (*asset, error) {
 	}
 
 	info := bindataFileInfo{name: "call_tracer.js", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)}
-	a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x46, 0x79, 0xb6, 0xbc, 0xd2, 0xc, 0x25, 0xb1, 0x22, 0x56, 0xef, 0x77, 0xb9, 0x5e, 0x2e, 0xf4, 0xda, 0xb2, 0x2f, 0x53, 0xa4, 0xff, 0xc8, 0xac, 0xbb, 0x75, 0x22, 0x46, 0x59, 0xe3, 0x1d, 0x7d}}
+	a := &asset{bytes: bytes, info: info}
+	return a, nil
+}
+
+var _call_tracer_parityJs = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xe4\x7b\x6f\x6f\x1b\x37\xd2\xf8\x6b\xe9\x53\xcc\xf9\x45\x2b\x21\x8a\x24\x27\x6d\x7e\x80\x7c\xce\xc1\x75\x9c\xd6\x38\x37\x0e\x6c\xa5\x45\x11\x18\x3f\x50\xbb\xb3\x12\x93\x15\xb9\x47\x72\x2d\xab\x89\xbf\xfb\x83\x19\x92\xab\x5d\x69\xe5\x38\xbd\xe0\x41\x81\x27\x6f\xa2\x25\x39\xc3\x99\xe1\xfc\x27\x3d\x1a\xc1\xa9\x2e\xd6\x46\xce\x17\x0e\x9e\x8d\x0f\xff\x1f\x4c\x17\x08\x73\xfd\x14\xdd\x02\x0d\x96\x4b\x38\x29\xdd\x42\x1b\xdb\x1d\x8d\x60\xba\x90\x16\x32\x99\x23\x48\x0b\x85\x30\x0e\x74\x06\x6e\x6b\x7d\x2e\x67\x46\x98\xf5\xb0\x3b\x1a\x79\x98\xd6\x69\xc2\x90\x19\x44\xb0\x3a\x73\x2b\x61\x70\x02\x6b\x5d\x42\x22\x14\x18\x4c\xa5\x75\x46\xce\x4a\x87\x20\x1d\x08\x95\x8e\xb4\x81\xa5\x4e\x65\xb6\x26\x94\xd2\x41\xa9\x52\x34\xbc\xb5\x43\xb3\xb4\x91\x8e\x9f\xdf\xbc\x83\x0b\xb4\x16\x0d\xfc\x8c\x0a\x8d\xc8\xe1\x6d\x39\xcb\x65\x02\x17\x32\x41\x65\x11\x84\x85\x82\x46\xec\x02\x53\x98\x31\x3a\x02\x7c\x4d\xa4\x5c\x07\x52\xe0\xb5\x2e\x55\x2a\x9c\xd4\x6a\x00\x28\x89\x72\xb8\x45\x63\xa5\x56\xf0\x3c\x6e\x15\x10\x0e\x40\x1b\x42\xd2\x13\x8e\x18\x30\xa0\x0b\x82\xeb\x83\x50\x6b\xc8\x85\xdb\x80\x3e\x42\x20\x1b\xbe\x53\x90\x8a\xb7\x59\xe8\x02\xc1\x2d\x84\x23\xae\x57\x32\xcf\x61\x86\x50\x5a\xcc\xca\x7c\x40\xd8\x66\xa5\x83\xdf\xcf\xa7\xbf\x5c\xbe\x9b\xc2\xc9\x9b\x3f\xe0\xf7\x93\xab\xab\x93\x37\xd3\x3f\x8e\x60\x25\xdd\x42\x97\x0e\xf0\x16\x3d\x2a\xb9\x2c\x72\x89\x29\xac\x84\x31\x42\xb9\x35\xe8\x8c\x30\xfc\x7a\x76\x75\xfa\xcb\xc9\x9b\xe9\xc9\x4f\xe7\x17\xe7\xd3\x3f\x40\x1b\x78\x7d\x3e\x7d\x73\x76\x7d\x0d\xaf\x2f\xaf\xe0\x04\xde\x9e\x5c\x4d\xcf\x4f\xdf\x5d\x9c\x5c\xc1\xdb\x77\x57\x6f\x2f\xaf\xcf\x86\x70\x8d\x44\x15\x12\xfc\x97\x65\x9e\xf1\xe9\x19\x84\x14\x9d\x90\xb9\x8d\x92\xf8\x43\x97\x60\x17\xba\xcc\x53\x58\x88\x5b\x04\x83\x09\xca\x5b\x4c\x41\x40\xa2\x8b\xf5\xa3\x0f\x95\x70\x89\x5c\xab\x39\xf3\xbc\x57\x21\xe1\x3c\x03\xa5\xdd\x00\x2c\x22\xfc\x73\xe1\x5c\x31\x19\x8d\x56\xab\xd5\x70\xae\xca\xa1\x36\xf3\x51\xee\xd1\xd9\xd1\xcb\x61\x97\x70\x26\x22\xcf\xa7\x46\x24\x68\xe8\x70\x04\x64\x25\x89\x3f\xd7\x2b\x05\xce\x08\x65\x45\x42\x47\x4d\xbf\x13\x56\x46\xe1\x00\xef\xe8\xcb\x59\x52\x5a\x30\x58\x68\x43\xbf\xf3\x3c\xea\x99\x54\x0e\x8d\x12\x39\xe3\xb6\xb0\x14\x29\xc2\x6c\x0d\xa2\x8e\x70\x50\x67\x86\xd4\xc8\x1f\x37\x48\x95\x69\xb3\x64\xb5\x1c\x76\x3f\x75\x3b\x81\x42\xeb\x44\xf2\x91\x08\x24\xfc\x49\x69\x0c\x2a\x47\xa2\x2c\x8d\x95\xb7\xc8\x4b\xc0\xaf\x09\xf2\x3c\xfb\xed\x57\xc0\x3b\x4c\x4a\x8f\xa9\x53\x21\x99\xc0\xfb\x4f\xf7\x37\x83\x2e\xa3\x4e\xd1\x26\xa8\x52\x4c\x99\xbf\x8f\x16\x56\x0b\x96\x28\xac\xf0\xfb\x5b\x84\x0f\xa5\x75\xb5\x35\x99\xd1\x4b\x10\x0a\x74\x49\x1a\x5f\x97\x8e\x54\x4e\x33\x42\x41\xbf\x15\x1a\xa6\x68\xd8\xed\x54\xc0\x13\xc8\x44\x6e\x91\xf6\x2d\x84\x91\x6e\x7d\x66\x8c\x36\xbf\x8a\xa2\x90\x6a\x3e\x81\x4f\xdd\x4e\xe7\x20\xd1\x8a\x05\x0b\x89\x41\x96\x00\x24\x3a\x45\xb0\x4e\x1b\x31\x47\xda\x96\xb8\x9b\x0b\x7b\x30\x81\x83\xcb\xcd\xd7\x80\x80\x1f\x9e\x9d\x0b\x0b\xa5\x54\xee\xc5\x0f\xa0\x6f\xd1\x64\xb9\x5e\xb5\x2d\x5b\x8a\xbb\xb0\xa7\xfc\x13\x01\xef\x12\xc4\x14\xd3\xb6\x95\x52\xdd\x8a\x5c\xa6\xf0\xa1\x5c\x16\x24\x22\x27\x15\x93\x4c\x6b\x7f\x12\x2d\xe3\x0c\x55\x9d\x08\x18\xbc\x45\xe3\x3c\xee\xab\xf8\x9b\xd7\x18\x74\xa5\x51\x90\x0a\x27\x22\xcb\x33\x72\x55\x75\xbe\xc2\x00\xaf\xf7\xc7\x9e\xcb\xa5\x24\x8d\x10\x09\xf9\xbc\xc3\xf1\xb3\x1f\xa0\x77\x38\x7e\xf6\xbc\x5f\x83\xe2\x95\x1e\xa8\x30\x98\xe8\x65\x21\x73\x3a\x56\x41\xff\x31\xe1\xa5\xcc\xdd\x53\xa9\xe2\xd0\xa0\xdb\xb9\x6f\x3f\xb1\x6b\x27\x8c\x93\x6a\xfe\xbb\x74\x8b\x70\x7a\x51\x22\xba\x20\x09\x4e\xa2\x20\xa4\xb2\xce\x94\xc9\x46\x06\x9e\x5e\xf6\xed\xf1\x18\xae\xb7\x86\x9a\xfb\x5e\x7f\x94\x05\x5b\xa8\x7d\xad\x0d\x13\x61\x27\xf0\xde\x6f\x69\xcb\x2c\x93\x89\x24\x6b\x98\x89\x5c\xa8\xc4\x3b\x22\xd6\xcd\x0c\xcd\x41\xb7\xc3\xaa\x2e\xed\xe5\xec\x03\x26\xee\x6c\x59\xb8\xf5\x04\xb2\x52\x31\x41\x3d\x3d\xfb\xd0\x67\xea\x09\xa8\x77\x2b\x0c\xdc\x91\x4f\xf6\xc3\x10\x4e\x82\x15\xf7\x08\xee\xbb\x9d\x4e\x18\x71\xa6\xc4\xa3\x40\xe3\x68\x04\xd6\x61\x41\xb6\x29\xd5\xad\xfe\x48\x02\xd5\x86\x1c\xb2\x59\x07\x59\x78\xaf\x41\x56\x59\x19\x25\xda\x61\xb7\x43\x70\x35\x62\x72\x3d\x1f\x40\x3a\xf3\x04\x51\xc8\x16\x85\x2b\x0d\xb2\x77\x40\x66\x1b\xe4\x72\x89\xa9\x14\x0e\xf3\x75\xb7\xd3\x21\x7a\x79\x02\x8e\x21\xd7\xf3\xe1\x1c\x1d\x8b\xa7\xd7\x3f\xea\x76\x3a\x32\x83\x9e\x5b\x17\xa8\xb3\xb0\xe8\x1f\xc7\xc7\x70\x40\x42\xce\xa4\xc2\xf4\xc0\xef\xd3\x71\x0b\x69\x87\x99\x28\x73\x57\x11\x40\xd0\x81\x55\xfa\x79\xef\xc9\xf9\x1d\x41\xab\x7c\x0d\x09\x05\x4f\x31\x23\xd5\xb4\x6b\xeb\x70\x19\xb8\xb4\x03\xc8\x84\x25\xcf\x20\x33\x58\x21\x14\x06\x9f\x26\x0b\x24\x97\xa4\x12\x0c\xe4\xda\xb5\x65\x5f\x75\x0c\xb4\xdb\x50\x17\x43\xa7\xdf\x94\xcb\x19\x9a\x5e\x1f\xbe\x83\xf1\x5d\x36\xee\xc3\xf1\x31\xff\x88\x4c\x04\x98\x40\x2f\x61\xd1\x45\xe0\x98\xe1\xaf\x9d\x91\x6a\xee\x99\x0e\xb4\x9e\x67\x20\x40\xe1\x0a\x2a\x97\x22\x2d\xcc\x50\xaa\xb9\xf7\x2d\x98\x0e\x40\xa4\x29\x38\xed\x1d\x6a\xe5\x3e\x9b\x5b\xc2\x77\xdf\x41\x8f\x36\x3b\x86\x83\xd3\xab\xb3\x93\xe9\xd9\x01\x7c\xfe\x0c\x8d\x91\x67\x07\xfd\x1a\x65\x52\x5d\x66\x59\x20\x8e\x11\x0e\x0b\xc4\x8f\xbd\xc3\xfe\xf0\x56\xe4\x25\x5e\x66\x9e\xcc\xb0\xf6\x4c\xa5\x70\x1c\x60\x9e\x6c\xc3\x3c\x6b\xc0\x10\xd0\x68\x04\x27\xd6\xe2\x72\x96\xe3\x6e\x9c\x09\x81\x88\x63\x12\x79\x4c\x6f\x08\x64\xe4\x39\x92\x7a\xc5\x5d\x83\xf8\x99\xe2\x0e\xe9\xc7\x04\x00\x40\x17\x03\x1e\x20\x17\xcf\x03\x4e\xff\x82\x77\x7c\x46\x51\x84\xa4\x5e\x27\x69\x6a\xd0\xda\x5e\xbf\xef\x97\x4b\x55\x94\x6e\xd2\x58\xbe\xc4\xa5\x36\xeb\xa1\xa5\x38\xdb\x63\xd6\x06\x9e\xd3\x08\x33\x17\x96\x77\x88\x2a\x7b\x72\x2b\x64\x2e\x66\x39\xfe\x2c\x6c\x6f\xb3\xe6\x5c\x4d\x36\x6b\x9a\x53\xa7\xda\xba\x49\x9c\xa2\x8f\x38\xc7\xf2\x22\xb0\x83\xf1\xdd\xc1\xae\x44\xc7\xfd\x8d\xb6\x1c\xbe\xe8\x13\xc8\xfd\x51\x65\x03\x55\x84\x1c\x16\xa5\x5d\xf4\x58\xe5\x36\xb3\x9b\x28\x78\x1c\xcd\xbf\xc5\x46\x58\xef\x76\x75\xce\x62\x9e\x71\x30\x20\x47\x48\xba\x37\x17\x1c\x65\xd9\x2f\x08\xca\x3a\x6c\x39\xe3\x83\x71\x5a\x7b\x4c\x6f\x2e\xa7\x67\x13\xf8\x37\x92\x67\x71\x64\x6e\xb7\xfe\xcc\xb7\x88\x91\x19\xb0\x8d\xed\xea\x6d\x50\xd2\xeb\xb3\x8b\xd7\xaf\xce\xae\xa7\x57\xef\x4e\xa7\x07\x35\x45\xcd\x31\x73\xc4\x4a\x93\xf3\x1c\xd5\xdc\x2d\x98\xb7\x9a\xfb\x68\x2e\x7a\x4f\xa0\x4f\x0f\x6f\xfc\x08\x1c\xb7\x7a\x95\xce\xc3\x30\xf0\xfe\x86\x37\xb9\xdf\x95\x7e\x73\xa9\x3f\x8b\x6f\xa3\xac\x4e\x7b\xbd\x0b\xcb\x9d\x8e\x0b\x1e\x56\x93\xfe\xb7\xd5\xc9\x74\x46\x2b\x7e\xf2\xc1\xea\x01\x9a\x77\x55\x75\x8f\x5f\xae\x7c\xdd\x12\xdd\x42\xa7\x1c\x85\x12\x9f\x3e\x55\x0a\x98\x6a\x85\x5f\xef\xf1\x4e\x2e\x2e\x1a\xfe\xee\xe4\xe2\xe2\xf4\xf2\x55\xc3\x07\xbe\x3a\xbb\x38\xfb\xf9\x64\x7a\xb6\xbd\xf6\x7a\x7a\x32\x3d\x3f\xe5\xd1\xba\x7b\x74\x9a\x74\x6e\x9f\xe0\x0f\xb7\x04\x5f\x79\x3d\xca\x00\x38\x0c\x72\x4c\xf1\x79\x4b\x8d\x4f\x3b\x00\xb7\xd0\x54\xf7\x99\x90\xb3\x66\x42\x25\x31\xfa\xda\xa8\xcd\xd2\xbe\xdd\x64\x3d\x3d\xa7\xfb\x0f\x31\xdb\xc2\x40\x4d\xf4\x5e\x71\x39\x14\xb1\xbb\xef\x3d\x5e\x1c\xf0\x2f\x18\xc3\x04\x0e\x03\x77\x0f\x04\x8d\x67\xf0\x84\xd0\xff\x85\xd0\xf1\xbc\x05\xf2\xef\x19\x40\x76\x6c\xf2\xef\x19\x58\x74\xe9\x2e\xb3\x6c\x02\xdb\x82\xfe\x61\x47\xd0\xd5\xfa\x0b\x54\xbb\xeb\x7f\xdc\x59\x1f\x82\x50\xd4\xd1\x2f\x99\x5e\x54\x45\x3a\x08\xc6\xd1\xa2\x36\x5e\x4d\xb8\xe2\x1b\xc6\x35\xc1\xf9\xf0\x67\xc3\xc8\xfc\xd6\xac\x19\x29\x9d\xbb\x2c\x50\xa5\xd0\xe3\x4c\x8f\x76\xfd\x1c\xb7\xa6\xd2\x50\x85\x3d\x5f\xc2\xb8\x1f\xc1\xa6\x97\xaf\x2e\x27\x54\x78\xa4\xe4\x68\xa8\xce\xe2\x32\x51\xe1\x9d\x8b\xe9\xaf\xb4\x60\x45\xe6\x13\xc3\xb8\x83\x47\x94\x2c\x84\x9a\x7b\x0b\x65\xf6\x37\xe8\x03\x9f\x9e\x0b\xc2\x7a\x0c\x33\x39\x3f\x57\xae\x57\x8d\x3c\x81\x67\xcf\xc7\xe3\xc0\x2d\x1b\xe4\x3d\x60\x6e\x11\x6a\x82\xac\x9b\x71\x40\xb9\x2d\x97\xf1\x41\xb0\xe8\x6f\x9d\x09\xb4\xd6\xd0\x54\x29\x37\xab\xe4\x01\xd5\x19\x46\xe2\x2d\x82\x74\xdf\x5b\xc6\x09\x22\xcf\xf5\x8a\x22\xc4\x10\x7e\x47\x8f\x51\x21\xb2\xfb\x0e\xdd\x07\xe2\x92\x25\xbd\x92\x6e\x11\xfa\x48\x6c\x9a\x82\x9b\x04\x06\x61\x29\xd6\x30\x43\xaa\x2f\x3e\xae\xf9\x60\xd2\xb5\x12\x4b\x99\x58\x8f\x8f\x3b\x0f\x06\xe7\xc2\x30\x5a\x83\xff\x29\xd1\x3a\x4c\xd9\x01\x88\xc4\x95\x22\xcf\xd7\x30\x97\xb7\xa8\x18\xba\x47\xd2\x8e\xe7\x37\x80\x17\xcf\x47\x2f\x7e\x00\x53\xe6\xd8\x1f\xc6\x6a\xa3\x21\x9e\x20\x6f\x9a\x08\x16\xf5\x0a\x0b\xb7\xe8\xf5\xe1\xe5\x9e\xbc\xa3\xae\xdc\xc1\xcb\x6c\xe5\x06\xad\x60\xf0\x14\x0e\x7d\x3a\x51\x4f\x5a\x36\x8a\xd3\x9e\xa0\xd4\x35\xab\xee\x0c\x76\xd5\xe9\x53\x5d\xd5\x7b\x1f\x85\x11\xb9\x98\x61\x7f\xc2\x4d\x3e\xa6\x73\x25\x42\x97\x87\xce\x16\x8a\x5c\x48\x05\x22\x49\x74\xa9\x1c\x9d\x5f\x6c\xd8\xe4\x6b\x0a\xc4\xdf\xbb\x88\x8f\xfb\x61\x22\x49\xd0\xda\x18\x97\xf9\xf0\x89\x28\xb1\x24\x68\xaa\x9e\x65\x8a\xb5\xc3\x25\xe7\xac\x39\x16\x86\x15\x2b\x99\xe7\x11\xe1\x52\x5b\xda\x64\x86\xb0\x32\x9a\xf2\x4e\x49\x05\xb1\x24\xfd\xa3\x43\xb3\xa0\x15\x08\xc8\x35\x77\x03\xd8\xc5\x82\x30\x73\x3b\xf4\x01\x96\x6d\x57\x1b\x50\x7a\x35\x6c\x26\x67\x75\x95\xf7\xd5\x70\x50\xf4\xf6\x9c\xf3\xea\xec\xb7\xb3\xab\x69\xa3\xc0\x7c\xcc\x11\x0e\x63\x2d\xdb\xd6\x26\xa9\x02\x18\x1f\xc2\x9f\x52\xcf\x85\x4d\x16\xa6\xef\x5d\x0f\x0b\x48\x97\x8e\x38\x62\xa3\xf0\x4d\x06\x61\x89\x79\x8a\x3f\x42\x2a\xdf\x3b\xf3\x7b\x14\xc2\xda\xd8\xd0\x62\xd9\xc6\x94\x3d\xc5\x5b\xcc\x75\x81\x66\xd7\xa8\xf7\xf1\x3a\x7d\x77\xf5\xe6\x60\xbf\xb2\x1f\x3f\x42\xd9\x7d\x78\xd9\x75\xe5\xe3\xed\xd8\x1f\x57\x5f\xa0\x7a\x44\x91\xf9\x15\xa2\x0f\xb2\x3b\xde\x17\x6f\x3d\x85\x83\x48\xe9\x93\x40\x44\xbf\xbf\xc9\x86\x76\xa5\xf5\x48\x49\x10\x05\x41\x1a\xa3\x11\xbc\xd5\x05\x27\x55\x74\x2c\xb9\xb0\x6e\xa3\xf7\x73\xf4\x4d\x94\xba\x76\xd8\x32\x77\xb6\xfb\x90\xcf\x18\x16\xba\x88\xf9\x0f\x11\xc5\x66\x4f\x3e\x62\xbb\xaa\x6f\x9b\x78\x56\xb9\x0b\xef\xd2\x5d\xdd\xe2\x05\xf8\x45\x35\x07\xde\xd0\x25\xe1\x73\x1d\xa6\x3d\xc8\x97\xc2\x61\xb7\xee\x7c\xde\x59\x36\xaa\x10\x9e\xb7\x23\xdc\xd3\x4a\x86\xec\x9a\xe8\x3b\xce\x9d\x2b\x78\x5a\xf9\x38\x4a\x55\xfa\x5b\x25\x83\xd7\x80\x14\x73\x74\x08\x1b\xa8\x23\xd8\x1a\x22\xd8\x90\x04\x90\x0c\x0d\xba\x36\x3d\xdc\xb8\xd7\x7f\x18\x74\x43\xfc\x4f\x29\x72\xdb\x1b\xf7\x9b\xde\xd4\x69\xce\xbf\x8e\x77\x2a\x2c\x82\x69\xd6\x54\x47\x35\xb0\x2d\xe5\xf3\x15\xd2\xa9\x4e\xf1\x41\x0c\xd1\x53\x6f\x62\x7e\xdd\xf3\x07\x5f\xb2\xc7\xf7\xfb\x26\xd2\x59\xb3\x77\x76\x2a\xf2\xbc\xd6\x3f\x6b\x86\x93\xb8\xba\xbd\x89\xd6\xa9\x05\xc0\xbd\x4d\xcb\xa1\x54\x29\xde\x5d\x66\xbd\x80\xab\x0f\x2f\xe1\xe9\xe1\x06\x43\xbd\xbe\x88\x46\x15\x45\x14\x5d\x63\x00\x0d\x6b\x1a\x01\xaa\x6a\x1b\x78\xef\xe8\x9d\xe3\x0a\xe3\xe5\x0b\xb7\x86\xd9\x36\x3c\x90\x50\xeb\xa5\x36\xd8\xb6\xc9\x41\x55\x17\x64\x42\xe6\xa5\xc1\x83\x23\x68\x09\x7f\xb6\x34\x99\x48\x58\xe9\x2d\x02\xb7\x10\x2d\x58\xbd\xc4\x85\x5e\x75\x5b\x38\xba\xdf\x1f\x59\x77\x4d\x6b\x73\x17\xd0\x4c\x91\xf8\xde\x47\x58\x28\xad\x98\x63\xcd\xb4\xf6\x86\xff\x7d\x07\xf6\x28\x0b\xdc\xb1\x32\x78\x02\x35\xeb\xac\x1b\x67\x9b\xf5\xdd\xff\xef\xda\xe0\x36\xfb\xd1\xae\x9a\x12\xa8\x7c\x5d\x7d\x7a\x7c\x57\x53\xe5\x36\xa3\x0c\xac\x5e\xf1\x81\xbe\x12\x4e\xf4\x2a\x1b\xbe\xff\xbf\x61\x87\x6d\x2d\x84\xe8\x9d\x82\xf7\xeb\xf7\x7d\x66\x50\x23\xb1\x76\x2d\x55\xdb\xa1\x69\x6e\x2d\x97\x31\x6c\x70\x6f\x99\x03\x2e\xc1\x85\x93\xb3\x3c\x1a\xeb\x96\xd9\x3f\xe4\x21\x22\xf5\x7f\x77\x4f\x11\x7d\xc3\x8e\xc1\xf8\x84\xa3\x69\x31\x3e\xf7\xd8\x64\x1e\x5f\x61\xf6\xb5\xa4\xff\xfb\xf1\xdd\xf7\xbb\x16\xdf\x62\xc6\xf7\x31\xf5\x3c\x57\x1f\x30\x71\x1b\x4f\xc5\xb5\x1c\x7d\x15\x06\x6f\xa5\x2e\x29\xbf\xc6\x47\x37\x58\xc3\x02\xfe\xef\x25\x8c\xe1\x5f\xe0\x3b\x9f\x30\xa1\xff\x1f\xd1\x83\xfd\xfa\x0e\xec\xa3\xfb\xaf\x8d\xee\x6b\x55\xff\xde\x6f\xae\xbc\xf8\x0c\xeb\x77\x5e\xdc\x1d\x20\x59\xf8\xca\xb1\x96\xa4\xe9\x8c\xef\x8c\x7d\x2b\x20\xf3\x4f\x03\x3a\x0c\xff\xc0\xdd\x57\x08\x08\x4e\x17\x54\xd3\x84\x1c\x30\xa7\x54\x7f\x5d\xd5\x04\x03\x5f\x4d\xc1\x42\xa8\x34\x34\xb4\x44\x9a\x4a\xc2\xc7\x0a\x49\x14\x8a\xb9\x90\xaa\xfb\x90\x24\xbf\x58\x8f\xb4\x6b\xd2\x4e\xc1\x5f\xcf\x5b\x43\x0f\x92\x0d\x9a\x50\x77\x1f\x91\x9f\x6e\x59\xd6\xf6\x7d\x5e\xf7\x71\xce\xf2\xd1\x9e\xf2\xbf\x75\x93\xdb\xbd\xd0\x7d\x3e\x88\x8d\x87\xdf\x1f\x29\x5b\x2e\xb9\xb1\x01\x22\x36\xe6\x7c\xa5\xab\x52\x48\x72\x14\xca\xbf\xa6\xc1\xcc\xe9\x5b\x34\xb6\xfb\x35\x76\xfd\x57\xcc\x7a\x2b\x01\x88\x9f\xdd\xa6\xb3\x1c\x8d\xe0\x2a\xe6\x1e\xb4\x41\xb3\x3b\xb3\xa9\x20\x1b\xaf\x1e\xe2\x7d\xe9\x37\x6d\xd9\x7c\xfb\x9e\xcd\x7e\xb1\x3d\x9c\xd8\xf0\x99\x56\xb5\x54\x2d\xc2\xd7\x82\x1d\x05\xc2\xc7\x75\x62\x6a\x44\x54\xdd\x38\x52\xa9\xc7\xa6\x4d\x8f\x8f\x17\x5e\x13\x5f\xe7\xc2\xb9\xe0\xac\x6a\x36\xea\xbd\xb9\x74\xfc\xe6\x0d\x95\xeb\x3e\xce\x8d\x73\x9d\x1b\x5c\x78\xdd\xb4\xfe\x26\x37\x67\x9b\xde\xe5\x8e\xc3\xba\xa8\x8a\xeb\x20\x05\xa7\xf5\x00\x72\x14\xdc\x88\x8c\x4f\xd3\xe2\x1d\xd1\x43\x8d\xd1\x18\x14\x7c\x39\xbe\x13\x15\xf8\x5e\x73\x81\xf1\x3a\xc6\xb7\xbd\x66\x88\x0a\xa4\x43\x23\x48\x7d\xc9\xe2\xc3\x6b\x2a\xa2\xd2\x32\x3a\x3e\x20\x49\xbe\x3c\x20\x0e\x4f\x9b\xc8\x96\xa4\x9a\x0f\xbb\x1d\x3f\x5e\x0b\x23\x89\xbb\xdb\x84\x11\x9f\x4a\x33\x64\xb8\xae\x98\xe5\x3a\xf9\x38\x01\x80\xc4\xdd\x0d\xf9\x83\xdb\xf5\xd5\x25\x06\x0d\xd3\x07\x8f\x6e\xdd\x64\xd0\x1c\x0d\xf9\x0e\xff\xd6\xbd\x05\x03\x86\xbb\x8b\xea\xc2\x2f\x98\x14\xcd\xed\xf6\xdd\x79\x69\x75\x63\xb1\xe5\xb4\xdc\xdd\xae\xcf\x8a\x00\xe4\xae\x26\xed\x00\x34\xd5\x02\xb4\x75\x97\x42\x8b\x79\xc8\xcf\xfa\x3c\x7f\x52\x9f\xf5\x43\x81\x51\xb9\xac\xc9\x46\x2e\x59\x36\x7c\x6b\xce\xaf\x4f\xc8\xb1\x9d\xba\xbb\x86\x80\x7f\x11\x76\x31\xd9\x88\x98\x3e\x07\xd5\xa4\x7f\xec\x51\x9b\xf6\x03\x7e\xaf\xcd\x8b\xb2\x0d\x8e\xad\xc1\xed\x85\x6f\xb5\xe5\x88\xbf\xb3\x38\x4e\x54\xf4\x92\xfb\xf4\x49\x4a\xa3\xa3\x69\x70\xe9\x9b\x83\xec\xd8\x55\x0a\x99\x34\xd6\x91\x6a\x2e\xc9\x06\x92\xfa\xe3\x3b\xa1\x00\x97\x85\x5b\x83\xe6\xd7\x44\x1e\x69\x6a\x74\x11\x74\x35\x02\x0e\xf8\x11\x91\xe1\xd7\xab\x3a\xe6\x27\x98\xce\xc9\x1f\x59\xb4\x1b\xdb\xc2\xa2\xd7\x87\x5c\xeb\x62\xe8\x71\xe1\x9d\x58\x16\xf5\xb5\x93\xda\x6b\x02\x25\x7d\x03\x89\xdc\xe4\x8b\xf1\x8f\xe2\xc5\x78\x3c\xfe\xf1\xf9\x8b\xf1\xf8\x90\x7e\xd1\xff\xd9\x38\xcb\xc6\xe3\x83\x01\x58\x14\x26\x59\xf0\x3e\x68\x5d\x2a\x9c\x68\x6d\xd1\xb3\x93\x6e\xcd\x7f\x5e\xc2\x61\x35\xd9\x78\x3c\xd5\xdb\xf2\x39\xe3\x9b\x7e\x6b\x9f\x77\x68\x17\x32\x73\x9b\x47\x39\xfb\x9d\xe2\x38\xfa\xb6\x7d\x89\x16\x59\x70\xe5\xfe\xf6\x00\x3f\x6a\x9b\x87\xf3\x39\xde\x26\x66\x30\x7b\x80\x8f\xba\xad\x85\xae\xbb\xfb\x1a\xdc\xd5\xf2\x16\xa2\x1b\x4b\xb7\xb0\xf1\x75\xf5\xee\x82\x96\x66\x39\x95\xf8\x61\xe1\xa6\xc8\xe7\x1a\x3f\x50\x14\xa2\x63\x63\x4d\xa4\x26\xbe\x71\xe3\x77\x61\xe4\x7e\xe5\x9f\x18\xb6\x1d\x54\x06\x5f\x77\xfb\x71\x11\x18\xf4\x8f\xab\xb8\x7f\x43\x5e\xdf\x9b\x09\x94\x56\xaa\x79\xcd\x9d\xa7\x68\xa5\xa1\x5a\x57\x62\x9e\x06\x3b\xc9\xb4\x81\x0f\x56\x2b\xff\xa0\x0e\x8d\x24\x94\xfe\x19\xac\x7f\x91\xce\x8f\x73\x95\x4c\xd0\xad\x21\x43\xc1\x2f\xe3\x9c\xe6\x4e\x3e\x2c\x51\x28\xa9\xe6\x59\x49\xd9\x0f\xe3\x63\xc3\x0e\xcd\x61\x0a\x25\x1a\x4a\x8b\xc6\xc2\x6a\xa1\x43\xd5\xc0\x95\x6b\x61\x90\x2c\x76\x10\x6e\xe9\xa4\x2d\x72\xb1\x06\xe9\xa8\x42\x09\x5c\xd5\xa3\x0b\xb7\xa2\xa2\x08\x06\xfe\x4d\x70\x68\x01\x6c\x42\x0e\x59\xdb\x51\xf7\xbf\x69\x36\xf3\xd3\xcf\xa8\x83\x2c\xd1\x2b\xe6\x25\x06\xdc\x90\x0c\x96\x45\x2a\x1c\x82\xc8\x5c\xc8\x3c\xfd\x2a\xbe\x1f\xe2\x8b\x0f\x91\x65\x98\x38\xeb\x9f\xed\x91\xf8\x8d\xd6\x8e\xb3\xb2\x2a\xef\xf2\x24\x54\xa4\x6d\xe9\x77\x93\xca\xb6\xa7\x44\x0d\x24\xd7\xef\xce\x4f\xcf\x5f\x79\x2c\x0d\x26\x6c\x29\x13\x99\x6e\x71\xd1\xcc\xb3\x1b\x3c\x57\xbc\x7c\x5b\x8e\x5b\x4e\xa4\xfe\xa4\xa5\x39\xb5\xf3\x94\x63\x4b\x18\x7b\x2e\x96\x2b\x81\xd2\x4c\x95\xa9\x71\xc6\x5c\x57\x17\xbe\x3b\xae\x7d\x7e\xfe\x1c\x12\x3b\x7e\x24\xa9\xc9\x8a\x63\x4c\xf5\xd9\x49\x85\x7c\xe8\xf4\x85\x5e\xa1\x39\x15\x16\xc3\x73\x03\x1f\xf0\x26\xac\x79\xc3\xf0\xbc\x7c\xe3\x77\xc2\x78\xb0\x60\x1a\x67\xe7\x31\xa9\xf5\xe7\x62\x50\xad\xe8\x99\x34\xa8\xe3\x69\x5b\xce\x78\xcc\x4e\x60\xbc\x3f\x08\x47\xe3\xd8\x17\x89\x77\x63\x7c\x1b\xc4\x9e\x94\x81\xe8\xe5\x11\x12\x57\x05\xb7\x9d\x45\xd4\x72\x90\xe6\x9a\x4d\xfa\xc0\x39\x8d\x97\x68\xcc\x68\xba\x4d\x3f\xec\x8f\xe0\x41\xaf\xbe\x55\x41\xd7\x5f\x47\x0f\x17\xc2\x5e\xae\xd4\x5b\xa3\x0b\x34\x6e\xdd\xab\x63\xab\xda\xb5\x8d\x2d\x82\xe6\xef\xa2\x7a\x5f\x5f\x76\xd3\xb8\xd4\x09\x33\xfe\x60\x8f\x76\xda\xea\xd5\x93\x66\x9f\x0c\xfc\x1b\xd7\x3e\xef\x68\xdd\xa6\xfe\x9e\xbb\xd9\x4f\xfe\xf2\xfa\x1d\x6e\xe3\x7e\xdc\x0d\xad\xd3\x5f\xb5\x14\x6a\x4b\x9a\xbd\xd7\xc7\x09\xa5\xbe\xfb\xfb\x0a\xd7\x4d\xec\x79\xee\x95\x4f\xf3\x0e\x22\x1e\x7b\x25\xa8\x8f\x5e\x44\x1e\x6e\xb7\x98\xf3\xe3\xef\x3f\xe2\xfa\x26\x94\xbb\x1c\xde\x2a\xfb\xaf\xf0\x28\xae\xc9\xff\x7f\x03\x1d\x83\xb5\x75\xea\x6b\xd3\xef\x37\x80\x37\x7b\x5b\xe6\x4d\xee\x76\xe0\xf6\xde\xb5\x3c\xc4\xc8\xee\x36\xbb\x9b\x34\x7d\x59\x6c\x67\xd9\xd8\x39\xa9\xb2\xb0\xad\xa6\xcd\xbe\xb4\x2e\x60\x3e\xa8\xdc\xca\xc1\x4d\x40\x65\x6b\xd5\x75\xb5\x57\x08\xe6\x54\xff\x7a\xc8\x9b\xa3\xee\xe3\x37\xab\x4e\x46\x1e\x8f\x8f\x40\xfe\xb3\xb1\x0d\xc8\x27\x4f\x1a\x2f\x4f\x16\x32\x4f\x4f\x7d\xab\x8e\x17\xbe\x97\x37\x9b\x57\x52\xaf\x30\xc7\xb9\x70\xc8\xf9\x4d\x49\xc9\x3c\x85\x19\xff\x9c\x88\x7b\x3b\x55\xf7\xc0\x53\xd7\xab\xd0\x3d\x14\x5a\x76\xd7\x34\xe2\x4b\xad\x97\x52\xad\x0c\x2f\x98\xf6\xdd\x6e\x6d\xaf\xf3\xa7\xc4\x1f\x47\xf5\x5e\xfb\x46\xb0\xe1\xd7\x30\xd1\x2a\x11\xae\xd7\xcc\xff\x2a\x7c\xfb\xf2\x9f\x08\xf6\x5e\xde\xf4\x6b\xaf\x02\x6a\x09\x65\xc0\x1f\x13\xc7\x7a\x62\xb3\x95\x63\x79\x2e\x02\xd8\xa7\x7a\x84\x0b\x86\x16\x2b\xf3\xf0\x8f\x59\xa3\xc1\x01\x6c\xfd\x1b\x8d\xe0\x9a\x2a\x1d\x13\x4e\x37\x54\xe6\x75\x38\x1e\xdc\x06\x1c\x8d\xe0\x37\x1a\x67\xb0\xaa\x4a\xaf\x83\xcd\x85\xdd\xd9\x8d\xc0\x7e\x16\xe1\x35\x9b\x92\x6e\x87\x46\x2e\xbb\x5b\xf6\x3a\x57\xd2\x6d\x12\xde\xda\x2b\x81\xf0\x77\x50\xbf\xf2\xcb\xde\xfd\x49\x00\x23\x39\x65\x81\xc2\x34\x24\x3b\xf7\x8d\x14\xe0\x53\xe4\xc4\xb7\x0f\xa0\xde\xfc\x1c\x44\xc2\x49\x9f\x53\xbf\xb1\x4e\x83\xa0\x6a\x77\x81\x03\x4f\xec\x69\xa4\x4e\xc4\x5c\x21\xd0\xa5\x07\x1b\x8e\x4e\xac\x95\x73\x85\x69\x7c\x04\x51\xd3\x07\x7f\xfa\x55\xf2\xf6\xd7\xcf\x7e\xef\xb1\x37\x4f\xbd\x6a\xd5\xec\xd0\xd9\x80\xb8\xc2\x44\x16\x32\x9a\x6e\x4d\x55\xf6\x6a\xc9\x68\x04\xd3\xf0\x77\x46\x98\xb6\xeb\xcb\x5e\x55\x69\x68\x4a\x68\xcf\x3c\xa0\x24\xac\x23\x54\xc7\x85\x52\xde\x27\x9b\x53\xdf\xb7\xda\xab\x15\xe1\xef\x50\xd9\xa7\xe8\xcd\x0d\xfb\x17\xb5\xe3\x0b\xca\x51\x75\x8c\x76\x75\xe3\xd2\x57\x9b\xb3\xb5\xc3\x9d\x23\x6f\x14\x01\x5f\x79\xea\x1b\x55\x6b\x39\x7a\xff\x76\x35\x6a\x59\xc7\x60\x56\xaa\xf4\xa4\x5d\x39\xf9\xa0\x69\xbe\xae\x98\x9d\xf0\xa7\x63\x4d\xf4\xf1\xc8\x47\x23\x08\xaf\xf5\x77\x05\xa7\x4a\x16\x27\xb1\xd8\xbd\xef\xfe\x4f\x00\x00\x00\xff\xff\xa0\xf8\xce\x6f\x67\x3d\x00\x00")
+
+func call_tracer_parityJsBytes() ([]byte, error) {
+	return bindataRead(
+		_call_tracer_parityJs,
+		"call_tracer_parity.js",
+	)
+}
+
+func call_tracer_parityJs() (*asset, error) {
+	bytes, err := call_tracer_parityJsBytes()
+	if err != nil {
+		return nil, err
+	}
+
+	info := bindataFileInfo{name: "call_tracer_parity.js", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)}
+	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
 
@@ -153,7 +182,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{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}}
+	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
 
@@ -173,7 +202,7 @@ func noop_tracerJs() (*asset, error) {
 	}
 
 	info := bindataFileInfo{name: "noop_tracer.js", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)}
-	a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xe3, 0xf, 0x1c, 0x6f, 0x65, 0xaf, 0x90, 0x31, 0xab, 0xf, 0xe0, 0xca, 0x54, 0x7, 0xfd, 0xd3, 0xa1, 0x4a, 0x14, 0x1, 0x2a, 0x9d, 0xdc, 0xb9, 0x64, 0x69, 0x83, 0x30, 0xb1, 0x2a, 0xbd, 0xfb}}
+	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
 
@@ -193,11 +222,11 @@ func opcount_tracerJs() (*asset, error) {
 	}
 
 	info := bindataFileInfo{name: "opcount_tracer.js", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)}
-	a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x27, 0xe, 0x97, 0x88, 0x9b, 0x53, 0xbb, 0x20, 0x44, 0xd8, 0xf5, 0xeb, 0x41, 0xd2, 0x7e, 0xd6, 0xda, 0x6b, 0xf5, 0xaf, 0x0, 0x75, 0x9f, 0xd9, 0x22, 0xc, 0x6e, 0x74, 0xac, 0x2a, 0xa9, 0xa7}}
+	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
 
-var _prestate_tracerJs = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x9c\x57\xdd\x6f\xdb\x38\x12\x7f\x96\xfe\x8a\x41\x5f\x6c\xa3\xae\xdc\x64\x81\x3d\xc0\xb9\x1c\xa0\xba\x6e\x1b\x20\x9b\x04\xb6\x7b\xb9\xdc\x62\x1f\x28\x72\x24\x73\x4d\x93\x02\x49\xd9\xf1\x15\xf9\xdf\x0f\x43\x7d\xf8\xa3\x49\xd3\xdd\x37\x9b\x1c\xfe\xe6\xfb\x37\xa3\xd1\x08\x26\xa6\xdc\x59\x59\x2c\x3d\x9c\xbf\x3f\xfb\x07\x2c\x96\x08\x85\x79\x87\x7e\x89\x16\xab\x35\xa4\x95\x5f\x1a\xeb\xe2\xd1\x08\x16\x4b\xe9\x20\x97\x0a\x41\x3a\x28\x99\xf5\x60\x72\xf0\x27\xf2\x4a\x66\x96\xd9\x5d\x12\x8f\x46\xf5\x9b\x67\xaf\x09\x21\xb7\x88\xe0\x4c\xee\xb7\xcc\xe2\x18\x76\xa6\x02\xce\x34\x58\x14\xd2\x79\x2b\xb3\xca\x23\x48\x0f\x4c\x8b\x91\xb1\xb0\x36\x42\xe6\x3b\x82\x94\x1e\x2a\x2d\xd0\x06\xd5\x1e\xed\xda\xb5\x76\x7c\xbe\xf9\x0a\xd7\xe8\x1c\x5a\xf8\x8c\x1a\x2d\x53\x70\x57\x65\x4a\x72\xb8\x96\x1c\xb5\x43\x60\x0e\x4a\x3a\x71\x4b\x14\x90\x05\x38\x7a\xf8\x89\x4c\x99\x37\xa6\xc0\x27\x53\x69\xc1\xbc\x34\x7a\x08\x28\xc9\x72\xd8\xa0\x75\xd2\x68\xf8\xa5\x55\xd5\x00\x0e\xc1\x58\x02\xe9\x33\x4f\x0e\x58\x30\x25\xbd\x1b\x00\xd3\x3b\x50\xcc\xef\x9f\xfe\x44\x40\xf6\x7e\x0b\x90\x3a\xa8\x59\x9a\x12\xc1\x2f\x99\x27\xaf\xb7\x52\x29\xc8\x10\x2a\x87\x79\xa5\x86\x84\x96\x55\x1e\xee\xaf\x16\x5f\x6e\xbf\x2e\x20\xbd\x79\x80\xfb\x74\x36\x4b\x6f\x16\x0f\x17\xb0\x95\x7e\x69\x2a\x0f\xb8\xc1\x1a\x4a\xae\x4b\x25\x51\xc0\x96\x59\xcb\xb4\xdf\x81\xc9\x09\xe1\xb7\xe9\x6c\xf2\x25\xbd\x59\xa4\x1f\xae\xae\xaf\x16\x0f\x60\x2c\x7c\xba\x5a\xdc\x4c\xe7\x73\xf8\x74\x3b\x83\x14\xee\xd2\xd9\xe2\x6a\xf2\xf5\x3a\x9d\xc1\xdd\xd7\xd9\xdd\xed\x7c\x9a\xc0\x1c\xc9\x2a\xa4\xf7\xaf\xc7\x3c\x0f\xd9\xb3\x08\x02\x3d\x93\xca\xb5\x91\x78\x30\x15\xb8\xa5\xa9\x94\x80\x25\xdb\x20\x58\xe4\x28\x37\x28\x80\x01\x37\xe5\xee\xa7\x93\x4a\x58\x4c\x19\x5d\x04\x9f\x5f\x2c\x48\xb8\xca\x41\x1b\x3f\x04\x87\x08\xff\x5c\x7a\x5f\x8e\x47\xa3\xed\x76\x9b\x14\xba\x4a\x8c\x2d\x46\xaa\x86\x73\xa3\x7f\x25\x31\x61\x96\x16\x9d\x67\x1e\x17\x96\x71\xb4\x60\x2a\x5f\x56\xde\x81\xab\xf2\x5c\x72\x89\xda\x83\xd4\xb9\xb1\xeb\x50\x29\xe0\x0d\x70\x8b\xcc\x23\x30\x50\x86\x33\x05\xf8\x88\xbc\x0a\x77\x75\xa4\x43\xb9\x5a\xa6\x1d\xe3\xe1\x34\xb7\x66\x4d\xbe\x56\xce\xd3\x0f\xe7\x70\x9d\x29\x14\x50\xa0\x46\x27\x1d\x64\xca\xf0\x55\x12\x7f\x8b\xa3\x03\x63\xa8\x4e\x82\x87\x8d\x50\xa8\x8d\x2d\xf6\x2c\x42\x56\x49\x25\xa4\x2e\x92\x38\x6a\xa5\xc7\xa0\x2b\xa5\x86\x71\x80\x50\xc6\xac\xaa\x32\xe5\xdc\x54\xc1\xf6\x3f\x91\xfb\x1a\xcc\x95\xc8\x65\x4e\xc5\xc1\xba\x5b\x6f\xc2\x55\xa7\xd7\x64\x24\x9f\xc4\xd1\x11\xcc\x18\xf2\x4a\x07\x77\xfa\x4c\x08\x3b\x04\x91\x0d\xbe\xc5\x51\xb4\x61\x96\xb0\xe0\x12\xbc\xf9\x82\x8f\xe1\x72\x70\x11\x47\x91\xcc\xa1\xef\x97\xd2\x25\x2d\xf0\xef\x8c\xf3\x3f\xe0\xf2\xf2\x32\x34\x75\x2e\x35\x8a\x01\x10\x44\xf4\x9c\x58\x7d\x13\x65\x4c\x31\xcd\x71\x0c\xbd\xf7\x8f\x3d\x78\x0b\x22\x4b\x0a\xf4\x1f\xea\xd3\x5a\x59\xe2\xcd\xdc\x5b\xa9\x8b\xfe\xd9\xaf\x83\x61\x78\xa5\x4d\x78\x03\x8d\xf8\x8d\xe9\x84\xeb\x7b\x6e\x44\xb8\x6e\x6c\xae\xa5\x26\x46\x34\x42\x8d\x94\xf3\xc6\xb2\x02\xc7\xf0\xed\x89\xfe\x3f\x91\x57\x4f\x71\xf4\x74\x14\xe5\x79\x2d\xf4\x42\x94\x1b\x08\x40\xed\x6d\x57\xe7\x85\xa4\x4e\x3d\x4c\x40\xc0\xfb\x51\x12\xe6\xad\x29\x27\x49\x58\xe1\xee\xf5\x4c\xd0\x85\x14\x8f\xdd\xc5\x0a\x77\x83\x8b\xf8\xc5\x14\x25\x8d\xd1\xbf\x4b\xf1\xf8\xb3\xf9\x3a\x79\x73\x14\xd7\x39\x49\xed\xed\x1d\x0c\x4e\xe2\x68\xd1\x55\xca\x53\xb9\x4b\xbd\x31\x2b\x22\xae\x25\xc5\x47\xa9\x10\x12\x53\x52\xb6\x5c\xcd\x1c\x19\xa2\x06\xe9\xd1\x32\xa2\x4e\xb3\x41\x4b\x53\x03\x2c\xfa\xca\x6a\xd7\x85\x31\x97\x9a\xa9\x16\xb8\x89\xba\xb7\x8c\xd7\x3d\x53\x9f\x1f\xc4\x92\xfb\xc7\x10\xc5\xe0\xdd\x68\x04\xa9\x07\x72\x11\x4a\x23\xb5\x1f\xc2\x16\x41\x23\x0a\x6a\x7c\x81\xa2\xe2\x3e\xe0\xf5\x36\x4c\x55\xd8\xab\x9b\x9b\x28\x32\x3c\x35\x15\x4d\x82\x83\xe6\x1f\x06\x03\xd7\x66\x13\x46\x5c\xc6\xf8\x0a\x9a\x86\x33\x56\x16\x52\xc7\x4d\x38\x8f\x9a\x8d\x2c\x4a\x08\x38\x98\x15\x72\x45\x49\xa4\x93\x0f\x4c\xc1\x25\x64\xb2\xb8\xd2\xfe\x24\x79\x75\xd0\xdb\xa7\x83\x3f\x92\xa6\x79\x12\x47\x84\xd7\x3f\x1f\x0c\xe1\xec\xd7\xae\x22\xbc\x21\x28\x78\x1d\xcc\x9b\x97\xa1\xe2\xd3\x62\x78\xfe\x59\x50\x43\x1d\xfc\x36\x68\x4d\x5c\x95\x51\x3a\x6a\x3f\x43\x1c\x8f\xbb\xf8\xe2\x07\xb8\xc7\xbe\xb5\xb8\x4d\x68\x12\x26\xc4\xcb\xa0\x75\x8a\x3e\x22\xb7\xb8\x26\x56\xa7\x2c\x70\xa6\x14\xda\x9e\x83\xc0\x19\xc3\xa6\x9c\x42\xbe\x70\x5d\xfa\x5d\xcb\xf5\x9e\xd9\x02\xbd\x7b\xdd\xb0\x80\xf3\xee\x5d\x4b\x81\x21\x14\xbb\x12\xe1\xf2\x12\x7a\x93\xd9\x34\x5d\x4c\x7b\x4d\x1b\x8d\x46\x70\x8f\x61\x13\xca\x94\xcc\x84\xda\x81\x40\x85\x1e\x6b\xbb\x8c\x0e\x21\xea\x28\x61\x48\x2b\x0d\x2d\x1b\xf8\x28\x9d\x97\xba\x80\x9a\x29\xb6\x34\x57\x1b\xb8\xd0\x23\x9c\x55\x8e\xaa\xf5\x64\x08\x79\x43\x1b\x85\x45\xe2\x15\xe2\xff\xd0\x6e\x4c\xc9\x6e\x03\xc9\xa5\x75\x1e\x4a\xc5\x38\x26\x84\xd7\x19\xf3\x72\x7e\x9b\x4e\x26\xd5\xb3\xd0\x82\x01\x68\x3f\xe0\x98\xa2\x01\x49\xea\x1d\xf4\x5b\x8c\x41\x1c\x45\xb6\x95\x3e\xc0\xbe\xd8\x53\x82\xf3\x58\x1e\x12\x02\x2d\x16\xb8\x41\xa2\xd0\xc0\x06\xf5\x30\x24\x5d\xff\xfe\xad\x99\xbe\xe8\x92\x38\xa2\x77\x07\x7d\xad\x4c\x71\xdc\xd7\xa2\x0e\x0b\xaf\xac\xa5\xfc\x77\x14\x9c\x53\x8f\xff\x59\x39\x4f\x31\xb5\x14\x9e\x86\x2d\x9e\x23\xc9\x40\x89\x34\x6d\x07\xdf\x93\x21\xcd\xad\x30\x27\x48\x5d\x33\xa5\xea\x6d\xae\x34\x1e\xb5\x97\x4c\xa9\x1d\xe5\x61\x6b\x69\x8d\xa1\xc5\x65\x08\x4e\x92\x54\x60\x9c\x20\x2a\x35\x57\x95\xa8\xcb\x20\xd4\x71\x83\xe7\x82\xcd\xc7\xfb\xcf\x1a\x9d\x63\x05\x26\x54\x49\xb9\x7c\x6c\x36\x48\x0d\xbd\x9a\xe4\xfa\x83\x5e\xd2\x19\x79\x4c\x31\xca\x14\x49\x5b\x64\x44\xd3\xa9\x10\x16\x9d\xeb\x0f\x1a\xce\xe9\x32\x7b\xbf\x44\x4d\xc1\x07\x8d\x5b\xe8\x56\x13\xc6\x39\xad\x6a\x62\x08\x4c\x08\xa2\xb6\x93\x35\x22\x8e\x22\xb7\x95\x9e\x2f\x21\x68\x32\xe5\xbe\x17\x07\x4d\xfd\x73\xe6\x10\xde\x4c\xff\xb3\x98\xdc\x7e\x9c\x4e\x6e\xef\x1e\xde\x8c\xe1\xe8\x6c\x7e\xf5\xdf\x69\x77\xf6\x21\xbd\x4e\x6f\x26\xd3\x37\xe3\x30\x9b\x9f\x71\xc8\x9b\xd6\x05\x52\xe8\x3c\xe3\xab\xa4\x44\x5c\xf5\xdf\x1f\xf3\xc0\xde\xc1\x28\xca\x2c\xb2\xd5\xc5\xde\x98\xba\x41\x1b\x1d\x2d\xe5\xc2\x25\xbc\x18\xac\x8b\x97\xad\x99\x34\xf2\xfd\x96\xc8\xf7\xab\x48\xa0\x8a\xd7\xed\x38\xff\xcb\x86\x84\xde\x61\x7c\x35\x06\xc7\x14\x6d\xc0\xf2\x7f\xf4\xe5\x92\xe7\x0e\xfd\x10\x50\x0b\xb3\x25\xe6\xeb\x50\xeb\x9b\x06\xf7\x20\x64\x67\x83\x9a\x41\x6f\xf3\xfe\xa0\x13\x26\xb0\xef\x45\xcf\x9f\x13\x45\x2d\xe0\xb2\x45\x7f\x1b\x5e\xbe\x1e\xa8\xf3\x26\x52\x27\x0a\x7e\x39\xd9\xf0\xc2\xfd\x1a\xd7\xc6\xee\x9a\x71\x74\xe0\xdf\x8f\xa3\x9a\x5e\x5f\x77\xf5\x44\x7f\xa8\xc8\xba\x83\x8f\xd3\xeb\xe9\xe7\x74\x31\x3d\x92\x9a\x2f\xd2\xc5\xd5\xa4\x3e\xfa\xcb\x85\x77\xf6\xd3\x85\xd7\x9b\xcf\x17\xb7\xb3\x69\x6f\xdc\xfc\xbb\xbe\x4d\x3f\xf6\xbe\x53\xd8\x6c\x81\x3f\x6a\x5d\x6f\xee\x8d\x15\x7f\xa7\x03\x0e\x36\xb2\x9c\x3d\xb7\x90\x05\x6a\xe7\xbe\x3a\xf9\xe0\x01\xa6\x5b\x56\xce\xeb\x8f\xbe\x28\xbc\x7f\x96\x87\x9f\xe2\xa7\xf8\xff\x01\x00\x00\xff\xff\xb1\x28\x85\x2a\x8a\x10\x00\x00")
+var _prestate_tracerJs = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x9c\x57\xdd\x6f\xdb\x38\x12\x7f\x96\xfe\x8a\x41\x5f\x6c\xa3\xae\xdc\x64\x81\x3d\xc0\xb9\x1c\xa0\xba\x6e\x1b\x20\x9b\x04\xb6\x7b\xb9\xdc\x62\x1f\x28\x72\x24\x73\x4d\x93\x02\x49\xd9\xf1\x15\xf9\xdf\x0f\x43\x7d\xf8\xa3\x49\xd3\xdd\x37\x9b\x1c\xfe\xe6\xfb\x37\xa3\xd1\x08\x26\xa6\xdc\x59\x59\x2c\x3d\x9c\xbf\x3f\xfb\x07\x2c\x96\x08\x85\x79\x87\x7e\x89\x16\xab\x35\xa4\x95\x5f\x1a\xeb\xe2\xd1\x08\x16\x4b\xe9\x20\x97\x0a\x41\x3a\x28\x99\xf5\x60\x72\xf0\x27\xf2\x4a\x66\x96\xd9\x5d\x12\x8f\x46\xf5\x9b\x67\xaf\x09\x21\xb7\x88\xe0\x4c\xee\xb7\xcc\xe2\x18\x76\xa6\x02\xce\x34\x58\x14\xd2\x79\x2b\xb3\xca\x23\x48\x0f\x4c\x8b\x91\xb1\xb0\x36\x42\xe6\x3b\x82\x94\x1e\x2a\x2d\xd0\x06\xd5\x1e\xed\xda\xb5\x76\x7c\xbe\xf9\x0a\xd7\xe8\x1c\x5a\xf8\x8c\x1a\x2d\x53\x70\x57\x65\x4a\x72\xb8\x96\x1c\xb5\x43\x60\x0e\x4a\x3a\x71\x4b\x14\x90\x05\x38\x7a\xf8\x89\x4c\x99\x37\xa6\xc0\x27\x53\x69\xc1\xbc\x34\x7a\x08\x28\xc9\x72\xd8\xa0\x75\xd2\x68\xf8\xa5\x55\xd5\x00\x0e\xc1\x58\x02\xe9\x33\x4f\x0e\x58\x30\x25\xbd\x1b\x00\xd3\x3b\x50\xcc\xef\x9f\xfe\x44\x40\xf6\x7e\x0b\x90\x3a\xa8\x59\x9a\x12\xc1\x2f\x99\x27\xaf\xb7\x52\x29\xc8\x10\x2a\x87\x79\xa5\x86\x84\x96\x55\x1e\xee\xaf\x16\x5f\x6e\xbf\x2e\x20\xbd\x79\x80\xfb\x74\x36\x4b\x6f\x16\x0f\x17\xb0\x95\x7e\x69\x2a\x0f\xb8\xc1\x1a\x4a\xae\x4b\x25\x51\xc0\x96\x59\xcb\xb4\xdf\x81\xc9\x09\xe1\xb7\xe9\x6c\xf2\x25\xbd\x59\xa4\x1f\xae\xae\xaf\x16\x0f\x60\x2c\x7c\xba\x5a\xdc\x4c\xe7\x73\xf8\x74\x3b\x83\x14\xee\xd2\xd9\xe2\x6a\xf2\xf5\x3a\x9d\xc1\xdd\xd7\xd9\xdd\xed\x7c\x9a\xc0\x1c\xc9\x2a\xa4\xf7\xaf\xc7\x3c\x0f\xd9\xb3\x08\x02\x3d\x93\xca\xb5\x91\x78\x30\x15\xb8\xa5\xa9\x94\x80\x25\xdb\x20\x58\xe4\x28\x37\x28\x80\x01\x37\xe5\xee\xa7\x93\x4a\x58\x4c\x19\x5d\x04\x9f\x5f\x2c\x48\xb8\xca\x41\x1b\x3f\x04\x87\x08\xff\x5c\x7a\x5f\x8e\x47\xa3\xed\x76\x9b\x14\xba\x4a\x8c\x2d\x46\xaa\x86\x73\xa3\x7f\x25\x31\x61\x96\x16\x9d\x67\x1e\x17\x96\x71\xb4\x60\x2a\x5f\x56\xde\x81\xab\xf2\x5c\x72\x89\xda\x83\xd4\xb9\xb1\xeb\x50\x29\xe0\x0d\x70\x8b\xcc\x23\x30\x50\x86\x33\x05\xf8\x88\xbc\x0a\x77\x75\xa4\x43\xb9\x5a\xa6\x1d\xe3\xe1\x34\xb7\x66\x4d\xbe\x56\xce\xd3\x0f\xe7\x70\x9d\x29\x14\x50\xa0\x46\x27\xdd\x02\x32\x65\xf8\x2a\x89\xbf\xc5\xd1\x81\x35\x54\x28\xc1\xc5\x56\x2a\x54\xc7\x16\x7b\x16\x21\xab\xa4\x12\x52\x17\x49\x1c\xb5\xe2\x63\xd0\x95\x52\xc3\x38\x60\x28\x63\x56\x55\x99\x72\x6e\xaa\x60\xfd\x9f\xc8\x7d\x8d\xe6\x4a\xe4\x32\xa7\xf2\x60\xdd\xad\x37\xe1\xaa\x53\x6c\x32\x92\x4f\xe2\xe8\x08\x66\x0c\x79\xa5\x83\x43\x7d\x26\x84\x1d\x82\xc8\x06\xdf\xe2\x28\xda\x30\x4b\x58\x70\x09\xde\x7c\xc1\xc7\x70\x39\xb8\x88\xa3\x48\xe6\xd0\xf7\x4b\xe9\x92\x16\xf8\x77\xc6\xf9\x1f\x70\x79\x79\x19\xda\x3a\x97\x1a\xc5\x00\x08\x22\x7a\x4e\xac\xbe\x89\x32\xa6\x98\xe6\x38\x86\xde\xfb\xc7\x1e\xbc\x05\x91\x25\x05\xfa\x0f\xf5\x69\xad\x2c\xf1\x66\xee\xad\xd4\x45\xff\xec\xd7\xc1\x30\xbc\xd2\x26\xbc\x81\x46\xfc\xc6\x74\xc2\xf5\x3d\x37\x22\x5c\x37\x36\xd7\x52\x13\x23\x1a\xa1\x46\xca\x79\x63\x59\x81\x63\xf8\xf6\x44\xff\x9f\xc8\xab\xa7\x38\x7a\x3a\x8a\xf2\xbc\x16\x7a\x21\xca\x0d\x04\xa0\xf6\xb6\xab\xf4\x42\x52\xaf\x1e\x26\x20\xe0\xfd\x28\x09\xf3\xd6\x94\x93\x24\xac\x70\xf7\x7a\x26\xe8\x42\x8a\xc7\xee\x62\x85\xbb\xc1\x45\xfc\x62\x8a\x92\xc6\xe8\xdf\xa5\x78\xfc\xd9\x7c\x9d\xbc\x39\x8a\xeb\x9c\xa4\xf6\xf6\x0e\x06\x27\x71\xb4\xe8\x2a\xe5\xa9\xde\xa5\xde\x98\x15\x51\xd7\x92\xe2\xa3\x54\x08\x89\x29\x29\x5b\xae\xe6\x8e\x0c\x51\x83\xf4\x68\x19\x91\xa7\xd9\xa0\xa5\xb9\x01\x16\x7d\x65\xb5\xeb\xc2\x98\x4b\xcd\x54\x0b\xdc\x44\xdd\x5b\xc6\xeb\x9e\xa9\xcf\x0f\x62\xc9\xfd\x63\x88\x62\xf0\x6e\x34\x82\xd4\x03\xb9\x08\xa5\x91\xda\x0f\x61\x8b\xa0\x11\x05\xb5\xbe\x40\x51\x71\x1f\xf0\x7a\x1b\xa6\x2a\xec\xd5\xed\x4d\x24\x19\x9e\x9a\x8a\x66\xc1\x41\xfb\x0f\x83\x81\x6b\xb3\x09\x43\x2e\x63\x7c\x05\x4d\xc3\x19\x2b\x0b\xa9\xe3\x26\x9c\x47\xcd\x46\x16\x25\x04\x1c\xcc\x0a\xb9\xa2\x24\xd2\xc9\x07\xa6\xe0\x12\x32\x59\x5c\x69\x7f\x92\xbc\x3a\xe8\xed\xd3\xc1\x1f\x49\xd3\x3c\x89\x23\xca\xeb\x9f\x0f\x86\x70\xf6\x6b\x57\x11\xde\x10\x14\xbc\x0e\xe6\xcd\xcb\x50\xf1\x69\x31\x3c\xff\x2c\xa8\xa1\x0e\x7e\x1b\xb4\x26\xae\xca\x28\x1d\xb5\x9f\x21\x8e\xc7\x5d\x7c\xf1\x03\xdc\x63\xdf\x5a\xdc\x26\x34\x09\x13\xe2\x65\xd0\x3a\x45\x1f\x91\x5b\x5c\x13\xaf\x53\x16\x38\x53\x0a\x6d\xcf\x41\xe0\x8c\x61\x53\x4e\x21\x5f\xb8\x2e\xfd\xae\x65\x7b\xcf\x6c\x81\xde\xbd\x6e\x58\xc0\x79\xf7\xae\xa5\xc0\x10\x8a\x5d\x89\x70\x79\x09\xbd\xc9\x6c\x9a\x2e\xa6\xbd\xa6\x8d\x46\x23\xb8\xc7\xb0\x0b\x65\x4a\x66\x42\xed\x40\xa0\x42\x8f\xb5\x5d\x46\x87\x10\x75\x94\x30\xa4\xa5\x86\xd6\x0d\x7c\x94\xce\x4b\x5d\x40\xcd\x14\x5b\x9a\xac\x0d\x5c\xe8\x11\xce\x2a\x47\xd5\x7a\x32\x86\xbc\xa1\x9d\xc2\x22\xf1\x0a\xf1\x7f\x68\x37\xa6\x64\xb7\x83\xe4\xd2\x3a\x0f\xa5\x62\x1c\x13\xc2\xeb\x8c\x79\x39\xbf\x4d\x27\x93\xea\x59\x68\xc1\x00\xb4\x1f\x71\x4c\xd1\x88\x24\xf5\x0e\xfa\x2d\xc6\x20\x8e\x22\xdb\x4a\x1f\x60\x5f\xec\x29\xc1\x79\x2c\x0f\x09\x81\x56\x0b\xdc\x20\x51\x68\x60\x83\x7a\x18\x92\xae\x7f\xff\xd6\xcc\x5f\x74\x49\x1c\xd1\xbb\x83\xbe\x56\xa6\x38\xee\x6b\x51\x87\x85\x57\xd6\x52\xfe\x3b\x0a\xce\xa9\xc7\xff\xac\x9c\xa7\x98\x5a\x0a\x4f\xc3\x16\xcf\x91\x64\xa0\x44\x9a\xb6\x83\xef\xc9\x90\xe6\x56\x98\x13\xa4\xae\x99\x52\xf5\x3e\x57\x1a\x8f\xda\x4b\xa6\xd4\x8e\xf2\xb0\xb5\xb4\xc8\xd0\xea\x32\x04\x27\x49\x2a\x30\x4e\x10\x95\x9a\xab\x4a\xd4\x65\x10\xea\xb8\xc1\x73\xc1\xe6\xe3\x0d\x68\x8d\xce\xb1\x02\x13\xaa\xa4\x5c\x3e\x36\x3b\xa4\x86\x5e\x4d\x72\xfd\x41\x2f\xe9\x8c\x3c\xa6\x18\x65\x8a\xa4\x2d\x32\xa2\xe9\x54\x08\x8b\xce\xf5\x07\x0d\xe7\x74\x99\xbd\x5f\xa2\xa6\xe0\x83\xc6\x2d\x74\xbb\x09\xe3\x9c\x96\x35\x31\x04\x26\x04\x51\xdb\xc9\x1a\x11\x47\x91\xdb\x4a\xcf\x97\x10\x34\x99\x72\xdf\x8b\x83\xa6\xfe\x39\x73\x08\x6f\xa6\xff\x59\x4c\x6e\x3f\x4e\x27\xb7\x77\x0f\x6f\xc6\x70\x74\x36\xbf\xfa\xef\xb4\x3b\xfb\x90\x5e\xa7\x37\x93\xe9\x9b\x71\x98\xcd\xcf\x38\xe4\x4d\xeb\x02\x29\x74\x9e\xf1\x55\x52\x22\xae\xfa\xef\x8f\x79\x60\xef\x60\x14\x65\x16\xd9\xea\x62\x6f\x4c\xdd\xa0\x8d\x8e\x96\x72\xe1\x12\x5e\x0c\xd6\xc5\xcb\xd6\x4c\x1a\xf9\x7e\x4b\xe4\xfb\x55\x24\x50\xc5\xeb\x76\x9c\xff\x65\x43\x42\xef\x30\xbe\x1a\x83\x63\x8a\x76\x60\xf9\x3f\xfa\x76\xc9\x73\x87\x7e\x08\xa8\x85\xd9\x12\xf3\x75\xa8\xf5\x4d\x83\x7b\x10\xb2\xb3\x41\xcd\xa0\xb7\x79\x7f\xd0\x09\x13\xd8\xf7\xa2\xe7\xcf\x89\xa2\x16\x70\xd9\xa2\xbf\x0d\x2f\x5f\x0f\xd4\x79\x13\xa9\x13\x05\xbf\x9c\x6c\x78\xe1\x7e\x8d\x6b\x63\x77\xcd\x38\x3a\xf0\xef\xc7\x51\x4d\xaf\xaf\xbb\x7a\xa2\x3f\x54\x64\xdd\xc1\xc7\xe9\xf5\xf4\x73\xba\x98\x1e\x49\xcd\x17\xe9\xe2\x6a\x52\x1f\xfd\xe5\xc2\x3b\xfb\xe9\xc2\xeb\xcd\xe7\x8b\xdb\xd9\xb4\x37\x6e\xfe\x5d\xdf\xa6\x1f\x7b\xdf\x29\x6c\xb6\xc0\x1f\xb5\xae\x37\xf7\xc6\x8a\xbf\xd3\x01\x07\x1b\x59\xce\x9e\x5b\xc8\x02\xb5\x73\x5f\x9d\x7c\xf2\x00\xd3\x2d\x2b\xe7\xf5\x67\x5f\x14\xde\x3f\xcb\xc3\x4f\xf1\x53\xfc\xff\x00\x00\x00\xff\xff\x06\x73\xb8\x1e\x8c\x10\x00\x00")
 
 func prestate_tracerJsBytes() ([]byte, error) {
 	return bindataRead(
@@ -213,7 +242,7 @@ func prestate_tracerJs() (*asset, error) {
 	}
 
 	info := bindataFileInfo{name: "prestate_tracer.js", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)}
-	a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xe9, 0x79, 0x70, 0x4f, 0xc5, 0x78, 0x57, 0x63, 0x6f, 0x5, 0x31, 0xce, 0x3e, 0x5d, 0xbd, 0x71, 0x4, 0x46, 0x78, 0xcd, 0x1d, 0xcd, 0xb9, 0xd8, 0x10, 0xff, 0xe6, 0xc5, 0x59, 0xb9, 0x25, 0x6e}}
+	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
 
@@ -233,7 +262,7 @@ func trigram_tracerJs() (*asset, error) {
 	}
 
 	info := bindataFileInfo{name: "trigram_tracer.js", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)}
-	a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x40, 0x63, 0xe1, 0x42, 0x60, 0x7, 0x1b, 0x79, 0x47, 0x1, 0xa1, 0xbf, 0xc4, 0x66, 0x19, 0x9b, 0x2b, 0x5a, 0x1f, 0x82, 0x3d, 0xcf, 0xee, 0xe7, 0x60, 0x25, 0x2c, 0x4f, 0x13, 0x97, 0xc7, 0x18}}
+	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
 
@@ -253,7 +282,7 @@ func unigram_tracerJs() (*asset, error) {
 	}
 
 	info := bindataFileInfo{name: "unigram_tracer.js", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)}
-	a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x2f, 0x36, 0x14, 0xc2, 0xf6, 0xc3, 0x80, 0x2b, 0x4a, 0x11, 0x7d, 0xd5, 0x3e, 0xef, 0x23, 0xb5, 0xd6, 0xe6, 0xe6, 0x5, 0x41, 0xf6, 0x14, 0x7a, 0x39, 0xf7, 0xf8, 0xac, 0x89, 0x8e, 0x43, 0xe6}}
+	a := &asset{bytes: bytes, info: info}
 	return a, nil
 }
 
@@ -261,8 +290,8 @@ func unigram_tracerJs() (*asset, error) {
 // It returns an error if the asset could not be found or
 // could not be loaded.
 func Asset(name string) ([]byte, error) {
-	canonicalName := strings.Replace(name, "\\", "/", -1)
-	if f, ok := _bindata[canonicalName]; ok {
+	cannonicalName := strings.Replace(name, "\\", "/", -1)
+	if f, ok := _bindata[cannonicalName]; ok {
 		a, err := f()
 		if err != nil {
 			return nil, fmt.Errorf("Asset %s can't read by error: %v", name, err)
@@ -272,12 +301,6 @@ func Asset(name string) ([]byte, error) {
 	return nil, fmt.Errorf("Asset %s not found", name)
 }
 
-// AssetString returns the asset contents as a string (instead of a []byte).
-func AssetString(name string) (string, error) {
-	data, err := Asset(name)
-	return string(data), err
-}
-
 // MustAsset is like Asset but panics when Asset would return an error.
 // It simplifies safe initialization of global variables.
 func MustAsset(name string) []byte {
@@ -289,18 +312,12 @@ func MustAsset(name string) []byte {
 	return a
 }
 
-// MustAssetString is like AssetString but panics when Asset would return an
-// error. It simplifies safe initialization of global variables.
-func MustAssetString(name string) string {
-	return string(MustAsset(name))
-}
-
 // AssetInfo loads and returns the asset info for the given name.
 // It returns an error if the asset could not be found or
 // could not be loaded.
 func AssetInfo(name string) (os.FileInfo, error) {
-	canonicalName := strings.Replace(name, "\\", "/", -1)
-	if f, ok := _bindata[canonicalName]; ok {
+	cannonicalName := strings.Replace(name, "\\", "/", -1)
+	if f, ok := _bindata[cannonicalName]; ok {
 		a, err := f()
 		if err != nil {
 			return nil, fmt.Errorf("AssetInfo %s can't read by error: %v", name, err)
@@ -310,33 +327,6 @@ func AssetInfo(name string) (os.FileInfo, error) {
 	return nil, fmt.Errorf("AssetInfo %s not found", name)
 }
 
-// AssetDigest returns the digest of the file with the given name. It returns an
-// error if the asset could not be found or the digest could not be loaded.
-func AssetDigest(name string) ([sha256.Size]byte, error) {
-	canonicalName := strings.Replace(name, "\\", "/", -1)
-	if f, ok := _bindata[canonicalName]; ok {
-		a, err := f()
-		if err != nil {
-			return [sha256.Size]byte{}, fmt.Errorf("AssetDigest %s can't read by error: %v", name, err)
-		}
-		return a.digest, nil
-	}
-	return [sha256.Size]byte{}, fmt.Errorf("AssetDigest %s not found", name)
-}
-
-// Digests returns a map of all known files and their checksums.
-func Digests() (map[string][sha256.Size]byte, error) {
-	mp := make(map[string][sha256.Size]byte, len(_bindata))
-	for name := range _bindata {
-		a, err := _bindata[name]()
-		if err != nil {
-			return nil, err
-		}
-		mp[name] = a.digest
-	}
-	return mp, nil
-}
-
 // AssetNames returns the names of the assets.
 func AssetNames() []string {
 	names := make([]string, 0, len(_bindata))
@@ -348,23 +338,16 @@ 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,
-
-	"prestate_tracer.js": prestate_tracerJs,
-
-	"trigram_tracer.js": trigram_tracerJs,
-
-	"unigram_tracer.js": unigram_tracerJs,
+	"4byte_tracer.js":       _4byte_tracerJs,
+	"bigram_tracer.js":      bigram_tracerJs,
+	"call_tracer.js":        call_tracerJs,
+	"call_tracer_parity.js": call_tracer_parityJs,
+	"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,
 }
 
 // AssetDir returns the file names below a certain
@@ -376,15 +359,15 @@ var _bindata = map[string]func() (*asset, error){
 //       img/
 //         a.png
 //         b.png
-// then AssetDir("data") would return []string{"foo.txt", "img"},
-// AssetDir("data/img") would return []string{"a.png", "b.png"},
-// AssetDir("foo.txt") and AssetDir("notexist") would return an error, and
+// then AssetDir("data") would return []string{"foo.txt", "img"}
+// AssetDir("data/img") would return []string{"a.png", "b.png"}
+// AssetDir("foo.txt") and AssetDir("notexist") would return an error
 // AssetDir("") will return []string{"data"}.
 func AssetDir(name string) ([]string, error) {
 	node := _bintree
 	if len(name) != 0 {
-		canonicalName := strings.Replace(name, "\\", "/", -1)
-		pathList := strings.Split(canonicalName, "/")
+		cannonicalName := strings.Replace(name, "\\", "/", -1)
+		pathList := strings.Split(cannonicalName, "/")
 		for _, p := range pathList {
 			node = node.Children[p]
 			if node == nil {
@@ -408,18 +391,19 @@ type bintree struct {
 }
 
 var _bintree = &bintree{nil, map[string]*bintree{
-	"4byte_tracer.js":    {_4byte_tracerJs, map[string]*bintree{}},
-	"bigram_tracer.js":   {bigram_tracerJs, map[string]*bintree{}},
-	"call_tracer.js":     {call_tracerJs, map[string]*bintree{}},
-	"evmdis_tracer.js":   {evmdis_tracerJs, map[string]*bintree{}},
-	"noop_tracer.js":     {noop_tracerJs, map[string]*bintree{}},
-	"opcount_tracer.js":  {opcount_tracerJs, map[string]*bintree{}},
-	"prestate_tracer.js": {prestate_tracerJs, map[string]*bintree{}},
-	"trigram_tracer.js":  {trigram_tracerJs, map[string]*bintree{}},
-	"unigram_tracer.js":  {unigram_tracerJs, map[string]*bintree{}},
+	"4byte_tracer.js":       {_4byte_tracerJs, map[string]*bintree{}},
+	"bigram_tracer.js":      {bigram_tracerJs, map[string]*bintree{}},
+	"call_tracer.js":        {call_tracerJs, map[string]*bintree{}},
+	"call_tracer_parity.js": {call_tracer_parityJs, map[string]*bintree{}},
+	"evmdis_tracer.js":      {evmdis_tracerJs, map[string]*bintree{}},
+	"noop_tracer.js":        {noop_tracerJs, map[string]*bintree{}},
+	"opcount_tracer.js":     {opcount_tracerJs, map[string]*bintree{}},
+	"prestate_tracer.js":    {prestate_tracerJs, map[string]*bintree{}},
+	"trigram_tracer.js":     {trigram_tracerJs, map[string]*bintree{}},
+	"unigram_tracer.js":     {unigram_tracerJs, map[string]*bintree{}},
 }}
 
-// RestoreAsset restores an asset under the given directory.
+// RestoreAsset restores an asset under the given directory
 func RestoreAsset(dir, name string) error {
 	data, err := Asset(name)
 	if err != nil {
@@ -437,10 +421,14 @@ func RestoreAsset(dir, name string) error {
 	if err != nil {
 		return err
 	}
-	return os.Chtimes(_filePath(dir, name), info.ModTime(), info.ModTime())
+	err = os.Chtimes(_filePath(dir, name), info.ModTime(), info.ModTime())
+	if err != nil {
+		return err
+	}
+	return nil
 }
 
-// RestoreAssets restores an asset under the given directory recursively.
+// RestoreAssets restores an asset under the given directory recursively
 func RestoreAssets(dir, name string) error {
 	children, err := AssetDir(name)
 	// File
@@ -458,6 +446,6 @@ func RestoreAssets(dir, name string) error {
 }
 
 func _filePath(dir, name string) string {
-	canonicalName := strings.Replace(name, "\\", "/", -1)
-	return filepath.Join(append([]string{dir}, strings.Split(canonicalName, "/")...)...)
+	cannonicalName := strings.Replace(name, "\\", "/", -1)
+	return filepath.Join(append([]string{dir}, strings.Split(cannonicalName, "/")...)...)
 }
diff --git a/eth/tracers/internal/tracers/call_tracer.js b/eth/tracers/internal/tracers/call_tracer.js
index 3ca7377738..1ac0f23323 100644
--- a/eth/tracers/internal/tracers/call_tracer.js
+++ b/eth/tracers/internal/tracers/call_tracer.js
@@ -47,6 +47,7 @@
 				type:    op,
 				from:    toHex(log.contract.getAddress()),
 				input:   toHex(log.memory.slice(inOff, inEnd)),
+				gas:     log.getAvailableGas(),
 				gasIn:   log.getGas(),
 				gasCost: log.getCost(),
 				value:   '0x' + log.stack.peek(0).toString(16)
@@ -125,7 +126,7 @@
 
 			if (call.type == 'CREATE' || call.type == "CREATE2") {
 				// If the call was a CREATE, retrieve the contract address and output code
-				call.gasUsed = '0x' + bigInt(call.gasIn - call.gasCost - log.getGas()).toString(16);
+				call.gasUsed = '0x' + bigInt(call.gas - (log.getGas() - (call.gasIn - call.gasCost))).toString(16);
 				delete call.gasIn; delete call.gasCost;
 
 				var ret = log.stack.peek(0);
diff --git a/eth/tracers/internal/tracers/call_tracer_parity.js b/eth/tracers/internal/tracers/call_tracer_parity.js
new file mode 100644
index 0000000000..b2c5481e95
--- /dev/null
+++ b/eth/tracers/internal/tracers/call_tracer_parity.js
@@ -0,0 +1,464 @@
+// 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/>.
+
+// callTracer is a full blown transaction tracer that extracts and reports all
+// the internal calls made by a transaction, along with any useful information.
+{
+	// callstack is the current recursive call stack of the EVM execution.
+	callstack: [{}],
+
+	// descended tracks whether we've just descended from an outer transaction into
+	// an inner call.
+	descended: false,
+
+	parityErrorMapping: {
+		"contract creation code storage out of gas": "Out of gas",
+		"out of gas": "Out of gas",
+		"gas uint64 overflow": "Out of gas",
+		"max code size exceeded": "Out of gas",
+		"invalid jump destination": "Bad jump destination",
+		"execution reverted": "Reverted",
+		"return data out of bounds": "Out of bounds",
+		"stack limit reached 1024 (1023)": "Out of stack",
+		"precompiled failed": "Built-in failed",
+	},
+
+	parityErrorMappingStartingWith: {
+		"invalid opcode:": "Bad instruction",
+		"stack underflow": "Stack underflow",
+	},
+
+	paritySkipTracesForErrors: [
+		"insufficient balance for transfer"
+	],
+
+	isObjectEmpty: function(obj) {
+		for (var x in obj) { return false; }
+		return true;
+	},
+
+	// step is invoked for every opcode that the VM executes.
+	step: function(log, db) {
+		// Capture any errors immediately
+		var error = log.getError();
+		if (typeof error !== "undefined") {
+			this.fault(log, db);
+			return;
+		}
+		// We only care about system opcodes, faster if we pre-check once
+		var syscall = (log.op.toNumber() & 0xf0) == 0xf0;
+		if (syscall) {
+			var op = log.op.toString();
+		}
+		// If a new contract is being created, add to the call stack
+		if (syscall && (op == "CREATE" || op == "CREATE2")) {
+			var inOff = log.stack.peek(1).valueOf();
+			var inEnd = inOff + log.stack.peek(2).valueOf();
+
+			// Assemble the internal call report and store for completion
+			var call = {
+				type:    op,
+				from:    toHex(log.contract.getAddress()),
+				input:   toHex(log.memory.slice(inOff, inEnd)),
+				gas:     log.getAvailableGas(),
+				gasIn:   log.getGas(),
+				gasCost: log.getCost(),
+				value:   "0x" + log.stack.peek(0).toString(16)
+			};
+			this.callstack.push(call);
+			this.descended = true;
+			return;
+		}
+		// If a contract is being self destructed, gather that as a subcall too
+		// NOTE: Keep it above the this.descended if check
+		if (syscall && op == "SELFDESTRUCT") {
+			var left = this.callstack.length;
+			if (typeof this.callstack[left-1].calls === "undefined") {
+				this.callstack[left-1].calls = [];
+			}
+			this.callstack[left-1].calls.push({
+				type:    op,
+				from:    toHex(log.contract.getAddress()),
+				to:      toHex(toAddress(log.stack.peek(0).toString(16))),
+				gasIn:   log.getGas(),
+				gasCost: log.getCost(),
+				value:   "0x" + db.getBalance(log.contract.getAddress()).toString(16)
+			});
+			return;
+		}
+		// If a new method invocation is being done, add to the call stack
+		if (syscall && (op == "CALL" || op == "CALLCODE" || op == "DELEGATECALL" || op == "STATICCALL")) {
+			var to = toAddress(log.stack.peek(1).toString(16));
+
+			// Skip any pre-compile invocations, those are just fancy opcodes
+			if (isPrecompiled(to) && (op == "CALL" || op == "STATICCALL")) {
+				return;
+			}
+			var off = (op == "DELEGATECALL" || op == "STATICCALL" ? 0 : 1);
+
+			var inOff = log.stack.peek(2 + off).valueOf();
+			var inEnd = inOff + log.stack.peek(3 + off).valueOf();
+
+			// Assemble the internal call report and store for completion
+			var call = {
+				type:    op,
+				from:    toHex(log.contract.getAddress()),
+				to:      toHex(to),
+				input:   toHex(log.memory.slice(inOff, inEnd)),
+				gas:     log.getAvailableGas(),
+				gasIn:   log.getGas(),
+				gasCost: log.getCost(),
+				outOff:  log.stack.peek(4 + off).valueOf(),
+				outLen:  log.stack.peek(5 + off).valueOf()
+			};
+
+			if (op == "CALL" || op == "CALLCODE") {
+				var value = log.stack.peek(2);
+				call.value = "0x" + value.toString(16);
+
+				// Add stipend (only CALL|CALLCODE when value > 0)
+				// TODO: reading gas from next opcode is safer if stipend value changes
+				if (value > 0) {
+					call.gas = bigInt(call.gas + 2300);
+				}
+			} else if (op == "STATICCALL") {
+				call.value = "0x0";
+			}
+
+			this.callstack.push(call);
+			this.descended = true;
+			return;
+		}
+		// If we've just descended into an inner call, retrieve it's true allowance. We
+		// need to extract if from within the call as there may be funky gas dynamics
+		// with regard to requested and actually given gas (2300 stipend, 63/64 rule).
+		if (this.descended) {
+			if (log.getDepth() >= this.callstack.length) {
+				var call = this.callstack[this.callstack.length - 1];
+				if (typeof call.gas === "undefined") {
+					call.gas = log.getGas();
+				}
+			} else {
+				// TODO(karalabe): The call was made to a plain account. We currently don't
+				// have access to the true gas amount inside the call and so any amount will
+				// mostly be wrong since it depends on a lot of input args. Skip gas for now.
+			}
+			this.descended = false;
+		}
+		if (syscall && op == "REVERT") {
+			this.callstack[this.callstack.length - 1].error = "execution reverted";
+
+			// TODO(ziogaschr): read the output from stack as it contains the error passed from the contract developer
+			return;
+		}
+		if (syscall && op == "RETURN") {
+			if (log.getDepth() == this.callstack.length) {
+				var outOff = log.stack.peek(0).valueOf();
+				var outLen = log.stack.peek(1).valueOf();
+				this.callstack[this.callstack.length - 1].output = toHex(log.memory.slice(outOff, outOff + outLen));
+			}
+			return;
+		}
+		if (log.getDepth() == this.callstack.length - 1) {
+			// Pop off the last call and get the execution results
+			var call = this.callstack.pop();
+
+			if (call.type == "CREATE" || call.type == "CREATE2") {
+				// If the call was a CREATE, retrieve the contract address and output code
+				call.gasUsed = "0x" + bigInt(call.gas - (log.getGas() - (call.gasIn - call.gasCost))).toString(16);
+				delete call.gasIn; delete call.gasCost;
+
+				var ret = log.stack.peek(0);
+				if (!ret.equals(0)) {
+					call.to     = toHex(toAddress(ret.toString(16)));
+					call.output = toHex(db.getCode(toAddress(ret.toString(16))));
+				} else if (typeof call.error === "undefined") {
+					var opError = log.getCallError();
+					if (typeof opError !== "undefined") {
+						if (this.paritySkipTracesForErrors.indexOf(opError) > -1) {
+							return;
+						}
+						call.error = opError;
+					} else {
+						// NOTE(ziogachr): we should reach this else anymore
+						call.error = "internal failure"; // TODO(karalabe): surface these faults somehow
+						return;
+					}
+				}
+			} else {
+				// If the call was a contract call, retrieve the gas usage and output
+				if (typeof call.gas !== "undefined") {
+					call.gasUsed = "0x" + bigInt(call.gasIn - call.gasCost + call.gas - log.getGas()).toString(16);
+				}
+				delete call.gasIn; delete call.gasCost;
+
+				var ret = log.stack.peek(0);
+				if (!ret.equals(0)) {
+					if (typeof call.output === "undefined" || call.output === "0x") {
+						call.output = toHex(log.getReturnData());
+					}
+				} else if (typeof call.error === "undefined") {
+					var opError = log.getCallError();
+					if (typeof opError !== "undefined") {
+						if (this.paritySkipTracesForErrors.indexOf(opError) > -1) {
+							return;
+						}
+						if (isPrecompiled(toAddress(call.to)) && opError !== "out of gas") {
+							call.error = "precompiled failed"; // Parity compatible
+						} else {
+							call.error = opError;
+						}
+					} else {
+						// NOTE(ziogachr): we should reach this else anymore
+						call.error = "internal failure"; // TODO(karalabe): surface these faults somehow
+					}
+				}
+
+				delete call.outOff; delete call.outLen;
+			}
+			if (typeof call.gas !== "undefined") {
+				call.gas = '0x' + bigInt(call.gas).toString(16);
+			}
+
+			// Inject the call into the previous one
+			var left = this.callstack.length;
+			left = left > 0 ? left-1 :left;
+			if (typeof this.callstack[left].calls === "undefined") {
+				this.callstack[left].calls = [];
+			}
+			this.callstack[left].calls.push(call);
+		}
+	},
+
+	// fault is invoked when the actual execution of an opcode fails.
+	fault: function(log, db) {
+		// If the topmost call already reverted, don't handle the additional fault again
+		if (typeof this.callstack[this.callstack.length - 1].error !== "undefined") {
+			return;
+		}
+		// Pop off the just failed call
+		var call = this.callstack.pop();
+		call.error = log.getError();
+
+		var opError = log.getCallError();
+		if (typeof opError !== "undefined") {
+			if (this.paritySkipTracesForErrors.indexOf(opError) > -1) {
+				return;
+			}
+			call.error = opError;
+		}
+
+		// Consume all available gas and clean any leftovers
+		if (typeof call.gas !== "undefined") {
+			call.gas = '0x' + bigInt(call.gas).toString(16);
+			call.gasUsed = call.gas
+		} else {
+			// Retrieve gas true allowance from the inner call.
+			// We need to extract if from within the call as there may be funky gas dynamics
+			// with regard to requested and actually given gas (2300 stipend, 63/64 rule).
+			call.gas = '0x' + bigInt(log.getGas()).toString(16);
+		}
+
+		if (call.error === "out of gas" && typeof call.gas === "undefined") {
+			call.gas = "0x0";
+		}
+		delete call.gasIn; delete call.gasCost;
+		delete call.outOff; delete call.outLen;
+
+		// Flatten the failed call into its parent
+		var left = this.callstack.length;
+		if (left > 0) {
+			if (typeof this.callstack[left-1].calls === "undefined") {
+				this.callstack[left-1].calls = [];
+			}
+			this.callstack[left-1].calls.push(call);
+			return;
+		}
+		// Last call failed too, leave it in the stack
+		this.callstack.push(call);
+	},
+
+	// result is invoked when all the opcodes have been iterated over and returns
+	// the final result of the tracing.
+	result: function(ctx, db) {
+		var result = {
+			block:   ctx.block,
+			type:    ctx.type,
+			from:    toHex(ctx.from),
+			to:      toHex(ctx.to),
+			value:   '0x' + ctx.value.toString(16),
+			gas:     '0x' + bigInt(ctx.gas).toString(16),
+			gasUsed: '0x' + bigInt(ctx.gasUsed).toString(16),
+			input:   toHex(ctx.input),
+			output:  toHex(ctx.output),
+			time:    ctx.time,
+		};
+		var extraCtx = {
+			blockHash: ctx.blockHash,
+			blockNumber: ctx.blockNumber,
+			transactionHash: ctx.transactionHash,
+			transactionPosition: ctx.transactionPosition,
+		};
+		// when this.descended remains true and first item in callstack is an empty object
+		// drop the first item, in order to handle edge cases in the step() loop.
+		// example edge case: contract init code "0x605a600053600160006001f0ff00", search in testdata
+		if (this.descended && this.callstack.length > 1 && this.isObjectEmpty(this.callstack[0])) {
+			this.callstack.shift();
+		}
+		if (typeof this.callstack[0].calls !== "undefined") {
+			result.calls = this.callstack[0].calls;
+		}
+		if (typeof this.callstack[0].error !== "undefined") {
+			result.error = this.callstack[0].error;
+		} else if (typeof ctx.error !== "undefined") {
+			result.error = ctx.error;
+		}
+		if (typeof result.error !== "undefined" && (result.error !== "execution reverted" || result.output ==="0x")) {
+			delete result.output;
+		}
+		return this.finalize(result, extraCtx);
+	},
+
+	// finalize recreates a call object using the final desired field order for json
+	// serialization. This is a nicety feature to pass meaningfully ordered results
+	// to users who don't interpret it, just display it.
+	finalize: function(call, extraCtx, traceAddress) {
+		var data;
+		if (call.type == "CREATE" || call.type == "CREATE2") {
+			data = this.createResult(call);
+
+			// update after callResult so as it affects only the root type
+			call.type = "CREATE";
+		} else if (call.type == "SELFDESTRUCT") {
+			call.type = "SUICIDE";
+			data = this.suicideResult(call);
+		} else {
+			data = this.callResult(call);
+
+			// update after callResult so as it affects only the root type
+			if (call.type == "CALLCODE" || call.type == "DELEGATECALL" || call.type == "STATICCALL") {
+				call.type = "CALL";
+			}
+		}
+
+		traceAddress = traceAddress || [];
+		var sorted = {
+			type: call.type.toLowerCase(),
+			action: data.action,
+			result: data.result,
+			error: call.error,
+			traceAddress: traceAddress,
+			subtraces: 0,
+			transactionPosition: extraCtx.transactionPosition,
+			transactionHash: extraCtx.transactionHash,
+			blockNumber: call.block || extraCtx.blockNumber,
+			blockHash: extraCtx.blockHash,
+			time: call.time,
+		}
+
+		if (typeof sorted.error !== "undefined") {
+			if (this.parityErrorMapping.hasOwnProperty(sorted.error)) {
+				sorted.error = this.parityErrorMapping[sorted.error];
+				delete sorted.result;
+			} else {
+				for (var searchKey in this.parityErrorMappingStartingWith) {
+					if (this.parityErrorMappingStartingWith.hasOwnProperty(searchKey) && sorted.error.indexOf(searchKey) > -1) {
+						sorted.error = this.parityErrorMappingStartingWith[searchKey];
+						delete sorted.result;
+					}
+				}
+			}
+		}
+
+		for (var key in sorted) {
+			if (typeof sorted[key] === "object") {
+				for (var nested_key in sorted[key]) {
+					if (typeof sorted[key][nested_key] === "undefined") {
+						delete sorted[key][nested_key];
+					}
+				}
+			} else if (typeof sorted[key] === "undefined") {
+				delete sorted[key];
+			}
+		}
+
+		var calls = call.calls;
+		if (typeof calls !== "undefined") {
+			sorted["subtraces"] = calls.length;
+		}
+
+		var results = [sorted];
+
+		if (typeof calls !== "undefined") {
+			for (var i=0; i<calls.length; i++) {
+				var childCall = calls[i];
+
+				// Delegatecall uses the value from parent
+				if ((childCall.type == "DELEGATECALL" || childCall.type == "STATICCALL") && typeof childCall.value === "undefined") {
+					childCall.value = call.value;
+				}
+
+				results = results.concat(this.finalize(childCall, extraCtx, traceAddress.concat([i])));
+			}
+		}
+		return results;
+	},
+
+	createResult: function(call) {
+		return {
+			action: {
+				from:           call.from,                // Sender
+				value:          call.value,               // Value
+				gas:            call.gas,                 // Gas
+				init:           call.input,               // Initialization code
+				creationMethod: call.type.toLowerCase(),  // Create Type
+			},
+			result: {
+				gasUsed:  call.gasUsed,  // Gas used
+				code:     call.output,   // Code
+				address:  call.to,       // Assigned address
+			}
+		}
+	},
+
+	callResult: function(call) {
+		return {
+			action: {
+				from:      call.from,               // Sender
+				to:        call.to,                 // Recipient
+				value:     call.value,              // Transfered Value
+				gas:       call.gas,                // Gas
+				input:     call.input,              // Input data
+				callType:  call.type.toLowerCase(), // The type of the call
+			},
+			result: {
+				gasUsed: call.gasUsed,  // Gas used
+				output:  call.output,   // Output bytes
+			}
+		}
+	},
+
+	suicideResult: function(call) {
+		return {
+			action: {
+				address:        call.from,   // Address
+				refundAddress:  call.to,     // Refund address
+				balance:        call.value,  // Balance
+			},
+			result: null
+		}
+	}
+}
diff --git a/eth/tracers/tracer.go b/eth/tracers/tracer.go
index dd7594dfb3..8abeb4e454 100644
--- a/eth/tracers/tracer.go
+++ b/eth/tracers/tracer.go
@@ -300,12 +300,15 @@ type Tracer struct {
 	contractWrapper *contractWrapper // Wrapper around the contract object
 	dbWrapper       *dbWrapper       // Wrapper around the VM environment
 
-	pcValue     *uint   // Swappable pc value wrapped by a log accessor
-	gasValue    *uint   // Swappable gas value wrapped by a log accessor
-	costValue   *uint   // Swappable cost value wrapped by a log accessor
-	depthValue  *uint   // Swappable depth value wrapped by a log accessor
-	errorValue  *string // Swappable error value wrapped by a log accessor
-	refundValue *uint   // Swappable refund value wrapped by a log accessor
+	pcValue           *uint   // Swappable pc value wrapped by a log accessor
+	gasValue          *uint   // Swappable gas value wrapped by a log accessor
+	availableGasValue *uint   // Swappable available gas value for this specific call wrapped by a log accessor
+	costValue         *uint   // Swappable cost value wrapped by a log accessor
+	depthValue        *uint   // Swappable depth value wrapped by a log accessor
+	returnData        *[]byte // Swappable return data wrapped by a log accessor
+	errorValue        *string // Swappable error value wrapped by a log accessor
+	opErrorValue      *string // Swappable error value for this specific call wrapped by a log accessor. NOTE: the error is for the previous call trace
+	refundValue       *uint   // Swappable refund value wrapped by a log accessor
 
 	ctx map[string]interface{} // Transaction context gathered throughout execution
 	err error                  // Error, if one has occurred
@@ -323,18 +326,20 @@ func New(code string) (*Tracer, error) {
 		code = tracer
 	}
 	tracer := &Tracer{
-		vm:              duktape.New(),
-		ctx:             make(map[string]interface{}),
-		opWrapper:       new(opWrapper),
-		stackWrapper:    new(stackWrapper),
-		memoryWrapper:   new(memoryWrapper),
-		contractWrapper: new(contractWrapper),
-		dbWrapper:       new(dbWrapper),
-		pcValue:         new(uint),
-		gasValue:        new(uint),
-		costValue:       new(uint),
-		depthValue:      new(uint),
-		refundValue:     new(uint),
+		vm:                duktape.New(),
+		ctx:               make(map[string]interface{}),
+		opWrapper:         new(opWrapper),
+		stackWrapper:      new(stackWrapper),
+		memoryWrapper:     new(memoryWrapper),
+		contractWrapper:   new(contractWrapper),
+		dbWrapper:         new(dbWrapper),
+		pcValue:           new(uint),
+		gasValue:          new(uint),
+		availableGasValue: new(uint),
+		costValue:         new(uint),
+		depthValue:        new(uint),
+		returnData:        new([]byte),
+		refundValue:       new(uint),
 	}
 	// Set up builtins for this environment
 	tracer.vm.PushGlobalGoFunction("toHex", func(ctx *duktape.Context) int {
@@ -470,15 +475,35 @@ func New(code string) (*Tracer, error) {
 	tracer.vm.PushGoFunction(func(ctx *duktape.Context) int { ctx.PushUint(*tracer.gasValue); return 1 })
 	tracer.vm.PutPropString(logObject, "getGas")
 
+	tracer.vm.PushGoFunction(func(ctx *duktape.Context) int { ctx.PushUint(*tracer.availableGasValue); return 1 })
+	tracer.vm.PutPropString(logObject, "getAvailableGas")
+
 	tracer.vm.PushGoFunction(func(ctx *duktape.Context) int { ctx.PushUint(*tracer.costValue); return 1 })
 	tracer.vm.PutPropString(logObject, "getCost")
 
 	tracer.vm.PushGoFunction(func(ctx *duktape.Context) int { ctx.PushUint(*tracer.depthValue); return 1 })
 	tracer.vm.PutPropString(logObject, "getDepth")
 
+	tracer.vm.PushGoFunction(func(ctx *duktape.Context) int {
+		ptr := ctx.PushFixedBuffer(len(*tracer.returnData))
+		copy(makeSlice(ptr, uint(len(*tracer.returnData))), *tracer.returnData)
+		return 1
+	})
+	tracer.vm.PutPropString(logObject, "getReturnData")
+
 	tracer.vm.PushGoFunction(func(ctx *duktape.Context) int { ctx.PushUint(*tracer.refundValue); return 1 })
 	tracer.vm.PutPropString(logObject, "getRefund")
 
+	tracer.vm.PushGoFunction(func(ctx *duktape.Context) int {
+		if tracer.opErrorValue != nil {
+			ctx.PushString(*tracer.opErrorValue)
+		} else {
+			ctx.PushUndefined()
+		}
+		return 1
+	})
+	tracer.vm.PutPropString(logObject, "getCallError")
+
 	tracer.vm.PushGoFunction(func(ctx *duktape.Context) int {
 		if tracer.errorValue != nil {
 			ctx.PushString(*tracer.errorValue)
@@ -541,6 +566,13 @@ func (jst *Tracer) CaptureStart(from common.Address, to common.Address, create b
 	return nil
 }
 
+func (jst *Tracer) CaptureExtraContext(inputs map[string]interface{}) error {
+	for key, val := range inputs {
+		jst.ctx[key] = val
+	}
+	return nil
+}
+
 // CaptureState implements the Tracer interface to trace a single step of VM execution.
 func (jst *Tracer) CaptureState(env *vm.EVM, pc uint64, op vm.OpCode, gas, cost uint64, memory *vm.Memory, stack *vm.Stack, rStack *vm.ReturnStack, rdata []byte, contract *vm.Contract, depth int, err error) error {
 	if jst.err == nil {
@@ -562,10 +594,19 @@ func (jst *Tracer) CaptureState(env *vm.EVM, pc uint64, op vm.OpCode, gas, cost
 
 		*jst.pcValue = uint(pc)
 		*jst.gasValue = uint(gas)
+		*jst.availableGasValue = uint(env.CallGasTemp)
 		*jst.costValue = uint(cost)
 		*jst.depthValue = uint(depth)
+		*jst.returnData = rdata
 		*jst.refundValue = uint(env.StateDB.GetRefund())
 
+		jst.opErrorValue = nil
+		if env.CallErrorTemp != nil {
+			jst.opErrorValue = new(string)
+			*jst.opErrorValue = env.CallErrorTemp.Error()
+
+			env.CallErrorTemp = nil // clean temp error storage, for debug tracing
+		}
 		jst.errorValue = nil
 		if err != nil {
 			jst.errorValue = new(string)
diff --git a/internal/web3ext/web3ext.go b/internal/web3ext/web3ext.go
index 73d5528716..b4f9d9ae6f 100644
--- a/internal/web3ext/web3ext.go
+++ b/internal/web3ext/web3ext.go
@@ -31,6 +31,7 @@ var Modules = map[string]string{
 	"rpc":        RpcJs,
 	"shh":        ShhJs,
 	"swarmfs":    SwarmfsJs,
+	"trace":      TraceJs,
 	"txpool":     TxpoolJs,
 	"les":        LESJs,
 	"lespay":     LESPayJs,
@@ -768,6 +769,33 @@ web3._extend({
 });
 `
 
+const TraceJs = `
+web3._extend({
+	property: 'trace',
+	methods: [
+		new web3._extend.Method({
+			name: 'block',
+			call: 'trace_block',
+			params: 2,
+			inputFormatter: [null, null]
+		}),
+		new web3._extend.Method({
+			name: 'transaction',
+			call: 'trace_transaction',
+			params: 2,
+			inputFormatter: [null, null]
+		}),
+		new web3._extend.Method({
+			name: 'filter',
+			call: 'trace_filter',
+			params: 2,
+			inputFormatter: [null, null]
+		}),
+	],
+	properties: []
+});
+`
+
 const TxpoolJs = `
 web3._extend({
 	property: 'txpool',