ipld-eth-statedb/statedb_test.go

439 lines
14 KiB
Go
Raw Normal View History

2023-03-05 07:33:51 +00:00
package ipld_eth_statedb_test
import (
"context"
"math/big"
"os"
"strconv"
"testing"
"github.com/jackc/pgx/v4/pgxpool"
"github.com/multiformats/go-multihash"
"github.com/stretchr/testify/require"
"github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/core/types"
"github.com/ethereum/go-ethereum/crypto"
"github.com/ethereum/go-ethereum/rlp"
"github.com/ethereum/go-ethereum/statediff/indexer/ipld"
statedb "github.com/cerc-io/ipld-eth-statedb"
util "github.com/cerc-io/ipld-eth-statedb/internal"
)
var (
testCtx = context.Background()
// Fixture data
// block one: contract account and slot are created
// block two: slot is emptied
// block three: slot has a new value added
// block four: non-canonical block with non-canonical slot value is added to the database
// block five: entire contract is destructed; another non-canonical block is created but it doesn't include an update for our slot
// but it links back to the other non-canonical header (this is to test the ability to resolve canonicity by comparing how many
// children reference back to a header)
// block six: canonical block only, no relevant state changes (check that we still return emptied result at heights where it wasn't emptied)
2023-03-05 07:33:51 +00:00
BlockNumber = big.NewInt(1337)
Header = types.Header{Number: BlockNumber}
BlockHash = Header.Hash()
2023-03-08 17:20:16 +00:00
BlockHash2 = crypto.Keccak256Hash([]byte("I am a random hash"))
BlockNumber2 = BlockNumber.Uint64() + 1
BlockHash3 = crypto.Keccak256Hash([]byte("I am another random hash"))
BlockNumber3 = BlockNumber.Uint64() + 2
BlockHash4 = crypto.Keccak256Hash([]byte("I am"))
BlockNumber4 = BlockNumber.Uint64() + 3
BlockHash5 = crypto.Keccak256Hash([]byte("I"))
BlockNumber5 = BlockNumber.Uint64() + 4
BlockHash6 = crypto.Keccak256Hash([]byte("am"))
BlockNumber6 = BlockNumber.Uint64() + 5
2023-03-05 07:33:51 +00:00
BlockParentHash = common.HexToHash("0123456701234567012345670123456701234567012345670123456701234567")
2023-03-09 15:03:47 +00:00
NonCanonicalHash4 = crypto.Keccak256Hash([]byte("I am a random non canonical hash"))
NonCanonicalHash5 = crypto.Keccak256Hash([]byte("I am also a random non canonical hash"))
2023-03-05 07:33:51 +00:00
AccountPK, _ = crypto.HexToECDSA("8a1f9a8f95be41cd7ccb6168179afb4504aefe388d1e14474d32c45c72ce7b7a")
AccountAddress = crypto.PubkeyToAddress(AccountPK.PublicKey) //0x703c4b2bD70c169f5717101CaeE543299Fc946C7
AccountLeafKey = crypto.Keccak256Hash(AccountAddress.Bytes())
AccountCode = []byte{0, 1, 2, 3, 4, 5, 6, 7}
AccountCodeHash = crypto.Keccak256Hash(AccountCode)
Account = types.StateAccount{
Nonce: uint64(0),
Balance: big.NewInt(1000),
CodeHash: AccountCodeHash.Bytes(),
Root: common.Hash{},
}
StorageLeafKey = crypto.Keccak256Hash(common.HexToHash("0").Bytes())
StoredValue = crypto.Keccak256Hash([]byte{1, 2, 3, 4, 5})
StoragePartialPath = []byte{0, 1, 0, 2, 0, 4}
// Encoded data
accountRLP, _ = rlp.EncodeToBytes(&Account)
accountAndLeafRLP, _ = rlp.EncodeToBytes(&[]interface{}{AccountLeafKey, accountRLP})
AccountCID, _ = ipld.RawdataToCid(ipld.MEthStateTrie, accountAndLeafRLP, multihash.KECCAK_256)
AccountCodeCID, _ = util.Keccak256ToCid(ipld.RawBinary, AccountCodeHash.Bytes())
StoredValueRLP, _ = rlp.EncodeToBytes(StoredValue)
StoredValueRLP2, _ = rlp.EncodeToBytes("something")
NonCanonStoredValueRLP, _ = rlp.EncodeToBytes("something else")
StorageRLP, _ = rlp.EncodeToBytes(&[]interface{}{StoragePartialPath, StoredValueRLP})
StorageCID, _ = ipld.RawdataToCid(ipld.MEthStorageTrie, StorageRLP, multihash.KECCAK_256)
RemovedNodeStateCID = "baglacgzayxjemamg64rtzet6pwznzrydydsqbnstzkbcoo337lmaixmfurya"
RemovedNodeStorageCID = "bagmacgzayxjemamg64rtzet6pwznzrydydsqbnstzkbcoo337lmaixmfurya"
2023-03-05 07:33:51 +00:00
)
func TestSuite(t *testing.T) {
testConfig, err := getTestConfig()
require.NoError(t, err)
pool, err := statedb.NewPGXPool(testCtx, testConfig)
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() {
tx, err := pool.Begin(testCtx)
require.NoError(t, err)
statements := []string{
`DELETE FROM eth.header_cids`,
`DELETE FROM eth.state_cids`,
`DELETE FROM eth.storage_cids`,
`DELETE FROM ipld.blocks`,
}
for _, stm := range statements {
_, err = tx.Exec(testCtx, stm)
require.NoErrorf(t, err, "Exec(`%s`)", stm)
}
require.NoError(t, tx.Commit(testCtx))
})
require.NoError(t, insertHeaderCID(pool, BlockHash.String(), BlockParentHash.String(), BlockNumber.Uint64()))
require.NoError(t, insertHeaderCID(pool, BlockHash2.String(), BlockHash.String(), BlockNumber2))
require.NoError(t, insertHeaderCID(pool, BlockHash3.String(), BlockHash2.String(), BlockNumber3))
require.NoError(t, insertHeaderCID(pool, BlockHash4.String(), BlockHash3.String(), BlockNumber4))
2023-03-09 15:03:47 +00:00
require.NoError(t, insertHeaderCID(pool, NonCanonicalHash4.String(), BlockHash3.String(), BlockNumber4))
require.NoError(t, insertHeaderCID(pool, BlockHash5.String(), BlockHash4.String(), BlockNumber5))
2023-03-09 15:03:47 +00:00
require.NoError(t, insertHeaderCID(pool, NonCanonicalHash5.String(), NonCanonicalHash4.String(), BlockNumber5))
require.NoError(t, insertHeaderCID(pool, BlockHash6.String(), BlockHash5.String(), BlockNumber6))
require.NoError(t, insertStateCID(pool, stateModel{
BlockNumber: BlockNumber.Uint64(),
BlockHash: BlockHash.String(),
LeafKey: AccountLeafKey.String(),
CID: AccountCID.String(),
Diff: true,
Balance: Account.Balance.Uint64(),
Nonce: Account.Nonce,
CodeHash: AccountCodeHash.String(),
StorageRoot: Account.Root.String(),
Removed: false,
}))
require.NoError(t, insertStateCID(pool, stateModel{
2023-03-09 15:03:47 +00:00
BlockNumber: BlockNumber4,
BlockHash: NonCanonicalHash4.String(),
LeafKey: AccountLeafKey.String(),
CID: AccountCID.String(),
Diff: true,
2023-03-09 15:03:47 +00:00
Balance: big.NewInt(123).Uint64(),
Nonce: Account.Nonce,
CodeHash: AccountCodeHash.String(),
StorageRoot: Account.Root.String(),
Removed: false,
}))
require.NoError(t, insertStateCID(pool, stateModel{
2023-03-08 17:20:16 +00:00
BlockNumber: BlockNumber5,
BlockHash: BlockHash5.String(),
LeafKey: AccountLeafKey.String(),
2023-03-08 17:20:16 +00:00
CID: RemovedNodeStateCID,
Diff: true,
Removed: true,
}))
require.NoError(t, insertStorageCID(pool, storageModel{
BlockNumber: BlockNumber.Uint64(),
BlockHash: BlockHash.String(),
LeafKey: AccountLeafKey.String(),
StorageLeafKey: StorageLeafKey.String(),
StorageCID: StorageCID.String(),
Diff: true,
Value: StoredValueRLP,
Removed: false,
}))
require.NoError(t, insertStorageCID(pool, storageModel{
2023-03-08 17:20:16 +00:00
BlockNumber: BlockNumber2,
BlockHash: BlockHash2.String(),
LeafKey: AccountLeafKey.String(),
StorageLeafKey: StorageLeafKey.String(),
2023-03-08 17:20:16 +00:00
StorageCID: RemovedNodeStorageCID,
Diff: true,
Value: []byte{},
Removed: true,
}))
require.NoError(t, insertStorageCID(pool, storageModel{
2023-03-08 17:20:16 +00:00
BlockNumber: BlockNumber3,
BlockHash: BlockHash3.String(),
LeafKey: AccountLeafKey.String(),
StorageLeafKey: StorageLeafKey.String(),
StorageCID: StorageCID.String(),
Diff: true,
Value: StoredValueRLP2,
Removed: false,
}))
require.NoError(t, insertStorageCID(pool, storageModel{
BlockNumber: BlockNumber4,
BlockHash: NonCanonicalHash4.String(),
LeafKey: AccountLeafKey.String(),
StorageLeafKey: StorageLeafKey.String(),
StorageCID: StorageCID.String(),
Diff: true,
Value: NonCanonStoredValueRLP,
Removed: false,
}))
2023-03-05 07:33:51 +00:00
require.NoError(t, insertContractCode(pool))
db, err := statedb.NewStateDatabaseWithPool(pool)
require.NoError(t, err)
t.Run("Database", func(t *testing.T) {
2023-03-06 17:46:07 +00:00
size, err := db.ContractCodeSize(AccountCodeHash)
2023-03-05 07:33:51 +00:00
require.NoError(t, err)
require.Equal(t, len(AccountCode), size)
2023-03-06 17:46:07 +00:00
code, err := db.ContractCode(AccountCodeHash)
2023-03-05 07:33:51 +00:00
require.NoError(t, err)
require.Equal(t, AccountCode, code)
acct, err := db.StateAccount(AccountLeafKey, BlockHash)
require.NoError(t, err)
require.Equal(t, &Account, acct)
2023-03-08 17:20:16 +00:00
acct2, err := db.StateAccount(AccountLeafKey, BlockHash2)
require.NoError(t, err)
require.Equal(t, &Account, acct2)
2023-03-08 17:20:16 +00:00
acct3, err := db.StateAccount(AccountLeafKey, BlockHash3)
require.NoError(t, err)
require.Equal(t, &Account, acct3)
// check that we don't get the non-canonical account
2023-03-08 17:20:16 +00:00
acct4, err := db.StateAccount(AccountLeafKey, BlockHash4)
require.NoError(t, err)
2023-03-08 16:03:48 +00:00
require.Equal(t, &Account, acct4)
2023-03-08 17:20:16 +00:00
acct5, err := db.StateAccount(AccountLeafKey, BlockHash5)
2023-03-08 16:03:48 +00:00
require.NoError(t, err)
2023-03-08 17:20:16 +00:00
require.Nil(t, acct5)
acct6, err := db.StateAccount(AccountLeafKey, BlockHash6)
require.NoError(t, err)
require.Nil(t, acct6)
2023-03-05 07:33:51 +00:00
val, err := db.StorageValue(AccountLeafKey, StorageLeafKey, BlockHash)
require.NoError(t, err)
require.Equal(t, StoredValueRLP, val)
2023-03-08 17:20:16 +00:00
val2, err := db.StorageValue(AccountLeafKey, StorageLeafKey, BlockHash2)
require.NoError(t, err)
2023-03-08 17:20:16 +00:00
require.Nil(t, val2)
2023-03-08 17:20:16 +00:00
val3, err := db.StorageValue(AccountLeafKey, StorageLeafKey, BlockHash3)
require.NoError(t, err)
require.Equal(t, StoredValueRLP2, val3)
// this checks that we don't get the non-canonical result
2023-03-08 17:20:16 +00:00
val4, err := db.StorageValue(AccountLeafKey, StorageLeafKey, BlockHash4)
require.NoError(t, err)
2023-03-08 16:03:48 +00:00
require.Equal(t, StoredValueRLP2, val4)
// this checks that when the entire account was deleted, we return nil result for storage slot
2023-03-08 17:20:16 +00:00
val5, err := db.StorageValue(AccountLeafKey, StorageLeafKey, BlockHash5)
2023-03-08 16:03:48 +00:00
require.NoError(t, err)
2023-03-08 17:20:16 +00:00
require.Nil(t, val5)
val6, err := db.StorageValue(AccountLeafKey, StorageLeafKey, BlockHash6)
require.NoError(t, err)
require.Nil(t, val6)
2023-03-05 07:33:51 +00:00
})
t.Run("StateDB", func(t *testing.T) {
sdb, err := statedb.New(BlockHash, db)
require.NoError(t, err)
checkAccountUnchanged := func() {
require.Equal(t, Account.Balance, sdb.GetBalance(AccountAddress))
require.Equal(t, Account.Nonce, sdb.GetNonce(AccountAddress))
require.Equal(t, StoredValue, sdb.GetState(AccountAddress, StorageLeafKey))
require.Equal(t, AccountCodeHash, sdb.GetCodeHash(AccountAddress))
require.Equal(t, AccountCode, sdb.GetCode(AccountAddress))
require.Equal(t, len(AccountCode), sdb.GetCodeSize(AccountAddress))
}
require.True(t, sdb.Exist(AccountAddress))
checkAccountUnchanged()
id := sdb.Snapshot()
newStorage := crypto.Keccak256Hash([]byte{5, 4, 3, 2, 1})
newCode := []byte{1, 3, 3, 7}
sdb.SetBalance(AccountAddress, big.NewInt(300))
sdb.AddBalance(AccountAddress, big.NewInt(200))
sdb.SubBalance(AccountAddress, big.NewInt(100))
sdb.SetNonce(AccountAddress, 42)
sdb.SetState(AccountAddress, StorageLeafKey, newStorage)
sdb.SetCode(AccountAddress, newCode)
require.Equal(t, big.NewInt(400), sdb.GetBalance(AccountAddress))
require.Equal(t, uint64(42), sdb.GetNonce(AccountAddress))
require.Equal(t, newStorage, sdb.GetState(AccountAddress, StorageLeafKey))
require.Equal(t, newCode, sdb.GetCode(AccountAddress))
sdb.AddSlotToAccessList(AccountAddress, StorageLeafKey)
require.True(t, sdb.AddressInAccessList(AccountAddress))
hasAddr, hasSlot := sdb.SlotInAccessList(AccountAddress, StorageLeafKey)
require.True(t, hasAddr)
require.True(t, hasSlot)
sdb.RevertToSnapshot(id)
checkAccountUnchanged()
require.False(t, sdb.AddressInAccessList(AccountAddress))
hasAddr, hasSlot = sdb.SlotInAccessList(AccountAddress, StorageLeafKey)
require.False(t, hasAddr)
require.False(t, hasSlot)
})
}
func insertHeaderCID(db *pgxpool.Pool, blockHash, parentHash string, blockNumber uint64) error {
cid, err := util.Keccak256ToCid(ipld.MEthHeader, common.HexToHash(blockHash).Bytes())
if err != nil {
return err
}
2023-03-05 07:33:51 +00:00
sql := `INSERT INTO eth.header_cids (
block_number,
block_hash,
parent_hash,
cid,
td,
node_ids,
reward,
state_root,
tx_root,
receipt_root,
uncles_hash,
bloom,
timestamp,
coinbase
) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14)`
_, err = db.Exec(testCtx, sql,
blockNumber,
blockHash,
parentHash,
cid.String(),
2023-03-05 07:33:51 +00:00
0, []string{}, 0,
Header.Root.String(),
Header.TxHash.String(),
Header.ReceiptHash.String(),
2023-03-08 17:20:16 +00:00
Header.UncleHash.String(),
2023-03-05 07:33:51 +00:00
[]byte{},
Header.Time,
Header.Coinbase.String(),
)
return err
}
type stateModel struct {
BlockNumber uint64
BlockHash string
LeafKey string
CID string
Diff bool
Balance uint64
Nonce uint64
CodeHash string
StorageRoot string
Removed bool
}
func insertStateCID(db *pgxpool.Pool, cidModel stateModel) error {
2023-03-05 07:33:51 +00:00
sql := `INSERT INTO eth.state_cids (
block_number,
header_id,
state_leaf_key,
cid,
diff,
balance,
nonce,
code_hash,
storage_root,
removed
) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)`
_, err := db.Exec(testCtx, sql,
cidModel.BlockNumber,
cidModel.BlockHash,
cidModel.LeafKey,
cidModel.CID,
cidModel.Diff,
cidModel.Balance,
cidModel.Nonce,
cidModel.CodeHash,
cidModel.StorageRoot,
cidModel.Removed,
2023-03-05 07:33:51 +00:00
)
return err
}
type storageModel struct {
BlockNumber uint64
BlockHash string
LeafKey string
StorageLeafKey string
StorageCID string
Diff bool
Value []byte
Removed bool
}
func insertStorageCID(db *pgxpool.Pool, cidModel storageModel) error {
2023-03-05 07:33:51 +00:00
sql := `INSERT INTO eth.storage_cids (
block_number,
header_id,
state_leaf_key,
storage_leaf_key,
cid,
diff,
val,
removed
) VALUES ($1, $2, $3, $4, $5, $6, $7, $8)`
_, err := db.Exec(testCtx, sql,
cidModel.BlockNumber,
cidModel.BlockHash,
cidModel.LeafKey,
cidModel.StorageLeafKey,
cidModel.StorageCID,
cidModel.Diff,
cidModel.Value,
cidModel.Removed,
2023-03-05 07:33:51 +00:00
)
return err
}
func insertContractCode(db *pgxpool.Pool) error {
sql := `INSERT INTO ipld.blocks (block_number, key, data) VALUES ($1, $2, $3)`
_, err := db.Exec(testCtx, sql, BlockNumber.Uint64(), AccountCodeCID, AccountCode)
return err
}
func getTestConfig() (conf statedb.Config, err error) {
port, err := strconv.Atoi(os.Getenv("DATABASE_PORT"))
if err != nil {
return
}
return statedb.Config{
Hostname: os.Getenv("DATABASE_HOSTNAME"),
DatabaseName: os.Getenv("DATABASE_NAME"),
Username: os.Getenv("DATABASE_USER"),
Password: os.Getenv("DATABASE_PASSWORD"),
Port: port,
}, nil
}