func (b *memBatch) Put(key, value []byte) error { b.lock.Lock() defer b.lock.Unlock() b.writes = append(b.writes, kv{common.CopyBytes(key), common.CopyBytes(value)}) return nil }
func TestReset(t *testing.T) { trie := NewEmpty() vals := []struct{ k, v string }{ {"do", "verb"}, {"expanse", "wookiedoo"}, {"horse", "stallion"}, } for _, val := range vals { trie.UpdateString(val.k, val.v) } trie.Commit() before := common.CopyBytes(trie.roothash) trie.UpdateString("should", "revert") trie.Hash() // Should have no effect trie.Hash() trie.Hash() // ### trie.Reset() after := common.CopyBytes(trie.roothash) if !bytes.Equal(before, after) { t.Errorf("expected roots to be equal. %x - %x", before, after) } }
func (self *StateObject) Copy() *StateObject { stateObject := NewStateObject(self.Address(), self.db) stateObject.balance.Set(self.balance) stateObject.codeHash = common.CopyBytes(self.codeHash) stateObject.nonce = self.nonce stateObject.trie = self.trie stateObject.code = common.CopyBytes(self.code) stateObject.initCode = common.CopyBytes(self.initCode) stateObject.storage = self.storage.Copy() stateObject.remove = self.remove stateObject.dirty = self.dirty stateObject.deleted = self.deleted return stateObject }
func NewTransaction(nonce uint64, to common.Address, amount, gasLimit, gasPrice *big.Int, data []byte) *Transaction { if len(data) > 0 { data = common.CopyBytes(data) } d := txdata{ AccountNonce: nonce, Recipient: &to, Payload: data, Amount: new(big.Int), GasLimit: new(big.Int), Price: new(big.Int), R: new(big.Int), S: new(big.Int), } if amount != nil { d.Amount.Set(amount) } if gasLimit != nil { d.GasLimit.Set(gasLimit) } if gasPrice != nil { d.Price.Set(gasPrice) } return &Transaction{data: d} }
func (db *MemDatabase) Put(key []byte, value []byte) error { db.lock.Lock() defer db.lock.Unlock() db.db[string(key)] = common.CopyBytes(value) return nil }
// TryUpdate associates key with value in the trie. Subsequent calls to // Get will return value. If value has length zero, any existing value // is deleted from the trie and calls to Get will return nil. // // The value bytes must not be modified by the caller while they are // stored in the trie. // // If a node was not found in the database, a MissingNodeError is returned. func (t *SecureTrie) TryUpdate(key, value []byte) error { hk := t.hashKey(key) err := t.trie.TryUpdate(hk, value) if err != nil { return err } t.getSecKeyCache()[string(hk)] = common.CopyBytes(key) return nil }
func NewContractCreation(nonce uint64, amount, gasLimit, gasPrice *big.Int, data []byte) *Transaction { if len(data) > 0 { data = common.CopyBytes(data) } return &Transaction{data: txdata{ AccountNonce: nonce, Recipient: nil, Amount: new(big.Int).Set(amount), GasLimit: new(big.Int).Set(gasLimit), Price: new(big.Int).Set(gasPrice), Payload: data, R: new(big.Int), S: new(big.Int), }} }
// hashChildren replaces the children of a node with their hashes if the encoded // size of the child is larger than a hash, returning the collapsed node as well // as a replacement for the original node with the child hashes cached in. func (h *hasher) hashChildren(original node, db DatabaseWriter) (node, node, error) { var err error switch n := original.(type) { case shortNode: // Hash the short node's child, caching the newly hashed subtree cached := n cached.Key = common.CopyBytes(cached.Key) n.Key = compactEncode(n.Key) if _, ok := n.Val.(valueNode); !ok { if n.Val, cached.Val, err = h.hash(n.Val, db, false); err != nil { return n, original, err } } if n.Val == nil { n.Val = valueNode(nil) // Ensure that nil children are encoded as empty strings. } return n, cached, nil case fullNode: // Hash the full node's children, caching the newly hashed subtrees cached := fullNode{dirty: n.dirty} for i := 0; i < 16; i++ { if n.Children[i] != nil { if n.Children[i], cached.Children[i], err = h.hash(n.Children[i], db, false); err != nil { return n, original, err } } else { n.Children[i] = valueNode(nil) // Ensure that nil children are encoded as empty strings. } } cached.Children[16] = n.Children[16] if n.Children[16] == nil { n.Children[16] = valueNode(nil) } return n, cached, nil default: // Value and hash nodes don't have children so they're left as were return n, original, nil } }
func (tx *Transaction) Data() []byte { return common.CopyBytes(tx.data.Payload) }
func (self *HashNode) Copy(t *Trie) Node { return NewHash(common.CopyBytes(self.key), t) }
// NewReceipt creates a barebone transaction receipt, copying the init fields. func NewReceipt(root []byte, cumulativeGasUsed *big.Int) *Receipt { return &Receipt{PostState: common.CopyBytes(root), CumulativeGasUsed: new(big.Int).Set(cumulativeGasUsed)} }
func (self *ShortNode) Copy(t *Trie) Node { node := &ShortNode{t, nil, self.value.Copy(t), self.dirty} node.key = common.CopyBytes(self.key) node.dirty = true return node }
func (b *Block) Extra() []byte { return common.CopyBytes(b.header.Extra) }
func (self *ValueNode) Copy(t *Trie) Node { return &ValueNode{t, common.CopyBytes(self.data), self.dirty} }