* Write state diff to CSV (#2) * port statediff from9b7fd9af80/statediff/statediff.go
; minor fixes * integrating state diff extracting, building, and persisting into geth processes * work towards persisting created statediffs in ipfs; based off github.com/vulcanize/eth-block-extractor * Add a state diff service * Remove diff extractor from blockchain * Update imports * Move statediff on/off check to geth cmd config * Update starting state diff service * Add debugging logs for creating diff * Add statediff extractor and builder tests and small refactoring * Start to write statediff to a CSV * Restructure statediff directory * Pull CSV publishing methods into their own file * Reformatting due to go fmt * Add gomega to vendor dir * Remove testing focuses * Update statediff tests to use golang test pkg instead of ginkgo - builder_test - extractor_test - publisher_test * Use hexutil.Encode instead of deprecated common.ToHex * Remove OldValue from DiffBigInt and DiffUint64 fields * Update builder test * Remove old storage value from updated accounts * Remove old values from created/deleted accounts * Update publisher to account for only storing current account values * Update service loop and fetching previous block * Update testing - remove statediff ginkgo test suite file - move mocks to their own dir * Updates per go fmt * Updates to tests * Pass statediff mode and path in through cli * Return filename from publisher * Remove some duplication in builder * Remove code field from state diff output this is the contract byte code, and it can still be obtained by querying the db by the codeHash * Consolidate acct diff structs for updated & updated/deleted accts * Include block number in csv filename * Clean up error logging * Cleanup formatting, spelling, etc * Address PR comments * Add contract address and storage value to csv * Refactor accumulating account row in csv publisher * Add DiffStorage struct * Add storage key to csv * Address PR comments * Fix publisher to include rows for accounts that don't have store updates * Update builder test after merging in release/1.8 * Update test contract to include storage on contract intialization - so that we're able to test that storage diffing works for created and deleted accounts (not just updated accounts). * Factor out a common trie iterator method in builder * Apply goimports to statediff * Apply gosimple changes to statediff * Gracefully exit geth command(#4) * Statediff for full node (#6) * Open a trie from the in-memory database * Use a node's LeafKey as an identifier instead of the address It was proving difficult to find look the address up from a given path with a full node (sometimes the value wouldn't exist in the disk db). So, instead, for now we are using the node's LeafKey with is a Keccak256 hash of the address, so if we know the address we can figure out which LeafKey it matches up to. * Make sure that statediff has been processed before pruning * Use blockchain stateCache.OpenTrie for storage diffs * Clean up log lines and remove unnecessary fields from builder * Apply go fmt changes * Add a sleep to the blockchain test * refactoring/reorganizing packages * refactoring statediff builder and types and adjusted to relay proofs and paths (still need to make this optional) * refactoring state diff service and adding api which allows for streaming state diff payloads over an rpc websocket subscription * make proofs and paths optional + compress service loop into single for loop (may be missing something here) * option to process intermediate nodes * make state diff rlp serializable * cli parameter to limit statediffing to select account addresses + test * review fixes and fixes for issues ran into in integration * review fixes; proper method signature for api; adjust service so that statediff processing is halted/paused until there is at least one subscriber listening for the results * adjust buffering to improve stability; doc.go; fix notifier err handling * relay receipts with the rest of the data + review fixes/changes * rpc method to get statediff at specific block; requires archival node or the block be within the pruning range * fix linter issues * include total difficulty to the payload * fix state diff builder: emit actual leaf nodes instead of value nodes; diff on the leaf not on the value; emit correct path for intermediate nodes * adjust statediff builder tests to changes and extend to test intermediate nodes; golint * add genesis block to test; handle block 0 in StateDiffAt * rlp files for mainnet blocks 0-3, for tests * builder test on mainnet blocks * common.BytesToHash(path) => crypto.Keaccak256(hash) in builder; BytesToHash produces same hash for e.g. []byte{} and []byte{\x00} - prefix \x00 steps are inconsequential to the hash result * complete tests for early mainnet blocks * diff type for representing deleted accounts * fix builder so that we handle account deletions properly and properly diff storage when an account is moved to a new path; update params * remove cli params; moving them to subscriber defined * remove unneeded bc methods * update service and api; statediffing params are now defined by user through api rather than by service provider by cli * update top level tests * add ability to watch specific storage slots (leaf keys) only * comments; explain logic * update mainnet blocks test * update api_test.go * storage leafkey filter test * cleanup chain maker * adjust chain maker for tests to add an empty account in block1 and switch to EIP-158 afterwards (now we just need to generate enough accounts until one causes the empty account to be touched and removed post-EIP-158 so we can simulate and test that process...); also added 2 new blocks where more contract storage is set and old slots are set to zero so they are removed so we can test that * found an account whose creation causes the empty account to be moved to a new path; this should count as 'touching; the empty account and cause it to be removed according to eip-158... but it doesn't * use new contract in unit tests that has self-destruct ability, so we can test eip-158 since simply moving an account to new path doesn't count as 'touchin' it * handle storage deletions * tests for eip-158 account removal and storage value deletions; there is one edge case left to test where we remove 1 account when only two exist such that the remaining account is moved up and replaces the root branch node * finish testing known edge cases * add endpoint to fetch all state and storage nodes at a given blockheight; useful for generating a recent atate cache/snapshot that we can diff forward from rather than needing to collect all diffs from genesis * test for state trie builder * if statediffing is on, lock tries in triedb until the statediffing service signals they are done using them * fix mock blockchain; golint; bump patch * increase maxRequestContentLength; bump patch * log the sizes of the state objects we are sending * CI build (#20) * CI: run build on PR and on push to master * CI: debug building geth * CI: fix coping file * CI: fix coping file v2 * CI: temporary upload file to release asset * CI: get release upload_url by tag, upload asset to current relase * CI: fix tag name * fix ci build on statediff_at_anyblock-1.9.11 branch * fix publishing assets in release * use context deadline for timeout in eth_call * collect and emit codehash=>code mappings for state objects * subscription endpoint for retrieving all the codehash=>code mappings that exist at provided height * Implement WriteStateDiffAt * Writes state diffs directly to postgres * Adds CLI flags to configure PG * Refactors builder output with callbacks * Copies refactored postgres handling code from ipld-eth-indexer * rename PostgresCIDWriter.{index->upsert}* * rm unused * output code & codehash iteratively * had to rf some types for this * prometheus metrics output * duplicate recent eth-indexer changes * migrations and metrics... * [wip] prom.Init() here? another CLI flag? * tidy & DRY * statediff WriteLoop service + CLI flag * [wip] update test mocks * todo - do something meaningful to test write loop * logging * use geth log * port tests to go testing * drop ginkgo/gomega * fix and cleanup tests * fail before defer statement * delete vendor/ dir * fixes after rebase onto 1.9.23 * fix API registration * use golang 1.15.5 version (#34) * bump version meta; add 0.0.11 branch to actions * bump version meta; update github actions workflows * statediff: refactor metrics * Remove redundant statediff/indexer/prom tooling and use existing prometheus integration. * "indexer" namespace for metrics * add reporting loop for db metrics * doc * metrics for statediff stats * metrics namespace/subsystem = statediff/{indexer,service} * statediff: use a worker pool (for direct writes) * fix test * fix chain event subscription * log tweaks * func name * unused import * intermediate chain event channel for metrics * update github actions; linting * add poststate and status to receipt ipld indexes * stateDiffFor endpoints for fetching or writing statediff object by blockhash; bump statediff version * fixes after rebase on to v1.10.1 * update github actions and version meta; go fmt * add leaf key to removed 'nodes' * include Postgres migrations and schema * service documentation * touching up * update github actions after rebase * fix connection leak (misplaced defer) and perform proper rollback on errs * improve error logging; handle PushBlock internal err * build docker image and publish it to Docker Hub on release * add access list tx to unit tests * MarshalBinary and UnmarshalBinary methods for receipt * fix error caused by 2718 by using MarshalBinary instead of EncodeRLP methods * ipld encoding/decoding tests * update TxModel; add AccessListElementModel * index tx type and access lists * add access list metrics * unit tests for tx_type and access list table * unit tests for receipt marshal/unmarshal binary methods * improve documentation of the encoding methods * fix issue identified in linting * update github actions and version meta after rebase * unit test that fails undeterministically on eip2930 txs, giving same error we are seeing in prod * Include genesis block state diff. * documentation on versioning, rebasing, releasing; bump version meta * Add geth and statediff unit test to CI. * Set pgpassword in env. * Added comments. * Add new major branch to github action. * Add support for Dynamic txn(EIP-1559). * Update version meta to 0.0.24 * Verify block base fee in test. * Fix base_fee type and add backward compatible test. * Remove type definition for AccessListElementModel * Change basefee to int64/bigint. * block and uncle reward in PoA network = 0 (#87) * in PoA networks there is no block and uncle rewards * bump meta version * (cherry picked from commitb64ca14689
) * Use Ropsten to test block reward. * Add Makefile target to build static linux binaries. * Strip symbol tables from static binaries. * Fix block_fee to support NULL values. * bump version meta. * Add new major branch to github action. * rename doc.go to README.md * Create a seperate table for storing logs * Bump statediff version to 0.0.26. * add btree index to state/storage_cids.node_type; updated schema * Dedup receipt data. * Fix linter errors. * Address comments. * Bump statediff version to 0.0.27. * new cli flag for initializing db first time service is ran * only write Removed node ipld block (on db init) and reuse constant cid and mhkey * test new handling of Removed nodes; don't require init flag * log metrics * Add new major branch to github action. * Fix build. * Update golang version in CI. * Use ipld-eth-db in testing. * Remove migration from repo. * Add new major branch to github action. *Use `GetTd` instead of `GetTdByHash`6289137827
* Add new major branch to github action. * Report DB metrics * batch inserts to public.blocks * v2 => v3 major refactor * fixes and cli integration for new options * update example command in readme * ashwin's fix for failing pgx unit test * update to use new schema; fix pgx driver * indexer that writes sql stmts out to a file * cli integration * fix unit tests * use node_id as PK/FK * misc fixes/adjustments * update README * cleanup; more unit tests * basefee is big.Int, it won't always fit in int64 * adjust for schema updates * finish unit tests * test harnest for arbitrary mainnet blocks and receipts * cache problematic block locally for quicker testing/easier CI testing * fix issue with log/logTrie processing * remove some unecessary hashing operations * handle edge case * add more 'bad blocks' to mainnet_tests * increase file write buffer size * increase buffer further * fix rct trie multicodec type * extend testing * log trie fk fix * bump statediff meta version; use db v0.3.0 in compose * skip file writing tests in CI, for now * prevent parallel execution of tests in different pkgs (suspect this is what causes our deadlock to show up only in CI test env) adjust write buffering * fix rct unit tests * fix README formatting * port retry on deadlock detection feature * new workflow on-'master' targets * update version meta * improve test coverage for logs * fix possible race condition * fix CI * check tx pool state at end of unit tests * better logging of rollbacks and dead lock retries
156 lines
4.5 KiB
Go
156 lines
4.5 KiB
Go
// Copyright 2014 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 trie
|
|
|
|
// Trie keys are dealt with in three distinct encodings:
|
|
//
|
|
// KEYBYTES encoding contains the actual key and nothing else. This encoding is the
|
|
// input to most API functions.
|
|
//
|
|
// HEX encoding contains one byte for each nibble of the key and an optional trailing
|
|
// 'terminator' byte of value 0x10 which indicates whether or not the node at the key
|
|
// contains a value. Hex key encoding is used for nodes loaded in memory because it's
|
|
// convenient to access.
|
|
//
|
|
// COMPACT encoding is defined by the Ethereum Yellow Paper (it's called "hex prefix
|
|
// encoding" there) and contains the bytes of the key and a flag. The high nibble of the
|
|
// first byte contains the flag; the lowest bit encoding the oddness of the length and
|
|
// the second-lowest encoding whether the node at the key is a value node. The low nibble
|
|
// of the first byte is zero in the case of an even number of nibbles and the first nibble
|
|
// in the case of an odd number. All remaining nibbles (now an even number) fit properly
|
|
// into the remaining bytes. Compact encoding is used for nodes stored on disk.
|
|
|
|
// HexToCompact converts a hex path to the compact encoded format
|
|
func HexToCompact(hex []byte) []byte {
|
|
return hexToCompact(hex)
|
|
}
|
|
|
|
func hexToCompact(hex []byte) []byte {
|
|
terminator := byte(0)
|
|
if hasTerm(hex) {
|
|
terminator = 1
|
|
hex = hex[:len(hex)-1]
|
|
}
|
|
buf := make([]byte, len(hex)/2+1)
|
|
buf[0] = terminator << 5 // the flag byte
|
|
if len(hex)&1 == 1 {
|
|
buf[0] |= 1 << 4 // odd flag
|
|
buf[0] |= hex[0] // first nibble is contained in the first byte
|
|
hex = hex[1:]
|
|
}
|
|
decodeNibbles(hex, buf[1:])
|
|
return buf
|
|
}
|
|
|
|
// hexToCompactInPlace places the compact key in input buffer, returning the length
|
|
// needed for the representation
|
|
func hexToCompactInPlace(hex []byte) int {
|
|
var (
|
|
hexLen = len(hex) // length of the hex input
|
|
firstByte = byte(0)
|
|
)
|
|
// Check if we have a terminator there
|
|
if hexLen > 0 && hex[hexLen-1] == 16 {
|
|
firstByte = 1 << 5
|
|
hexLen-- // last part was the terminator, ignore that
|
|
}
|
|
var (
|
|
binLen = hexLen/2 + 1
|
|
ni = 0 // index in hex
|
|
bi = 1 // index in bin (compact)
|
|
)
|
|
if hexLen&1 == 1 {
|
|
firstByte |= 1 << 4 // odd flag
|
|
firstByte |= hex[0] // first nibble is contained in the first byte
|
|
ni++
|
|
}
|
|
for ; ni < hexLen; bi, ni = bi+1, ni+2 {
|
|
hex[bi] = hex[ni]<<4 | hex[ni+1]
|
|
}
|
|
hex[0] = firstByte
|
|
return binLen
|
|
}
|
|
|
|
// CompactToHex converts a compact encoded path to hex format
|
|
func CompactToHex(compact []byte) []byte {
|
|
return compactToHex(compact)
|
|
}
|
|
|
|
func compactToHex(compact []byte) []byte {
|
|
if len(compact) == 0 {
|
|
return compact
|
|
}
|
|
base := keybytesToHex(compact)
|
|
// delete terminator flag
|
|
if base[0] < 2 {
|
|
base = base[:len(base)-1]
|
|
}
|
|
// apply odd flag
|
|
chop := 2 - base[0]&1
|
|
return base[chop:]
|
|
}
|
|
|
|
func keybytesToHex(str []byte) []byte {
|
|
l := len(str)*2 + 1
|
|
var nibbles = make([]byte, l)
|
|
for i, b := range str {
|
|
nibbles[i*2] = b / 16
|
|
nibbles[i*2+1] = b % 16
|
|
}
|
|
nibbles[l-1] = 16
|
|
return nibbles
|
|
}
|
|
|
|
// hexToKeyBytes turns hex nibbles into key bytes.
|
|
// This can only be used for keys of even length.
|
|
func hexToKeyBytes(hex []byte) []byte {
|
|
if hasTerm(hex) {
|
|
hex = hex[:len(hex)-1]
|
|
}
|
|
if len(hex)&1 != 0 {
|
|
panic("can't convert hex key of odd length")
|
|
}
|
|
key := make([]byte, len(hex)/2)
|
|
decodeNibbles(hex, key)
|
|
return key
|
|
}
|
|
|
|
func decodeNibbles(nibbles []byte, bytes []byte) {
|
|
for bi, ni := 0, 0; ni < len(nibbles); bi, ni = bi+1, ni+2 {
|
|
bytes[bi] = nibbles[ni]<<4 | nibbles[ni+1]
|
|
}
|
|
}
|
|
|
|
// prefixLen returns the length of the common prefix of a and b.
|
|
func prefixLen(a, b []byte) int {
|
|
var i, length = 0, len(a)
|
|
if len(b) < length {
|
|
length = len(b)
|
|
}
|
|
for ; i < length; i++ {
|
|
if a[i] != b[i] {
|
|
break
|
|
}
|
|
}
|
|
return i
|
|
}
|
|
|
|
// hasTerm returns whether a hex key has the terminator flag.
|
|
func hasTerm(s []byte) bool {
|
|
return len(s) > 0 && s[len(s)-1] == 16
|
|
}
|