forks/go-ethereum
1
0
Fork 1
mirror of https://github.com/ethereum/go-ethereum.git synced 2026-08-19 18:32:23 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

change output JSON schema

Browse source 
The new output becomes:

```
{
  "issuance": {
    "reward": 0,
    "withdrawals": 0
  },
  "burn": {
    "1559": 0,
    "blob": 0,
    "misc": 0
  },
  "blockNumber": 1,
  "hash": "0x",
  "parentHash": "0x"
}
```
This commit is contained in:
Chris Ziogas 2024-05-30 14:33:28 +03:00
parent dec5d3b6d1
commit b07ef33e95
No known key found for this signature in database
GPG key ID: 2329CF479E36E2DA
2 changed files with 131 additions and 77 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

154
eth/tracers/internal/tracetest/supply_test.go
View file

@ -42,11 +42,21 @@ import (
_ "github.com/ethereum/go-ethereum/eth/tracers/live" _ "github.com/ethereum/go-ethereum/eth/tracers/live"
) )
type supplyInfoIssuance struct {
GenesisAlloc *big.Int `json:"genesisAlloc,omitempty"`
Reward *big.Int `json:"reward"`
Withdrawals *big.Int `json:"withdrawals"`
}
type supplyInfoBurn struct {
EIP1559 *big.Int `json:"1559"`
Blob *big.Int `json:"blob"`
Misc *big.Int `json:"misc"`
}
type supplyInfo struct { type supplyInfo struct {
Delta *big.Int `json:"delta"` Issuance *supplyInfoIssuance `json:"issuance"`
Reward *big.Int `json:"reward"` Burn *supplyInfoBurn `json:"burn"`
Withdrawals *big.Int `json:"withdrawals"`
Burn *big.Int `json:"burn"`
// Block info // Block info
Number uint64 `json:"blockNumber"` Number uint64 `json:"blockNumber"`
@ -76,13 +86,19 @@ func TestSupplyGenesisAlloc(t *testing.T) {
) )
expected := supplyInfo{ expected := supplyInfo{
Delta: new(big.Int).Mul(common.Big2, big.NewInt(params.Ether)), Issuance: &supplyInfoIssuance{
Reward: common.Big0, GenesisAlloc: new(big.Int).Mul(common.Big2, big.NewInt(params.Ether)),
Withdrawals: common.Big0, Reward: common.Big0,
Burn: common.Big0, Withdrawals: common.Big0,
Number: 0, },
Hash: common.HexToHash("0xbcc9466e9fc6a8b56f4b29ca353a421ff8b51a0c1a58ca4743b427605b08f2ca"), Burn: &supplyInfoBurn{
ParentHash: common.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000000"), EIP1559: common.Big0,
Blob: common.Big0,
Misc: common.Big0,
},
Number: 0,
Hash: common.HexToHash("0xbcc9466e9fc6a8b56f4b29ca353a421ff8b51a0c1a58ca4743b427605b08f2ca"),
ParentHash: common.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000000"),
} }
out, _, err := testSupplyTracer(t, gspec, emptyBlockGenerationFunc) out, _, err := testSupplyTracer(t, gspec, emptyBlockGenerationFunc)
@ -105,13 +121,18 @@ func TestSupplyRewards(t *testing.T) {
) )
expected := supplyInfo{ expected := supplyInfo{
Delta: new(big.Int).Mul(common.Big2, big.NewInt(params.Ether)), Issuance: &supplyInfoIssuance{
Reward: new(big.Int).Mul(common.Big2, big.NewInt(params.Ether)), Reward: new(big.Int).Mul(common.Big2, big.NewInt(params.Ether)),
Withdrawals: common.Big0, Withdrawals: common.Big0,
Burn: common.Big0, },
Number: 1, Burn: &supplyInfoBurn{
Hash: common.HexToHash("0xcbb08370505be503dafedc4e96d139ea27aba3cbc580148568b8a307b3f51052"), EIP1559: common.Big0,
ParentHash: common.HexToHash("0xadeda0a83e337b6c073e3f0e9a17531a04009b397a9588c093b628f21b8bc5a3"), Blob: common.Big0,
Misc: common.Big0,
},
Number: 1,
Hash: common.HexToHash("0xcbb08370505be503dafedc4e96d139ea27aba3cbc580148568b8a307b3f51052"),
ParentHash: common.HexToHash("0xadeda0a83e337b6c073e3f0e9a17531a04009b397a9588c093b628f21b8bc5a3"),
} }
out, _, err := testSupplyTracer(t, gspec, emptyBlockGenerationFunc) out, _, err := testSupplyTracer(t, gspec, emptyBlockGenerationFunc)
@ -170,13 +191,18 @@ func TestSupplyEip1559Burn(t *testing.T) {
reward = new(big.Int).Mul(common.Big2, big.NewInt(params.Ether)) reward = new(big.Int).Mul(common.Big2, big.NewInt(params.Ether))
burn = new(big.Int).Mul(big.NewInt(21000), head.BaseFee) burn = new(big.Int).Mul(big.NewInt(21000), head.BaseFee)
expected = supplyInfo{ expected = supplyInfo{
Delta: new(big.Int).Sub(reward, burn), Issuance: &supplyInfoIssuance{
Reward: reward, Reward: reward,
Withdrawals: common.Big0, Withdrawals: common.Big0,
Burn: burn, },
Number: 1, Burn: &supplyInfoBurn{
Hash: head.Hash(), EIP1559: burn,
ParentHash: head.ParentHash, Blob: common.Big0,
Misc: common.Big0,
},
Number: 1,
Hash: head.Hash(),
ParentHash: head.ParentHash,
} }
) )
@ -210,13 +236,18 @@ func TestSupplyWithdrawals(t *testing.T) {
var ( var (
head = chain.CurrentBlock() head = chain.CurrentBlock()
expected = supplyInfo{ expected = supplyInfo{
Delta: big.NewInt(1337000000000), Issuance: &supplyInfoIssuance{
Reward: common.Big0, Reward: common.Big0,
Withdrawals: big.NewInt(1337000000000), Withdrawals: big.NewInt(1337000000000),
Burn: common.Big0, },
Number: 1, Burn: &supplyInfoBurn{
Hash: head.Hash(), EIP1559: common.Big0,
ParentHash: head.ParentHash, Blob: common.Big0,
Misc: common.Big0,
},
Number: 1,
Hash: head.Hash(),
ParentHash: head.ParentHash,
} }
actual = out[expected.Number] actual = out[expected.Number]
) )
@ -306,13 +337,18 @@ func TestSupplySelfdestruct(t *testing.T) {
head := preCancunChain.CurrentBlock() head := preCancunChain.CurrentBlock()
// Check live trace output // Check live trace output
expected := supplyInfo{ expected := supplyInfo{
Delta: big.NewInt(-55294500000000), Issuance: &supplyInfoIssuance{
Reward: common.Big0, Reward: common.Big0,
Withdrawals: common.Big0, Withdrawals: common.Big0,
Burn: big.NewInt(55294500000000), },
Number: 1, Burn: &supplyInfoBurn{
Hash: head.Hash(), EIP1559: big.NewInt(55289500000000),
ParentHash: head.ParentHash, Blob: common.Big0,
Misc: big.NewInt(5000000000),
},
Number: 1,
Hash: head.Hash(),
ParentHash: head.ParentHash,
} }
actual := preCancunOutput[expected.Number] actual := preCancunOutput[expected.Number]
@ -347,13 +383,18 @@ func TestSupplySelfdestruct(t *testing.T) {
// Check live trace output // Check live trace output
head = postCancunChain.CurrentBlock() head = postCancunChain.CurrentBlock()
expected = supplyInfo{ expected = supplyInfo{
Delta: big.NewInt(-55289500000000), Issuance: &supplyInfoIssuance{
Reward: common.Big0, Reward: common.Big0,
Withdrawals: common.Big0, Withdrawals: common.Big0,
Burn: big.NewInt(55289500000000), },
Number: 1, Burn: &supplyInfoBurn{
Hash: head.Hash(), EIP1559: big.NewInt(55289500000000),
ParentHash: head.ParentHash, Blob: common.Big0,
Misc: common.Big0,
},
Number: 1,
Hash: head.Hash(),
ParentHash: head.ParentHash,
} }
actual = postCancunOutput[expected.Number] actual = postCancunOutput[expected.Number]
@ -491,17 +532,20 @@ func TestSupplySelfdestructItselfAndRevert(t *testing.T) {
// Check live trace output // Check live trace output
block := chain.GetBlockByNumber(1) block := chain.GetBlockByNumber(1)
blockBurn := new(big.Int).Mul(block.BaseFee(), big.NewInt(int64(block.GasUsed())))
totalBurn := new(big.Int).Add(blockBurn, eth5) // 5ETH burned from contract B
expected := supplyInfo{ expected := supplyInfo{
Delta: new(big.Int).Neg(totalBurn), Issuance: &supplyInfoIssuance{
Reward: common.Big0, Reward: common.Big0,
Withdrawals: common.Big0, Withdrawals: common.Big0,
Burn: totalBurn, },
Number: 1, Burn: &supplyInfoBurn{
Hash: block.Hash(), EIP1559: new(big.Int).Mul(block.BaseFee(), big.NewInt(int64(block.GasUsed()))),
ParentHash: block.ParentHash(), Blob: common.Big0,
Misc: eth5, // 5ETH burned from contract B
},
Number: 1,
Hash: block.Hash(),
ParentHash: block.ParentHash(),
} }
actual := output[expected.Number] actual := output[expected.Number]

54
eth/tracers/live/supply.go
View file

@ -21,11 +21,21 @@ func init() {
tracers.LiveDirectory.Register("supply", newSupply) tracers.LiveDirectory.Register("supply", newSupply)
} }
type supplyInfoIssuance struct {
GenesisAlloc *big.Int `json:"genesisAlloc,omitempty"`
Reward *big.Int `json:"reward"`
Withdrawals *big.Int `json:"withdrawals"`
}
type supplyInfoBurn struct {
EIP1559 *big.Int `json:"1559"`
Blob *big.Int `json:"blob"`
Misc *big.Int `json:"misc"`
}
type supplyInfo struct { type supplyInfo struct {
Delta *big.Int `json:"delta"` Issuance *supplyInfoIssuance `json:"issuance"`
Reward *big.Int `json:"reward"` Burn *supplyInfoBurn `json:"burn"`
Withdrawals *big.Int `json:"withdrawals"`
Burn *big.Int `json:"burn"`
// Block info // Block info
Number uint64 `json:"blockNumber"` Number uint64 `json:"blockNumber"`
@ -33,11 +43,6 @@ type supplyInfo struct {
ParentHash common.Hash `json:"parentHash"` ParentHash common.Hash `json:"parentHash"`
} }
func (s *supplyInfo) burn(amount *big.Int) {
s.Burn.Add(s.Burn, amount)
s.Delta.Sub(s.Delta, amount)
}
type supplyTxCallstack struct { type supplyTxCallstack struct {
calls []supplyTxCallstack calls []supplyTxCallstack
burn *big.Int burn *big.Int
@ -91,10 +96,15 @@ func newSupply(cfg json.RawMessage) (*tracing.Hooks, error) {
func newSupplyInfo() supplyInfo { func newSupplyInfo() supplyInfo {
return supplyInfo{ return supplyInfo{
Delta: big.NewInt(0), Issuance: &supplyInfoIssuance{
Reward: big.NewInt(0), Reward: big.NewInt(0),
Withdrawals: big.NewInt(0), Withdrawals: big.NewInt(0),
Burn: big.NewInt(0), },
Burn: &supplyInfoBurn{
EIP1559: big.NewInt(0),
Blob: big.NewInt(0),
Misc: big.NewInt(0),
},
Number: 0, Number: 0,
Hash: common.Hash{}, Hash: common.Hash{},
@ -116,7 +126,7 @@ func (s *supply) OnBlockStart(ev tracing.BlockEvent) {
// Calculate Burn for this block // Calculate Burn for this block
if ev.Block.BaseFee() != nil { if ev.Block.BaseFee() != nil {
burn := new(big.Int).Mul(new(big.Int).SetUint64(ev.Block.GasUsed()), ev.Block.BaseFee()) burn := new(big.Int).Mul(new(big.Int).SetUint64(ev.Block.GasUsed()), ev.Block.BaseFee())
s.delta.burn(burn) s.delta.Burn.EIP1559.Add(s.delta.Burn.EIP1559, burn)
} }
// Blob burnt gas // Blob burnt gas
if blobGas := ev.Block.BlobGasUsed(); blobGas != nil && *blobGas > 0 && ev.Block.ExcessBlobGas() != nil { if blobGas := ev.Block.BlobGasUsed(); blobGas != nil && *blobGas > 0 && ev.Block.ExcessBlobGas() != nil {
@ -125,7 +135,7 @@ func (s *supply) OnBlockStart(ev tracing.BlockEvent) {
baseFee = eip4844.CalcBlobFee(excess) baseFee = eip4844.CalcBlobFee(excess)
burn = new(big.Int).Mul(new(big.Int).SetUint64(*blobGas), baseFee) burn = new(big.Int).Mul(new(big.Int).SetUint64(*blobGas), baseFee)
) )
s.delta.burn(burn) s.delta.Burn.Blob.Add(s.delta.Burn.Blob, burn)
} }
} }
@ -140,9 +150,11 @@ func (s *supply) OnGenesisBlock(b *types.Block, alloc types.GenesisAlloc) {
s.delta.Hash = b.Hash() s.delta.Hash = b.Hash()
s.delta.ParentHash = b.ParentHash() s.delta.ParentHash = b.ParentHash()
s.delta.Issuance.GenesisAlloc = big.NewInt(0)
// Initialize supply with total allocation in genesis block // Initialize supply with total allocation in genesis block
for _, account := range alloc { for _, account := range alloc {
s.delta.Delta.Add(s.delta.Delta, account.Balance) s.delta.Issuance.GenesisAlloc.Add(s.delta.Issuance.GenesisAlloc, account.Balance)
} }
s.write(s.delta) s.write(s.delta)
@ -155,18 +167,16 @@ func (s *supply) OnBalanceChange(a common.Address, prevBalance, newBalance *big.
switch reason { switch reason {
case tracing.BalanceIncreaseRewardMineUncle: case tracing.BalanceIncreaseRewardMineUncle:
case tracing.BalanceIncreaseRewardMineBlock: case tracing.BalanceIncreaseRewardMineBlock:
s.delta.Reward.Add(s.delta.Reward, diff) s.delta.Issuance.Reward.Add(s.delta.Issuance.Reward, diff)
case tracing.BalanceIncreaseWithdrawal: case tracing.BalanceIncreaseWithdrawal:
s.delta.Withdrawals.Add(s.delta.Withdrawals, diff) s.delta.Issuance.Withdrawals.Add(s.delta.Issuance.Withdrawals, diff)
case tracing.BalanceDecreaseSelfdestructBurn: case tracing.BalanceDecreaseSelfdestructBurn:
// BalanceDecreaseSelfdestructBurn is non-reversible as it happens // BalanceDecreaseSelfdestructBurn is non-reversible as it happens
// at the end of the transaction. // at the end of the transaction.
s.delta.Burn.Sub(s.delta.Burn, diff) s.delta.Burn.Misc.Sub(s.delta.Burn.Misc, diff)
default: default:
return return
} }
s.delta.Delta.Add(s.delta.Delta, diff)
} }
func (s *supply) OnTxStart(vm *tracing.VMContext, tx *types.Transaction, from common.Address) { func (s *supply) OnTxStart(vm *tracing.VMContext, tx *types.Transaction, from common.Address) {
@ -177,7 +187,7 @@ func (s *supply) OnTxStart(vm *tracing.VMContext, tx *types.Transaction, from co
func (s *supply) internalTxsHandler(call *supplyTxCallstack) { func (s *supply) internalTxsHandler(call *supplyTxCallstack) {
// Handle Burned amount // Handle Burned amount
if call.burn != nil { if call.burn != nil {
s.delta.burn(call.burn) s.delta.Burn.Misc.Add(s.delta.Burn.Misc, call.burn)
} }
if len(call.calls) > 0 { if len(call.calls) > 0 {