github.com/daeglee/go-ethereum@v0.0.0-20190504220456-cad3e8d18e9b/core/rawdb/schema.go (about) 1 // Copyright 2018 The go-ethereum Authors 2 // This file is part of the go-ethereum library. 3 // 4 // The go-ethereum library is free software: you can redistribute it and/or modify 5 // it under the terms of the GNU Lesser General Public License as published by 6 // the Free Software Foundation, either version 3 of the License, or 7 // (at your option) any later version. 8 // 9 // The go-ethereum library is distributed in the hope that it will be useful, 10 // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 // GNU Lesser General Public License for more details. 13 // 14 // You should have received a copy of the GNU Lesser General Public License 15 // along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>. 16 17 // Package rawdb contains a collection of low level database accessors. 18 package rawdb 19 20 import ( 21 "encoding/binary" 22 23 "github.com/ethereum/go-ethereum/common" 24 "github.com/ethereum/go-ethereum/metrics" 25 ) 26 27 // The fields below define the low level database schema prefixing. 28 var ( 29 // databaseVerisionKey tracks the current database version. 30 databaseVerisionKey = []byte("DatabaseVersion") 31 32 // headHeaderKey tracks the latest know header's hash. 33 headHeaderKey = []byte("LastHeader") 34 35 // headBlockKey tracks the latest know full block's hash. 36 headBlockKey = []byte("LastBlock") 37 38 // headFastBlockKey tracks the latest known incomplete block's hash during fast sync. 39 headFastBlockKey = []byte("LastFast") 40 41 // fastTrieProgressKey tracks the number of trie entries imported during fast sync. 42 fastTrieProgressKey = []byte("TrieSync") 43 44 // Data item prefixes (use single byte to avoid mixing data types, avoid `i`, used for indexes). 45 headerPrefix = []byte("h") // headerPrefix + num (uint64 big endian) + hash -> header 46 headerTDSuffix = []byte("t") // headerPrefix + num (uint64 big endian) + hash + headerTDSuffix -> td 47 headerHashSuffix = []byte("n") // headerPrefix + num (uint64 big endian) + headerHashSuffix -> hash 48 headerNumberPrefix = []byte("H") // headerNumberPrefix + hash -> num (uint64 big endian) 49 50 blockBodyPrefix = []byte("b") // blockBodyPrefix + num (uint64 big endian) + hash -> block body 51 blockReceiptsPrefix = []byte("r") // blockReceiptsPrefix + num (uint64 big endian) + hash -> block receipts 52 53 txLookupPrefix = []byte("l") // txLookupPrefix + hash -> transaction/receipt lookup metadata 54 bloomBitsPrefix = []byte("B") // bloomBitsPrefix + bit (uint16 big endian) + section (uint64 big endian) + hash -> bloom bits 55 56 preimagePrefix = []byte("secure-key-") // preimagePrefix + hash -> preimage 57 configPrefix = []byte("ethereum-config-") // config prefix for the db 58 59 // Chain index prefixes (use `i` + single byte to avoid mixing data types). 60 BloomBitsIndexPrefix = []byte("iB") // BloomBitsIndexPrefix is the data table of a chain indexer to track its progress 61 62 ebnIndexPrefix= []byte("e") // Prefix + blocknumber + index + suffix => hash 63 ebnIndexSuffix= []byte("x") // Prefix + blocknumber + index + suffix => hash 64 ebnLaterPrefix= []byte("E") // Prefix + blocknumber + index + hash => txl 65 66 preimageCounter = metrics.NewRegisteredCounter("db/preimage/total", nil) 67 preimageHitCounter = metrics.NewRegisteredCounter("db/preimage/hits", nil) 68 ) 69 70 // LegacyTxLookupEntry is the legacy TxLookupEntry definition with some unnecessary 71 // fields. 72 type LegacyTxLookupEntry struct { 73 BlockHash common.Hash 74 BlockIndex uint64 75 Index uint64 76 } 77 78 // encodeBlockNumber encodes a block number as big endian uint64 79 func encodeBlockNumber(number uint64) []byte { 80 enc := make([]byte, 8) 81 binary.BigEndian.PutUint64(enc, number) 82 return enc 83 } 84 85 // headerKeyPrefix = headerPrefix + num (uint64 big endian) 86 func headerKeyPrefix(number uint64) []byte { 87 return append(headerPrefix, encodeBlockNumber(number)...) 88 } 89 90 // headerKey = headerPrefix + num (uint64 big endian) + hash 91 func headerKey(number uint64, hash common.Hash) []byte { 92 return append(append(headerPrefix, encodeBlockNumber(number)...), hash.Bytes()...) 93 } 94 95 // headerTDKey = headerPrefix + num (uint64 big endian) + hash + headerTDSuffix 96 func headerTDKey(number uint64, hash common.Hash) []byte { 97 return append(headerKey(number, hash), headerTDSuffix...) 98 } 99 100 // headerHashKey = headerPrefix + num (uint64 big endian) + headerHashSuffix 101 func headerHashKey(number uint64) []byte { 102 return append(append(headerPrefix, encodeBlockNumber(number)...), headerHashSuffix...) 103 } 104 105 // headerNumberKey = headerNumberPrefix + hash 106 func headerNumberKey(hash common.Hash) []byte { 107 return append(headerNumberPrefix, hash.Bytes()...) 108 } 109 110 // blockBodyKey = blockBodyPrefix + num (uint64 big endian) + hash 111 func blockBodyKey(number uint64, hash common.Hash) []byte { 112 return append(append(blockBodyPrefix, encodeBlockNumber(number)...), hash.Bytes()...) 113 } 114 115 // blockReceiptsKey = blockReceiptsPrefix + num (uint64 big endian) + hash 116 func blockReceiptsKey(number uint64, hash common.Hash) []byte { 117 return append(append(blockReceiptsPrefix, encodeBlockNumber(number)...), hash.Bytes()...) 118 } 119 120 // txLookupKey = txLookupPrefix + hash 121 func txLookupKey(hash common.Hash) []byte { 122 return append(txLookupPrefix, hash.Bytes()...) 123 } 124 125 // bloomBitsKey = bloomBitsPrefix + bit (uint16 big endian) + section (uint64 big endian) + hash 126 func bloomBitsKey(bit uint, section uint64, hash common.Hash) []byte { 127 key := append(append(bloomBitsPrefix, make([]byte, 10)...), hash.Bytes()...) 128 129 binary.BigEndian.PutUint16(key[1:], uint16(bit)) 130 binary.BigEndian.PutUint64(key[3:], section) 131 132 return key 133 } 134 135 // preimageKey = preimagePrefix + hash 136 func preimageKey(hash common.Hash) []byte { 137 return append(preimagePrefix, hash.Bytes()...) 138 } 139 140 // configKey = configPrefix + hash 141 func configKey(hash common.Hash) []byte { 142 return append(configPrefix, hash.Bytes()...) 143 } 144 // executionIndexKey = ebnPrefix + Index (uint16 big endian) + blockNumber (uint64 big endian) + hash 145 func futureIndexKey(index uint, number uint64) []byte { 146 key := append(append(ebnIndexPrefix, make([]byte, 10)...), ebnIndexSuffix...) 147 148 binary.BigEndian.PutUint16(key[1:], uint16(index)) 149 binary.BigEndian.PutUint64(key[3:], number) 150 151 return key 152 } 153 154 // executionIndexKey = ebnPrefix + Index (uint16 big endian) + blockNumber (uint64 big endian) + hash 155 func futureTxKey(index uint, number uint64, hash common.Hash) []byte { 156 key := append(append(ebnLaterPrefix, make([]byte, 10)...), hash.Bytes()...) 157 158 binary.BigEndian.PutUint16(key[1:], uint16(index)) 159 binary.BigEndian.PutUint64(key[3:], number) 160 161 return key 162 }