From e7171f6601c236da05253ef36113149817f8b6d6 Mon Sep 17 00:00:00 2001 From: soham Date: Tue, 23 Apr 2024 13:59:48 +0530 Subject: [PATCH] Transient Storage Support (#1797) https://github.com/privacy-scaling-explorations/zkevm-circuits/issues/1761 - [x] Geth utils update - [x] TLOAD TSTORE in bus mapping - [x] TLOAD TSTORE in zkevm circuits --------- Co-authored-by: Miha Stopar Co-authored-by: Chih Cheng Liang --- bus-mapping/src/circuit_input_builder.rs | 1 + .../circuit_input_builder/input_state_ref.rs | 4 + bus-mapping/src/evm/opcodes.rs | 11 +- bus-mapping/src/evm/opcodes/tload.rs | 136 ++++++ bus-mapping/src/evm/opcodes/tstore.rs | 215 ++++++++++ bus-mapping/src/exec_trace.rs | 1 + bus-mapping/src/operation.rs | 104 ++++- bus-mapping/src/operation/container.rs | 12 +- bus-mapping/src/state_db.rs | 24 ++ eth-types/src/error.rs | 2 + eth-types/src/evm_types.rs | 2 + eth-types/src/evm_types/opcode_ids.rs | 16 +- eth-types/src/evm_types/transient_storage.rs | 67 +++ external-tracer/src/lib.rs | 10 +- geth-utils/gethutil/mpt/oracle/prefetch.go | 2 +- geth-utils/gethutil/mpt/state/state_object.go | 42 +- geth-utils/gethutil/mpt/state/statedb.go | 34 +- geth-utils/gethutil/trace.go | 112 ++++- geth-utils/go.mod | 64 ++- geth-utils/go.sum | 399 +++++------------- geth-utils/src/block.rs | 4 +- zkevm-circuits/src/evm_circuit/execution.rs | 10 + .../src/evm_circuit/execution/sstore.rs | 2 +- .../src/evm_circuit/execution/tload.rs | 164 +++++++ .../src/evm_circuit/execution/tstore.rs | 181 ++++++++ zkevm-circuits/src/evm_circuit/param.rs | 2 +- zkevm-circuits/src/evm_circuit/step.rs | 6 + .../evm_circuit/util/constraint_builder.rs | 50 +++ zkevm-circuits/src/witness/rw.rs | 55 ++- 29 files changed, 1334 insertions(+), 398 deletions(-) create mode 100644 bus-mapping/src/evm/opcodes/tload.rs create mode 100644 bus-mapping/src/evm/opcodes/tstore.rs create mode 100644 eth-types/src/evm_types/transient_storage.rs create mode 100644 zkevm-circuits/src/evm_circuit/execution/tload.rs create mode 100644 zkevm-circuits/src/evm_circuit/execution/tstore.rs diff --git a/bus-mapping/src/circuit_input_builder.rs b/bus-mapping/src/circuit_input_builder.rs index 8f6e1d6a0c..b92ef9cb34 100644 --- a/bus-mapping/src/circuit_input_builder.rs +++ b/bus-mapping/src/circuit_input_builder.rs @@ -460,6 +460,7 @@ impl<'a, C: CircuitsParams> CircuitInputBuilder { // Generate EndTx step let end_tx_step = gen_associated_steps(&mut self.state_ref(&mut tx, &mut tx_ctx), ExecState::EndTx)?; + self.sdb.clear_transient_storage(); tx.steps_mut().push(end_tx_step.clone()); (end_tx_step, last_call) } else if self.feature_config.invalid_tx { diff --git a/bus-mapping/src/circuit_input_builder/input_state_ref.rs b/bus-mapping/src/circuit_input_builder/input_state_ref.rs index 214564d7a5..17cdddcade 100644 --- a/bus-mapping/src/circuit_input_builder/input_state_ref.rs +++ b/bus-mapping/src/circuit_input_builder/input_state_ref.rs @@ -977,6 +977,10 @@ impl<'a> CircuitInputStateRef<'a> { OpEnum::Storage(op) => { self.sdb.set_storage(&op.address, &op.key, &op.value); } + OpEnum::TransientStorage(op) => { + self.sdb + .set_transient_storage(&op.address, &op.key, &op.value) + } OpEnum::TxAccessListAccount(op) => { if !op.is_warm_prev && op.is_warm { self.sdb.add_account_to_access_list(op.address); diff --git a/bus-mapping/src/evm/opcodes.rs b/bus-mapping/src/evm/opcodes.rs index 3be582fc20..35e1ba2583 100644 --- a/bus-mapping/src/evm/opcodes.rs +++ b/bus-mapping/src/evm/opcodes.rs @@ -44,6 +44,8 @@ mod sstore; mod stackonlyop; mod stop; mod swap; +mod tload; +mod tstore; mod error_code_store; mod error_invalid_creation_code; @@ -65,7 +67,6 @@ mod precompiles; #[cfg(test)] mod memory_expansion_test; -use self::{invalid_tx::InvalidTx, sha3::Sha3}; use address::Address; use balance::Balance; use begin_end_tx::BeginEndTx; @@ -96,6 +97,7 @@ use extcodecopy::Extcodecopy; use extcodehash::Extcodehash; use extcodesize::Extcodesize; use gasprice::GasPrice; +use invalid_tx::InvalidTx; use logs::Log; use mload::Mload; use mstore::Mstore; @@ -104,13 +106,16 @@ use return_revert::ReturnRevert; use returndatacopy::Returndatacopy; use returndatasize::Returndatasize; use selfbalance::Selfbalance; +use sha3::Sha3; use sload::Sload; use sstore::Sstore; use stackonlyop::StackOnlyOpcode; use stop::Stop; use swap::Swap; +use tload::Tload; +use tstore::Tstore; -#[cfg(feature = "test")] +#[cfg(any(feature = "test", test))] pub use crate::precompile::PrecompileCallArgs; /// Generic opcode trait which defines the logic of the @@ -224,6 +229,8 @@ fn fn_gen_associated_ops(opcode_id: &OpcodeId) -> FnGenAssociatedOps { OpcodeId::MSIZE => StackOnlyOpcode::<0, 1>::gen_associated_ops, OpcodeId::GAS => StackOnlyOpcode::<0, 1>::gen_associated_ops, OpcodeId::JUMPDEST => Dummy::gen_associated_ops, + OpcodeId::TLOAD => Tload::gen_associated_ops, + OpcodeId::TSTORE => Tstore::gen_associated_ops, OpcodeId::DUP1 => Dup::<1>::gen_associated_ops, OpcodeId::DUP2 => Dup::<2>::gen_associated_ops, OpcodeId::DUP3 => Dup::<3>::gen_associated_ops, diff --git a/bus-mapping/src/evm/opcodes/tload.rs b/bus-mapping/src/evm/opcodes/tload.rs new file mode 100644 index 0000000000..55d0bdddd6 --- /dev/null +++ b/bus-mapping/src/evm/opcodes/tload.rs @@ -0,0 +1,136 @@ +use super::Opcode; +use crate::{ + circuit_input_builder::{CircuitInputStateRef, ExecStep}, + operation::{CallContextField, TransientStorageOp, RW}, + Error, +}; +use eth_types::{GethExecStep, ToWord, Word}; + +/// Placeholder structure used to implement [`Opcode`] trait over it +/// corresponding to the [`OpcodeId::TLOAD`](crate::evm::OpcodeId::TLOAD) +/// `OpcodeId`. +#[derive(Debug, Copy, Clone)] +pub(crate) struct Tload; + +impl Opcode for Tload { + fn gen_associated_ops( + state: &mut CircuitInputStateRef, + geth_steps: &[GethExecStep], + ) -> Result, Error> { + let geth_step = &geth_steps[0]; + let mut exec_step = state.new_step(geth_step)?; + + let call_id = state.call()?.call_id; + let contract_addr = state.call()?.address; + + state.call_context_read( + &mut exec_step, + call_id, + CallContextField::TxId, + Word::from(state.tx_ctx.id()), + )?; + + state.call_context_read( + &mut exec_step, + call_id, + CallContextField::CalleeAddress, + contract_addr.to_word(), + )?; + + // First stack read + let key = geth_step.stack.last()?; + let stack_position = geth_step.stack.last_filled(); + + // Manage first stack read at latest stack position + state.stack_read(&mut exec_step, stack_position, key)?; + + // Transient Storage read + let (_, &value) = state.sdb.get_transient_storage(&contract_addr, &key); + + state.push_op( + &mut exec_step, + RW::READ, + TransientStorageOp::new(contract_addr, key, value, value, state.tx_ctx.id()), + )?; + + // First stack write + state.stack_write(&mut exec_step, stack_position, value)?; + + Ok(vec![exec_step]) + } +} + +#[cfg(test)] +mod tload_tests { + use super::*; + use crate::{circuit_input_builder::ExecState, mock::BlockData, operation::StackOp}; + use eth_types::{ + bytecode, + evm_types::{OpcodeId, StackAddress}, + geth_types::GethData, + }; + use mock::{ + test_ctx::{helpers::*, TestContext}, + MOCK_ACCOUNTS, + }; + use pretty_assertions::assert_eq; + + #[test] + fn tload_opcode() { + let code = bytecode! { + // Load transient storage slot 0 + PUSH1(0x00u64) + TLOAD + STOP + }; + let expected_loaded_value = 0; + + // Get the execution steps from the external tracer + let block: GethData = TestContext::<2, 1>::new( + None, + account_0_code_account_1_no_code(code), + tx_from_1_to_0, + |block, _tx| block.number(0xcafeu64), + ) + .unwrap() + .into(); + + let builder = BlockData::new_from_geth_data(block.clone()).new_circuit_input_builder(); + let builder = builder + .handle_block(&block.eth_block, &block.geth_traces) + .unwrap(); + + let step = builder.block.txs()[0] + .steps() + .iter() + .find(|step| step.exec_state == ExecState::Op(OpcodeId::TLOAD)) + .unwrap(); + + println!("{:?}", step.bus_mapping_instance); + + assert_eq!( + [&builder.block.container.stack[step.bus_mapping_instance[2].as_usize()]] + .map(|operation| (operation.rw(), operation.op())), + [( + RW::READ, + &StackOp::new(1, StackAddress::from(1023), Word::from(0x0u32)) + )] + ); + + let transient_storage_op = + &builder.block.container.transient_storage[step.bus_mapping_instance[3].as_usize()]; + assert_eq!( + (transient_storage_op.rw(), transient_storage_op.op()), + ( + RW::READ, + &TransientStorageOp::new( + MOCK_ACCOUNTS[0], + Word::from(0x0u32), + Word::from(expected_loaded_value), + Word::from(expected_loaded_value), + 1, + ) + ) + ); + } +} diff --git a/bus-mapping/src/evm/opcodes/tstore.rs b/bus-mapping/src/evm/opcodes/tstore.rs new file mode 100644 index 0000000000..f55ed0a8e2 --- /dev/null +++ b/bus-mapping/src/evm/opcodes/tstore.rs @@ -0,0 +1,215 @@ +use super::Opcode; +use crate::{ + circuit_input_builder::{CircuitInputStateRef, ExecStep}, + operation::{CallContextField, TransientStorageOp}, + Error, +}; +use eth_types::{GethExecStep, ToWord, Word}; + +/// Placeholder structure used to implement [`Opcode`] trait over it +/// corresponding to the [`OpcodeId::TSTORE`](crate::evm::OpcodeId::TSTORE) +/// `OpcodeId`. +#[derive(Debug, Copy, Clone)] +pub(crate) struct Tstore; + +impl Opcode for Tstore { + fn gen_associated_ops( + state: &mut CircuitInputStateRef, + geth_steps: &[GethExecStep], + ) -> Result, Error> { + let geth_step = &geth_steps[0]; + let mut exec_step = state.new_step(geth_step)?; + + let contract_addr = state.call()?.address; + + state.call_context_read( + &mut exec_step, + state.call()?.call_id, + CallContextField::TxId, + Word::from(state.tx_ctx.id()), + )?; + state.call_context_read( + &mut exec_step, + state.call()?.call_id, + CallContextField::IsStatic, + Word::from(state.call()?.is_static as u8), + )?; + + state.call_context_read( + &mut exec_step, + state.call()?.call_id, + CallContextField::RwCounterEndOfReversion, + Word::from(state.call()?.rw_counter_end_of_reversion), + )?; + + state.call_context_read( + &mut exec_step, + state.call()?.call_id, + CallContextField::IsPersistent, + Word::from(state.call()?.is_persistent as u8), + )?; + + state.call_context_read( + &mut exec_step, + state.call()?.call_id, + CallContextField::CalleeAddress, + state.call()?.address.to_word(), + )?; + + let key = geth_step.stack.nth_last(0)?; + let key_stack_position = geth_step.stack.nth_last_filled(0); + let value = geth_step.stack.nth_last(1)?; + let value_stack_position = geth_step.stack.nth_last_filled(1); + + state.stack_read(&mut exec_step, key_stack_position, key)?; + state.stack_read(&mut exec_step, value_stack_position, value)?; + + let (_, value_prev) = state.sdb.get_transient_storage(&contract_addr, &key); + let value_prev = *value_prev; + + state.push_op_reversible( + &mut exec_step, + TransientStorageOp::new( + state.call()?.address, + key, + value, + value_prev, + state.tx_ctx.id(), + ), + )?; + + Ok(vec![exec_step]) + } +} + +#[cfg(test)] +mod tstore_tests { + use super::*; + use crate::{ + circuit_input_builder::ExecState, + mock::BlockData, + operation::{CallContextOp, StackOp, RW}, + }; + use eth_types::{ + bytecode, + evm_types::{OpcodeId, StackAddress}, + geth_types::GethData, + Word, + }; + use mock::{test_ctx::helpers::tx_from_1_to_0, TestContext, MOCK_ACCOUNTS}; + use pretty_assertions::assert_eq; + + #[test] + fn tstore_opcode() { + let code = bytecode! { + // Write 0x6f to storage slot 0 + PUSH1(0x6fu64) + PUSH1(0x00u64) + TSTORE + PUSH1(0x00u64) + TLOAD + STOP + }; + let expected_prev_value = 0x00u64; + + // Get the execution steps from the external tracer + let block: GethData = TestContext::<2, 1>::new( + None, + |accs| { + accs[0] + .address(MOCK_ACCOUNTS[0]) + .balance(Word::from(10u64.pow(19))) + .code(code) + .storage(vec![(0x00u64.into(), 0x6fu64.into())].into_iter()); + accs[1] + .address(MOCK_ACCOUNTS[1]) + .balance(Word::from(10u64.pow(19))); + }, + tx_from_1_to_0, + |block, _tx| block.number(0xcafeu64), + ) + .unwrap() + .into(); + + let builder = BlockData::new_from_geth_data(block.clone()).new_circuit_input_builder(); + let builder = builder + .handle_block(&block.eth_block, &block.geth_traces) + .unwrap(); + + let step = builder.block.txs()[0] + .steps() + .iter() + .rev() // find last tstore + .find(|step| step.exec_state == ExecState::Op(OpcodeId::TSTORE)) + .unwrap(); + + assert_eq!( + [0, 1, 2, 3, 4] + .map(|idx| &builder.block.container.call_context + [step.bus_mapping_instance[idx].as_usize()]) + .map(|operation| (operation.rw(), operation.op())), + [ + ( + RW::READ, + &CallContextOp::new(1, CallContextField::TxId, Word::from(0x01)), + ), + ( + RW::READ, + &CallContextOp::new(1, CallContextField::IsStatic, Word::from(0x00)), + ), + ( + RW::READ, + &CallContextOp::new( + 1, + CallContextField::RwCounterEndOfReversion, + Word::from(0x00) + ), + ), + ( + RW::READ, + &CallContextOp::new(1, CallContextField::IsPersistent, Word::from(0x01)), + ), + ( + RW::READ, + &CallContextOp::new( + 1, + CallContextField::CalleeAddress, + MOCK_ACCOUNTS[0].to_word(), + ), + ), + ] + ); + + assert_eq!( + [5, 6] + .map(|idx| &builder.block.container.stack[step.bus_mapping_instance[idx].as_usize()]) + .map(|operation| (operation.rw(), operation.op())), + [ + ( + RW::READ, + &StackOp::new(1, StackAddress::from(1022), Word::from(0x0u32)) + ), + ( + RW::READ, + &StackOp::new(1, StackAddress::from(1023), Word::from(0x6fu32)) + ), + ] + ); + + let storage_op = + &builder.block.container.transient_storage[step.bus_mapping_instance[7].as_usize()]; + assert_eq!( + (storage_op.rw(), storage_op.op()), + ( + RW::WRITE, + &TransientStorageOp::new( + MOCK_ACCOUNTS[0], + Word::from(0x0u32), + Word::from(0x6fu32), + Word::from(expected_prev_value), + 1, + ) + ) + ); + } +} diff --git a/bus-mapping/src/exec_trace.rs b/bus-mapping/src/exec_trace.rs index 28c886240b..9457b32100 100644 --- a/bus-mapping/src/exec_trace.rs +++ b/bus-mapping/src/exec_trace.rs @@ -18,6 +18,7 @@ impl fmt::Debug for OperationRef { Target::Memory => "Memory", Target::Stack => "Stack", Target::Storage => "Storage", + Target::TransientStorage => "TransientStorage", Target::TxAccessListAccount => "TxAccessListAccount", Target::TxAccessListAccountStorage => "TxAccessListAccountStorage", Target::TxRefund => "TxRefund", diff --git a/bus-mapping/src/operation.rs b/bus-mapping/src/operation.rs index c0b4ab4e78..ec47a4c040 100644 --- a/bus-mapping/src/operation.rs +++ b/bus-mapping/src/operation.rs @@ -102,6 +102,8 @@ pub enum Target { Stack, /// Means the target of the operation is the Storage. Storage, + /// Means the target of the operation is the TransientStorage. + TransientStorage, /// Means the target of the operation is the TxAccessListAccount. TxAccessListAccount, /// Means the target of the operation is the TxAccessListAccountStorage. @@ -141,6 +143,7 @@ impl Target { | Target::TxRefund | Target::Account | Target::Storage + | Target::TransientStorage ) } } @@ -310,7 +313,7 @@ impl Ord for StackOp { } /// Represents a [`READ`](RW::READ)/[`WRITE`](RW::WRITE) into the storage -/// implied by an specific +/// implied by a specific /// [`OpcodeId`](eth_types::evm_types::opcode_ids::OpcodeId) of /// the [`ExecStep`](crate::circuit_input_builder::ExecStep). #[derive(Clone, PartialEq, Eq)] @@ -410,6 +413,103 @@ impl Ord for StorageOp { } } +/// Represents a [`READ`](RW::READ)/[`WRITE`](RW::WRITE) into the transient storage +/// implied by a specific +/// [`OpcodeId`](eth_types::evm_types::opcode_ids::OpcodeId) of +/// the [`ExecStep`](crate::circuit_input_builder::ExecStep). +#[derive(Clone, PartialEq, Eq)] +pub struct TransientStorageOp { + /// Account Address + pub address: Address, + /// Transient Storage Key + pub key: Word, + /// Transient Storage Value after the operation + pub value: Word, + /// Transient Storage Value before the operation + pub value_prev: Word, + /// Transaction ID: Transaction index in the block starting at 1. + pub tx_id: usize, +} + +impl fmt::Debug for TransientStorageOp { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.write_str("TransientStorageOp { ")?; + f.write_fmt(format_args!( + "tx_id: {:?}, addr: {:?}, key: {:?}, val_prev: 0x{:x}, val: 0x{:x}", + self.tx_id, self.address, self.key, self.value_prev, self.value + ))?; + f.write_str(" }") + } +} + +impl TransientStorageOp { + /// Create a new instance of a `TransientStorageOp` from its components. + pub const fn new( + address: Address, + key: Word, + value: Word, + value_prev: Word, + tx_id: usize, + ) -> TransientStorageOp { + TransientStorageOp { + address, + key, + value, + value_prev, + tx_id, + } + } + + /// Returns the [`Target`] (operation type) of this operation. + pub const fn target(&self) -> Target { + Target::TransientStorage + } + + /// Returns the [`Address`] corresponding to this transient storage operation. + pub const fn address(&self) -> &Address { + &self.address + } + + /// Returns the [`Word`] used as key for this operation. + pub const fn key(&self) -> &Word { + &self.key + } + + /// Returns the [`Word`] read or written by this operation. + pub const fn value(&self) -> &Word { + &self.value + } + + /// Returns the [`Word`] at key found previous to this operation. + pub const fn value_prev(&self) -> &Word { + &self.value_prev + } +} + +impl Op for TransientStorageOp { + fn into_enum(self) -> OpEnum { + OpEnum::TransientStorage(self) + } + + fn reverse(&self) -> Self { + let mut rev = self.clone(); + swap(&mut rev.value, &mut rev.value_prev); + rev + } +} + +impl PartialOrd for TransientStorageOp { + fn partial_cmp(&self, other: &Self) -> Option { + Some(self.cmp(other)) + } +} + +impl Ord for TransientStorageOp { + fn cmp(&self, other: &Self) -> Ordering { + (&self.address, &self.key).cmp(&(&other.address, &other.key)) + } +} + /// Represents a change in the Account AccessList implied by a `BeginTx`, /// `EXTCODECOPY`, `EXTCODESIZE`, `EXTCODEHASH` `BALANCE`, `SELFDESTRUCT`, /// `*CALL`* or `CREATE*` step. @@ -1055,6 +1155,8 @@ pub enum OpEnum { Memory(MemoryOp), /// Storage Storage(StorageOp), + /// TransientStorage + TransientStorage(TransientStorageOp), /// TxAccessListAccount TxAccessListAccount(TxAccessListAccountOp), /// TxAccessListAccountStorage diff --git a/bus-mapping/src/operation/container.rs b/bus-mapping/src/operation/container.rs index 2ccac336cd..0e3551af9b 100644 --- a/bus-mapping/src/operation/container.rs +++ b/bus-mapping/src/operation/container.rs @@ -1,7 +1,7 @@ use super::{ AccountOp, CallContextOp, MemoryOp, Op, OpEnum, Operation, PaddingOp, RWCounter, StackOp, - StartOp, StepStateOp, StorageOp, Target, TxAccessListAccountOp, TxAccessListAccountStorageOp, - TxLogOp, TxReceiptOp, TxRefundOp, RW, + StartOp, StepStateOp, StorageOp, Target, TransientStorageOp, TxAccessListAccountOp, + TxAccessListAccountStorageOp, TxLogOp, TxReceiptOp, TxRefundOp, RW, }; use crate::exec_trace::OperationRef; use itertools::Itertools; @@ -28,6 +28,8 @@ pub struct OperationContainer { pub stack: Vec>, /// Operations of StorageOp pub storage: Vec>, + /// Operations of TransientStorageOp + pub transient_storage: Vec>, /// Operations of TxAccessListAccountOp pub tx_access_list_account: Vec>, /// Operations of TxAccessListAccountStorageOp @@ -64,6 +66,7 @@ impl OperationContainer { memory: Vec::new(), stack: Vec::new(), storage: Vec::new(), + transient_storage: Vec::new(), tx_access_list_account: Vec::new(), tx_access_list_account_storage: Vec::new(), tx_refund: Vec::new(), @@ -120,6 +123,11 @@ impl OperationContainer { }); OperationRef::from((Target::Storage, self.storage.len() - 1)) } + OpEnum::TransientStorage(op) => { + self.transient_storage + .push(Operation::new(rwc, rwc_inner_chunk, rw, op)); + OperationRef::from((Target::TransientStorage, self.transient_storage.len() - 1)) + } OpEnum::TxAccessListAccount(op) => { self.tx_access_list_account.push(if reversible { Operation::new_reversible(rwc, rwc_inner_chunk, rw, op) diff --git a/bus-mapping/src/state_db.rs b/bus-mapping/src/state_db.rs index eb47ba787d..6b92df6439 100644 --- a/bus-mapping/src/state_db.rs +++ b/bus-mapping/src/state_db.rs @@ -140,6 +140,8 @@ pub struct StateDB { // state before current transaction, to calculate gas cost for some opcodes like sstore. // So both dirty storage and committed storage are needed. dirty_storage: HashMap<(Address, Word), Word>, + // Transient storage, which is cleared after the transaction. + transient_storage: HashMap<(Address, Word), Word>, // Accounts that have been through `SELFDESTRUCT` under the situation that `is_persistent` is // `true`. These accounts will be reset once `commit_tx` is called. destructed_account: HashSet
, @@ -190,6 +192,17 @@ impl StateDB { } } + /// Get a reference to the transient storage value from [`Account`] at `addr`, at + /// `key`. Returns false and a zero [`Word`] when the [`Account`] or `key` + /// wasn't found in the state. + /// Returns transient storage value, which is cleared after current tx + pub fn get_transient_storage(&self, addr: &Address, key: &Word) -> (bool, &Word) { + match self.transient_storage.get(&(*addr, *key)) { + Some(v) => (true, v), + None => (false, &VALUE_ZERO), + } + } + /// Get a reference to the storage value from [`Account`] at `addr`, at /// `key`. Returns false and a zero [`Word`] when the [`Account`] or `key` /// wasn't found in the state. @@ -227,6 +240,12 @@ impl StateDB { self.dirty_storage.insert((*addr, *key), *value); } + /// Set transient storage value at `addr` and `key`. + /// Transient storage is cleared after transaction execution. + pub fn set_transient_storage(&mut self, addr: &Address, key: &Word, value: &Word) { + self.transient_storage.insert((*addr, *key), *value); + } + /// Get nonce of account with `addr`. pub fn get_nonce(&self, addr: &Address) -> u64 { let (_, account) = self.get_account(addr); @@ -313,6 +332,11 @@ impl StateDB { } self.refund = 0; } + + /// Clear transient storage. + pub fn clear_transient_storage(&mut self) { + self.transient_storage = HashMap::new(); + } } #[cfg(test)] diff --git a/eth-types/src/error.rs b/eth-types/src/error.rs index ef28ba62b5..795fe86834 100644 --- a/eth-types/src/error.rs +++ b/eth-types/src/error.rs @@ -28,6 +28,8 @@ pub enum Error { InvalidMemoryPointer, /// Error while trying to access an invalid/empty Storage key. InvalidStorageKey, + /// Error while trying to access an invalid/empty Transient Storage key. + InvalidTransientStorageKey, /// Error when an EvmWord is too big to be converted into a /// `MemoryAddress`. WordToMemAddr, diff --git a/eth-types/src/evm_types.rs b/eth-types/src/evm_types.rs index 39adaa4a17..c2d4ebf446 100644 --- a/eth-types/src/evm_types.rs +++ b/eth-types/src/evm_types.rs @@ -8,11 +8,13 @@ pub mod memory; pub mod opcode_ids; pub mod stack; pub mod storage; +pub mod transient_storage; pub use memory::{Memory, MemoryAddress}; pub use opcode_ids::OpcodeId; pub use stack::{Stack, StackAddress}; pub use storage::Storage; +pub use transient_storage::TransientStorage; /// According to EIP-3541, disallow new code starting with 0xEF to be deployed. pub const INVALID_INIT_CODE_FIRST_BYTE: u8 = 0xef; diff --git a/eth-types/src/evm_types/opcode_ids.rs b/eth-types/src/evm_types/opcode_ids.rs index 1cad398fc9..04b241298f 100644 --- a/eth-types/src/evm_types/opcode_ids.rs +++ b/eth-types/src/evm_types/opcode_ids.rs @@ -287,6 +287,10 @@ pub enum OpcodeId { SSTORE, /// `GAS` GAS, + /// `TLOAD` + TLOAD, + /// `TSTORE` + TSTORE, // LOGn /// `LOG0` @@ -501,6 +505,8 @@ impl OpcodeId { OpcodeId::SLOAD => 0x54u8, OpcodeId::SSTORE => 0x55u8, OpcodeId::GAS => 0x5au8, + OpcodeId::TLOAD => 0x5cu8, + OpcodeId::TSTORE => 0x5du8, OpcodeId::LOG0 => 0xa0u8, OpcodeId::LOG1 => 0xa1u8, OpcodeId::LOG2 => 0xa2u8, @@ -588,6 +594,8 @@ impl OpcodeId { OpcodeId::MSIZE => GasCost::QUICK, OpcodeId::GAS => GasCost::QUICK, OpcodeId::JUMPDEST => GasCost::ONE, + OpcodeId::TLOAD => GasCost::WARM_ACCESS, + OpcodeId::TSTORE => GasCost::WARM_ACCESS, OpcodeId::PUSH0 => GasCost::QUICK, OpcodeId::PUSH1 => GasCost::FASTEST, OpcodeId::PUSH2 => GasCost::FASTEST, @@ -743,6 +751,8 @@ impl OpcodeId { OpcodeId::MSIZE => (1, 1024), OpcodeId::GAS => (1, 1024), OpcodeId::JUMPDEST => (0, 1024), + OpcodeId::TLOAD => (0, 1023), + OpcodeId::TSTORE => (0, 1022), OpcodeId::PUSH0 => (1, 1024), OpcodeId::PUSH1 => (1, 1024), OpcodeId::PUSH2 => (1, 1024), @@ -948,6 +958,8 @@ impl From for OpcodeId { 0x58u8 => OpcodeId::PC, 0x59u8 => OpcodeId::MSIZE, 0x5bu8 => OpcodeId::JUMPDEST, + 0x5cu8 => OpcodeId::TLOAD, + 0x5du8 => OpcodeId::TSTORE, 0x5fu8 => OpcodeId::PUSH0, 0x60u8 => OpcodeId::PUSH1, 0x61u8 => OpcodeId::PUSH2, @@ -1206,8 +1218,8 @@ impl FromStr for OpcodeId { "SELFDESTRUCT" => OpcodeId::SELFDESTRUCT, "CHAINID" => OpcodeId::CHAINID, "BASEFEE" => OpcodeId::BASEFEE, - "TLOAD" => OpcodeId::INVALID(0xb3), - "TSTORE" => OpcodeId::INVALID(0xb4), + "TLOAD" => OpcodeId::TLOAD, + "TSTORE" => OpcodeId::TSTORE, _ => { // Parse an invalid opcode value as reported by geth lazy_static! { diff --git a/eth-types/src/evm_types/transient_storage.rs b/eth-types/src/evm_types/transient_storage.rs new file mode 100644 index 0000000000..9b5063a22c --- /dev/null +++ b/eth-types/src/evm_types/transient_storage.rs @@ -0,0 +1,67 @@ +//! Doc this +use crate::{DebugWord, Error, ToBigEndian, Word}; +use serde::{ser::SerializeMap, Serialize, Serializer}; +use std::{collections::HashMap, fmt}; + +/// Represents a snapshot of the EVM stack state at a certain +/// execution step height. +#[derive(Clone, Eq, PartialEq)] +pub struct TransientStorage(pub HashMap); + +impl>> From for TransientStorage { + fn from(map: T) -> Self { + Self(map.into()) + } +} + +impl fmt::Debug for TransientStorage { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_map() + .entries(self.0.iter().map(|(k, v)| (DebugWord(k), DebugWord(v)))) + .finish() + } +} + +impl Serialize for TransientStorage { + fn serialize(&self, serializer: S) -> Result + where + S: Serializer, + { + let mut ser = serializer.serialize_map(Some(self.0.len()))?; + for (k, v) in self.0.iter() { + ser.serialize_entry(&hex::encode(k.to_be_bytes()), &hex::encode(v.to_be_bytes()))?; + } + ser.end() + } +} + +impl Default for TransientStorage { + fn default() -> Self { + Self::empty() + } +} + +impl TransientStorage { + /// Generate an empty instance of EVM TransientStorage. + pub fn empty() -> Self { + TransientStorage(HashMap::new()) + } + + /// Generate an new instance of EVM transient storage given a `HashMap`. + pub fn new(map: HashMap) -> Self { + Self::from(map) + } + + /// Get the word for a given key in the EVM transient storage + pub fn get(&self, key: &Word) -> Option<&Word> { + self.0.get(key) + } + + /// Get the word for a given key in the EVM transient storage. Return error if key + /// is not found. + pub fn get_or_err(&self, key: &Word) -> Result { + self.get(key) + .cloned() + .ok_or(Error::InvalidTransientStorageKey) + } +} diff --git a/external-tracer/src/lib.rs b/external-tracer/src/lib.rs index 7bb5c27db5..a46be00637 100644 --- a/external-tracer/src/lib.rs +++ b/external-tracer/src/lib.rs @@ -75,11 +75,11 @@ pub fn trace(config: &TraceConfig) -> Result, Error> { // Don't throw only for specific invalid transactions we support. for trace in trace.iter() { let error = &trace.return_value; - let allowed_cases = error.starts_with("nonce too low") - || error.starts_with("nonce too high") - || error.starts_with("intrinsic gas too low") - || error.starts_with("insufficient funds for gas * price + value") - || error.starts_with("insufficient funds for transfer"); + let allowed_cases = error.contains("nonce too low") + || error.contains("nonce too high") + || error.contains("intrinsic gas too low") + || error.contains("insufficient funds for gas * price + value") + || error.contains("insufficient funds for transfer"); if trace.invalid && !allowed_cases { return Err(Error::TracingError(error.clone())); } diff --git a/geth-utils/gethutil/mpt/oracle/prefetch.go b/geth-utils/gethutil/mpt/oracle/prefetch.go index 34907912b1..68735d6283 100644 --- a/geth-utils/gethutil/mpt/oracle/prefetch.go +++ b/geth-utils/gethutil/mpt/oracle/prefetch.go @@ -266,7 +266,7 @@ func PrefetchBlock(blockNumber *big.Int, startBlock bool, hasher types.TrieHashe panic("block transition isn't correct") } inputs[1] = blockHeader.TxHash - inputs[2] = blockHeader.Coinbase.Hash() + inputs[2] = common.BytesToHash(blockHeader.Coinbase[:]) inputs[3] = blockHeader.UncleHash inputs[4] = common.BigToHash(big.NewInt(int64(blockHeader.GasLimit))) inputs[5] = common.BigToHash(big.NewInt(int64(blockHeader.Time))) diff --git a/geth-utils/gethutil/mpt/state/state_object.go b/geth-utils/gethutil/mpt/state/state_object.go index 4225152f16..16c93e27e8 100644 --- a/geth-utils/gethutil/mpt/state/state_object.go +++ b/geth-utils/gethutil/mpt/state/state_object.go @@ -27,7 +27,6 @@ import ( "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/crypto" - "github.com/ethereum/go-ethereum/metrics" "github.com/ethereum/go-ethereum/rlp" ) @@ -213,20 +212,18 @@ func (s *stateObject) GetCommittedState(db Database, key common.Hash) common.Has meter *time.Duration ) readStart := time.Now() - if metrics.EnabledExpensive { - // If the snap is 'under construction', the first lookup may fail. If that - // happens, we don't want to double-count the time elapsed. Thus this - // dance with the metering. - defer func() { - if meter != nil { - *meter += time.Since(readStart) - } - }() - } - if s.db.snap != nil { - if metrics.EnabledExpensive { - meter = &s.db.SnapshotStorageReads + + // If the snap is 'under construction', the first lookup may fail. If that + // happens, we don't want to double-count the time elapsed. Thus this + // dance with the metering. + defer func() { + if meter != nil { + *meter += time.Since(readStart) } + }() + + if s.db.snap != nil { + meter = &s.db.SnapshotStorageReads // If the object was destructed in *this* block (and potentially resurrected), // the storage has been cleared out, and we should *not* consult the previous // snapshot about any storage values. The only possible alternatives are: @@ -246,9 +243,7 @@ func (s *stateObject) GetCommittedState(db Database, key common.Hash) common.Has *meter += time.Since(readStart) readStart = time.Now() } - if metrics.EnabledExpensive { - meter = &s.db.StorageReads - } + meter = &s.db.StorageReads oracle.PrefetchStorage(db.BlockNumber, s.address, key, nil) if enc, err = s.getTrie(db).TryGet(key.Bytes()); err != nil { s.setError(err) @@ -337,9 +332,8 @@ func (s *stateObject) updateTrie(db Database) Trie { return s.Trie } // Track the amount of time wasted on updating the storage trie - if metrics.EnabledExpensive { - defer func(start time.Time) { s.db.StorageUpdates += time.Since(start) }(time.Now()) - } + defer func(start time.Time) { s.db.StorageUpdates += time.Since(start) }(time.Now()) + // The snapshot storage map for the object var storage map[common.Hash][]byte // Insert all the pending updates into the trie @@ -397,9 +391,7 @@ func (s *stateObject) updateRoot(db Database) { return } // Track the amount of time wasted on hashing the storage trie - if metrics.EnabledExpensive { - defer func(start time.Time) { s.db.StorageHashes += time.Since(start) }(time.Now()) - } + defer func(start time.Time) { s.db.StorageHashes += time.Since(start) }(time.Now()) s.data.Root = s.Trie.Hash() } @@ -414,9 +406,7 @@ func (s *stateObject) CommitTrie(db Database) error { return s.dbErr } // Track the amount of time wasted on committing the storage trie - if metrics.EnabledExpensive { - defer func(start time.Time) { s.db.StorageCommits += time.Since(start) }(time.Now()) - } + defer func(start time.Time) { s.db.StorageCommits += time.Since(start) }(time.Now()) root, err := s.Trie.Commit(nil) if err == nil { s.data.Root = root diff --git a/geth-utils/gethutil/mpt/state/statedb.go b/geth-utils/gethutil/mpt/state/statedb.go index 787319705c..ee1b93861e 100644 --- a/geth-utils/gethutil/mpt/state/statedb.go +++ b/geth-utils/gethutil/mpt/state/statedb.go @@ -32,7 +32,6 @@ import ( "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/crypto" "github.com/ethereum/go-ethereum/log" - "github.com/ethereum/go-ethereum/metrics" "github.com/ethereum/go-ethereum/rlp" ) @@ -523,9 +522,7 @@ func (s *StateDB) DeleteAccount(addr common.Address) bool { // updateStateObject writes the given object to the trie. func (s *StateDB) updateStateObject(obj *stateObject) { // Track the amount of time wasted on updating the account from the trie - if metrics.EnabledExpensive { - defer func(start time.Time) { s.AccountUpdates += time.Since(start) }(time.Now()) - } + defer func(start time.Time) { s.AccountUpdates += time.Since(start) }(time.Now()) // Encode the account and update the account trie addr := obj.Address() @@ -549,9 +546,7 @@ func (s *StateDB) updateStateObject(obj *stateObject) { // deleteStateObject removes the given object from the state trie. func (s *StateDB) deleteStateObject(obj *stateObject) { // Track the amount of time wasted on deleting the account from the trie - if metrics.EnabledExpensive { - defer func(start time.Time) { s.AccountUpdates += time.Since(start) }(time.Now()) - } + defer func(start time.Time) { s.AccountUpdates += time.Since(start) }(time.Now()) // Delete the account from the trie addr := obj.Address() // Get absence proof of account in case the deletion needs the sister node. @@ -586,9 +581,7 @@ func (s *StateDB) getDeletedStateObject(addr common.Address) *stateObject { err error ) /*if s.snap != nil { - if metrics.EnabledExpensive { - defer func(start time.Time) { s.SnapshotAccountReads += time.Since(start) }(time.Now()) - } + defer func(start time.Time) { s.SnapshotAccountReads += time.Since(start) }(time.Now()) var acc *snapshot.Account if acc, err = s.snap.Account(crypto.HashData(s.hasher, addr.Bytes())); err == nil { if acc == nil { @@ -610,9 +603,7 @@ func (s *StateDB) getDeletedStateObject(addr common.Address) *stateObject { }*/ // If snapshot unavailable or reading from it failed, load from the database if s.snap == nil || err != nil { - if metrics.EnabledExpensive { - defer func(start time.Time) { s.AccountReads += time.Since(start) }(time.Now()) - } + defer func(start time.Time) { s.AccountReads += time.Since(start) }(time.Now()) oracle.PrefetchAccount(s.Db.BlockNumber, addr, nil) enc, err := s.trie.TryGet(addr.Bytes()) if err != nil { @@ -972,9 +963,7 @@ func (s *StateDB) IntermediateRoot(deleteEmptyObjects bool) common.Hash { s.stateObjectsPending = make(map[common.Address]struct{}) } // Track the amount of time wasted on hashing the account trie - if metrics.EnabledExpensive { - defer func(start time.Time) { s.AccountHashes += time.Since(start) }(time.Now()) - } + defer func(start time.Time) { s.AccountHashes += time.Since(start) }(time.Now()) return s.trie.Hash() } @@ -1041,10 +1030,7 @@ func (s *StateDB) Commit(deleteEmptyObjects bool) (common.Hash, error) { }*/ // Write the account trie changes, measuring the amount of wasted time - var start time.Time - if metrics.EnabledExpensive { - start = time.Now() - } + var start = time.Now() // The onleaf func is called _serially_, so we can reuse the same account // for unmarshalling every time. var account Account @@ -1057,14 +1043,10 @@ func (s *StateDB) Commit(deleteEmptyObjects bool) (common.Hash, error) { }*/ return nil }) - if metrics.EnabledExpensive { - s.AccountCommits += time.Since(start) - } + s.AccountCommits += time.Since(start) // If snapshotting is enabled, update the snapshot tree with this new version /*if s.snap != nil { - if metrics.EnabledExpensive { - defer func(start time.Time) { s.SnapshotCommits += time.Since(start) }(time.Now()) - } + defer func(start time.Time) { s.SnapshotCommits += time.Since(start) }(time.Now()) // Only update if there's a state transition (skip empty Clique blocks) if parent := s.snap.Root(); parent != root { if err := s.snaps.Update(root, parent, s.snapDestructs, s.snapAccounts, s.snapStorage); err != nil { diff --git a/geth-utils/gethutil/trace.go b/geth-utils/gethutil/trace.go index d48e46666c..2afa18b249 100644 --- a/geth-utils/gethutil/trace.go +++ b/geth-utils/gethutil/trace.go @@ -1,6 +1,7 @@ package gethutil import ( + "encoding/json" "fmt" "math/big" @@ -9,10 +10,12 @@ import ( "github.com/ethereum/go-ethereum/core" "github.com/ethereum/go-ethereum/core/rawdb" "github.com/ethereum/go-ethereum/core/state" + "github.com/ethereum/go-ethereum/core/tracing" "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/core/vm" "github.com/ethereum/go-ethereum/eth/tracers/logger" "github.com/ethereum/go-ethereum/params" + "github.com/holiman/uint256" ) // Copied from github.com/ethereum/go-ethereum/internal/ethapi.ExecutionResult @@ -137,12 +140,12 @@ func toBigInt(value *hexutil.Big) *big.Int { func Trace(config TraceConfig) ([]*ExecutionResult, error) { chainConfig := params.ChainConfig{ - ChainID: toBigInt(config.ChainID), - HomesteadBlock: big.NewInt(0), - DAOForkBlock: big.NewInt(0), - DAOForkSupport: true, - EIP150Block: big.NewInt(0), - EIP150Hash: common.Hash{}, + ChainID: toBigInt(config.ChainID), + HomesteadBlock: big.NewInt(0), + DAOForkBlock: big.NewInt(0), + DAOForkSupport: true, + EIP150Block: big.NewInt(0), + // EIP150Hash: common.Hash{}, EIP155Block: big.NewInt(0), EIP158Block: big.NewInt(0), ByzantiumBlock: big.NewInt(0), @@ -153,6 +156,7 @@ func Trace(config TraceConfig) ([]*ExecutionResult, error) { BerlinBlock: big.NewInt(0), LondonBlock: big.NewInt(0), ShanghaiTime: newUint64(0), + CancunTime: newUint64(0), TerminalTotalDifficulty: big.NewInt(0), TerminalTotalDifficultyPassed: true, } @@ -226,7 +230,7 @@ func Trace(config TraceConfig) ([]*ExecutionResult, error) { stateDB.SetNonce(address, uint64(account.Nonce)) stateDB.SetCode(address, account.Code) if account.Balance != nil { - stateDB.SetBalance(address, toBigInt(account.Balance)) + stateDB.SetBalance(address, uint256.MustFromBig(toBigInt(account.Balance)), tracing.BalanceChangeUnspecified) } for key, value := range account.Storage { stateDB.SetState(address, key, value) @@ -234,15 +238,26 @@ func Trace(config TraceConfig) ([]*ExecutionResult, error) { } stateDB.Finalise(true) + var ( + err error + usedGas uint64 + raw json.RawMessage + tx types.Transaction + ) + // Run the transactions with tracing enabled. executionResults := make([]*ExecutionResult, len(config.Transactions)) for i, message := range messages { tracer := logger.NewStructLogger(config.LoggerConfig) - evm := vm.NewEVM(blockCtx, core.NewEVMTxContext(&message), stateDB, &chainConfig, vm.Config{Debug: true, Tracer: tracer, NoBaseFee: true}) + evm := vm.NewEVM(blockCtx, vm.TxContext{GasPrice: big.NewInt(0)}, stateDB, &chainConfig, vm.Config{Tracer: tracer.Hooks(), NoBaseFee: true}) + + tx = *types.NewTx(ToTxData(message, chainConfig.ChainID)) + stateDB.SetTxContext(tx.Hash(), i) - result, err := core.ApplyMessage(evm, &message, new(core.GasPool).AddGas(message.GasLimit)) + _, err = core.ApplyTransactionWithEVM(&message, &chainConfig, new(core.GasPool).AddGas(message.GasLimit), stateDB, blockCtx.BlockNumber, common.Hash{}, &tx, &usedGas, evm) + var result ExecutionResult if err != nil { - executionResults[i] = &ExecutionResult{ + result = ExecutionResult{ Gas: 0, Failed: true, Invalid: true, @@ -250,17 +265,80 @@ func Trace(config TraceConfig) ([]*ExecutionResult, error) { StructLogs: []StructLogRes{}, } } else { - stateDB.Finalise(true) + raw, _ = tracer.GetResult() - executionResults[i] = &ExecutionResult{ - Gas: result.UsedGas, - Failed: result.Failed(), - Invalid: false, - ReturnValue: fmt.Sprintf("%x", result.ReturnData), - StructLogs: FormatLogs(tracer.StructLogs()), + err = json.Unmarshal(raw, &result) + if err != nil { + return nil, fmt.Errorf("failed to unmarshal result: %w", err) } } + + executionResults[i] = &result } return executionResults, nil } + +func ToTxData(message core.Message, ChainID *big.Int) types.TxData { + var data types.TxData + switch { + case message.BlobHashes != nil: + al := types.AccessList{} + if message.AccessList != nil { + al = message.AccessList + } + data = &types.BlobTx{ + To: *message.To, + ChainID: uint256.MustFromBig((*big.Int)(ChainID)), + Nonce: message.Nonce, + Gas: message.GasLimit, + GasFeeCap: uint256.MustFromBig((*big.Int)(message.GasFeeCap)), + GasTipCap: uint256.MustFromBig((*big.Int)(message.GasTipCap)), + Value: uint256.MustFromBig((*big.Int)(message.Value)), + Data: message.Data, + AccessList: al, + BlobHashes: message.BlobHashes, + BlobFeeCap: uint256.MustFromBig((*big.Int)(message.BlobGasFeeCap)), + } + + case message.GasFeeCap != nil: + al := types.AccessList{} + if message.AccessList != nil { + al = message.AccessList + } + data = &types.DynamicFeeTx{ + To: message.To, + ChainID: (*big.Int)(ChainID), + Nonce: message.Nonce, + Gas: message.GasLimit, + GasFeeCap: message.GasFeeCap, + GasTipCap: message.GasTipCap, + Value: message.Value, + Data: message.Data, + AccessList: al, + } + + case message.AccessList != nil: + data = &types.AccessListTx{ + To: message.To, + ChainID: ChainID, + Nonce: message.Nonce, + Gas: message.GasLimit, + GasPrice: message.GasPrice, + Value: message.Value, + Data: message.Data, + AccessList: message.AccessList, + } + + default: + data = &types.LegacyTx{ + To: message.To, + Nonce: message.Nonce, + Gas: message.GasLimit, + GasPrice: message.GasPrice, + Value: message.Value, + Data: message.Data, + } + } + return data +} diff --git a/geth-utils/go.mod b/geth-utils/go.mod index a417f0750e..cc87187f07 100644 --- a/geth-utils/go.mod +++ b/geth-utils/go.mod @@ -2,54 +2,78 @@ module main go 1.21 -require github.com/ethereum/go-ethereum v1.11.5 +require github.com/ethereum/go-ethereum v1.13.5-0.20240402092557-0bd03dbc5597 -require golang.org/x/crypto v0.1.0 +require ( + github.com/holiman/uint256 v1.2.4 + golang.org/x/crypto v0.21.0 +) require ( github.com/DataDog/zstd v1.5.2 // indirect - github.com/StackExchange/wmi v0.0.0-20180116203802-5d049714c4a6 // indirect - github.com/VictoriaMetrics/fastcache v1.6.0 // indirect + github.com/Microsoft/go-winio v0.6.1 // indirect + github.com/StackExchange/wmi v1.2.1 // indirect + github.com/VictoriaMetrics/fastcache v1.12.1 // indirect github.com/beorn7/perks v1.0.1 // indirect + github.com/bits-and-blooms/bitset v1.10.0 // indirect github.com/btcsuite/btcd/btcec/v2 v2.2.0 // indirect github.com/cespare/xxhash/v2 v2.2.0 // indirect - github.com/cockroachdb/errors v1.9.1 // indirect + github.com/cockroachdb/errors v1.11.1 // indirect github.com/cockroachdb/logtags v0.0.0-20230118201751-21c54148d20b // indirect - github.com/cockroachdb/pebble v0.0.0-20230209160836-829675f94811 // indirect - github.com/cockroachdb/redact v1.1.3 // indirect + github.com/cockroachdb/pebble v1.1.0 // indirect + github.com/cockroachdb/redact v1.1.5 // indirect + github.com/cockroachdb/tokenbucket v0.0.0-20230807174530-cc333fc44b06 // indirect + github.com/consensys/bavard v0.1.13 // indirect + github.com/consensys/gnark-crypto v0.12.1 // indirect + github.com/crate-crypto/go-ipa v0.0.0-20231025140028-3c0104f4b233 // indirect + github.com/crate-crypto/go-kzg-4844 v1.0.0 // indirect + github.com/davecgh/go-spew v1.1.1 // indirect github.com/deckarep/golang-set/v2 v2.1.0 // indirect github.com/decred/dcrd/dcrec/secp256k1/v4 v4.0.1 // indirect + github.com/ethereum/c-kzg-4844 v1.0.0 // indirect + github.com/fsnotify/fsnotify v1.6.0 // indirect + github.com/gballet/go-libpcsclite v0.0.0-20190607065134-2772fd86a8ff // indirect + github.com/gballet/go-verkle v0.1.1-0.20231031103413-a67434b50f46 // indirect github.com/getsentry/sentry-go v0.18.0 // indirect - github.com/go-ole/go-ole v1.2.1 // indirect - github.com/go-stack/stack v1.8.1 // indirect + github.com/go-ole/go-ole v1.3.0 // indirect github.com/gofrs/flock v0.8.1 // indirect github.com/gogo/protobuf v1.3.2 // indirect - github.com/golang/protobuf v1.5.2 // indirect - github.com/golang/snappy v0.0.4 // indirect + github.com/golang/protobuf v1.5.4 // indirect + github.com/golang/snappy v0.0.5-0.20220116011046-fa5810519dcb // indirect + github.com/google/uuid v1.3.0 // indirect github.com/gorilla/websocket v1.4.2 // indirect github.com/holiman/bloomfilter/v2 v2.0.3 // indirect - github.com/holiman/uint256 v1.2.0 // indirect + github.com/huin/goupnp v1.3.0 // indirect + github.com/jackpal/go-nat-pmp v1.0.2 // indirect github.com/klauspost/compress v1.15.15 // indirect github.com/kr/pretty v0.3.1 // indirect github.com/kr/text v0.2.0 // indirect - github.com/mattn/go-runewidth v0.0.9 // indirect + github.com/mattn/go-runewidth v0.0.13 // indirect github.com/matttproud/golang_protobuf_extensions v1.0.4 // indirect + github.com/mmcloughlin/addchain v0.4.0 // indirect github.com/olekukonko/tablewriter v0.0.5 // indirect github.com/pkg/errors v0.9.1 // indirect github.com/prometheus/client_golang v1.14.0 // indirect github.com/prometheus/client_model v0.3.0 // indirect github.com/prometheus/common v0.39.0 // indirect github.com/prometheus/procfs v0.9.0 // indirect + github.com/rivo/uniseg v0.2.0 // indirect github.com/rogpeppe/go-internal v1.9.0 // indirect github.com/shirou/gopsutil v3.21.4-0.20210419000835-c7a38de76ee5+incompatible // indirect + github.com/status-im/keycard-go v0.2.0 // indirect + github.com/supranational/blst v0.3.11 // indirect github.com/syndtr/goleveldb v1.0.1-0.20210819022825-2ae1ddf74ef7 // indirect - github.com/tklauser/go-sysconf v0.3.5 // indirect - github.com/tklauser/numcpus v0.2.2 // indirect - golang.org/x/exp v0.0.0-20230206171751-46f607a40771 // indirect - golang.org/x/sys v0.5.0 // indirect - golang.org/x/text v0.7.0 // indirect - google.golang.org/protobuf v1.28.1 // indirect - gopkg.in/natefinch/npipe.v2 v2.0.0-20160621034901-c1b8fa8bdcce // indirect + github.com/tklauser/go-sysconf v0.3.12 // indirect + github.com/tklauser/numcpus v0.6.1 // indirect + github.com/tyler-smith/go-bip39 v1.1.0 // indirect + golang.org/x/exp v0.0.0-20231110203233-9a3e6036ecaa // indirect + golang.org/x/mod v0.14.0 // indirect + golang.org/x/sync v0.5.0 // indirect + golang.org/x/sys v0.18.0 // indirect + golang.org/x/text v0.14.0 // indirect + golang.org/x/tools v0.15.0 // indirect + google.golang.org/protobuf v1.33.0 // indirect + rsc.io/tmplfunc v0.0.3 // indirect ) // Uncomment for debugging diff --git a/geth-utils/go.sum b/geth-utils/go.sum index 11b360c307..87d052c2eb 100644 --- a/geth-utils/go.sum +++ b/geth-utils/go.sum @@ -1,48 +1,45 @@ -cloud.google.com/go v0.26.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw= -github.com/AndreasBriese/bbloom v0.0.0-20190306092124-e2d15f34fcf9/go.mod h1:bOvUY6CB00SOBii9/FifXqc0awNKxLFCL/+pkDPuyl8= -github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU= -github.com/CloudyKit/fastprinter v0.0.0-20200109182630-33d98a066a53/go.mod h1:+3IMCy2vIlbG1XG/0ggNQv0SvxCAIpPM5b1nCz56Xno= -github.com/CloudyKit/jet/v3 v3.0.0/go.mod h1:HKQPgSJmdK8hdoAbKUUWajkHyHo4RaU5rMdUywE7VMo= github.com/DataDog/zstd v1.5.2 h1:vUG4lAyuPCXO0TLbXvPv7EB7cNK1QV/luu55UHLrrn8= github.com/DataDog/zstd v1.5.2/go.mod h1:g4AWEaM3yOg3HYfnJ3YIawPnVdXJh9QME85blwSAmyw= -github.com/Joker/hpp v1.0.0/go.mod h1:8x5n+M1Hp5hC0g8okX3sR3vFQwynaX/UgSOM9MeBKzY= -github.com/Shopify/goreferrer v0.0.0-20181106222321-ec9c9a553398/go.mod h1:a1uqRtAwp2Xwc6WNPJEufxJ7fx3npB4UV/JOLmbu5I0= -github.com/StackExchange/wmi v0.0.0-20180116203802-5d049714c4a6 h1:fLjPD/aNc3UIOA6tDi6QXUemppXK3P9BI7mr2hd6gx8= -github.com/StackExchange/wmi v0.0.0-20180116203802-5d049714c4a6/go.mod h1:3eOhrUMpNV+6aFIbp5/iudMxNCF27Vw2OZgy4xEx0Fg= -github.com/VictoriaMetrics/fastcache v1.6.0 h1:C/3Oi3EiBCqufydp1neRZkqcwmEiuRT9c3fqvvgKm5o= -github.com/VictoriaMetrics/fastcache v1.6.0/go.mod h1:0qHz5QP0GMX4pfmMA/zt5RgfNuXJrTP0zS7DqpHGGTw= -github.com/ajg/form v1.5.1/go.mod h1:uL1WgH+h2mgNtvBq0339dVnzXdBETtL2LeUXaIv25UY= +github.com/Microsoft/go-winio v0.6.1 h1:9/kr64B9VUZrLm5YYwbGtUJnMgqWVOdUAXu6Migciow= +github.com/Microsoft/go-winio v0.6.1/go.mod h1:LRdKpFKfdobln8UmuiYcKPot9D2v6svN5+sAH+4kjUM= +github.com/StackExchange/wmi v1.2.1 h1:VIkavFPXSjcnS+O8yTq7NI32k0R5Aj+v39y29VYDOSA= +github.com/StackExchange/wmi v1.2.1/go.mod h1:rcmrprowKIVzvc+NUiLncP2uuArMWLCbu9SBzvHz7e8= +github.com/VictoriaMetrics/fastcache v1.12.1 h1:i0mICQuojGDL3KblA7wUNlY5lOK6a4bwt3uRKnkZU40= +github.com/VictoriaMetrics/fastcache v1.12.1/go.mod h1:tX04vaqcNoQeGLD+ra5pU5sWkuxnzWhEzLwhP9w653o= github.com/allegro/bigcache v1.2.1-0.20190218064605-e24eb225f156 h1:eMwmnE/GDgah4HI848JfFxHt+iPb26b4zyfspmqY0/8= github.com/allegro/bigcache v1.2.1-0.20190218064605-e24eb225f156/go.mod h1:Cb/ax3seSYIx7SuZdm2G2xzfwmv3TPSk2ucNfQESPXM= -github.com/armon/consul-api v0.0.0-20180202201655-eb2c6b5be1b6/go.mod h1:grANhF5doyWs3UAsr3K4I6qtAmlQcZDesFNEHPZAzj8= -github.com/aymerick/raymond v2.0.3-0.20180322193309-b565731e1464+incompatible/go.mod h1:osfaiScAUVup+UC9Nfq76eWqDhXlp+4UYaA8uhTBO6g= github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM= github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw= +github.com/bits-and-blooms/bitset v1.10.0 h1:ePXTeiPEazB5+opbv5fr8umg2R/1NlzgDsyepwsSr88= +github.com/bits-and-blooms/bitset v1.10.0/go.mod h1:7hO7Gc7Pp1vODcmWvKMRA9BNmbv6a/7QIWpPxHddWR8= github.com/btcsuite/btcd/btcec/v2 v2.2.0 h1:fzn1qaOt32TuLjFlkzYSsBC35Q3KUjT1SwPxiMSCF5k= github.com/btcsuite/btcd/btcec/v2 v2.2.0/go.mod h1:U7MHm051Al6XmscBQ0BoNydpOTsFAn707034b5nY8zU= github.com/btcsuite/btcd/chaincfg/chainhash v1.0.1 h1:q0rUy8C/TYNBQS1+CGKw68tLOFYSNEs0TFnxxnS9+4U= -github.com/census-instrumentation/opencensus-proto v0.2.1/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU= -github.com/cespare/xxhash/v2 v2.1.1/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= +github.com/btcsuite/btcd/chaincfg/chainhash v1.0.1/go.mod h1:7SFka0XMvUgj3hfZtydOrQY2mwhPclbT2snogU7SQQc= +github.com/cespare/cp v0.1.0 h1:SE+dxFebS7Iik5LK0tsi1k9ZCxEaFX4AjQmoyA+1dJk= +github.com/cespare/cp v0.1.0/go.mod h1:SOGHArjBr4JWaSDEVpWpo/hNg6RoKrls6Oh40hiwW+s= github.com/cespare/xxhash/v2 v2.2.0 h1:DC2CZ1Ep5Y4k3ZQ899DldepgrayRUGE6BBZ/cd9Cj44= github.com/cespare/xxhash/v2 v2.2.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= -github.com/client9/misspell v0.3.4/go.mod h1:qj6jICC3Q7zFZvVWo7KLAzC3yx5G7kyvSDkc90ppPyw= -github.com/cncf/udpa/go v0.0.0-20201120205902-5459f2c99403/go.mod h1:WmhPx2Nbnhtbo57+VJT5O0JRkEi1Wbu0z5j0R8u5Hbk= -github.com/cockroachdb/datadriven v1.0.2 h1:H9MtNqVoVhvd9nCBwOyDjUEdZCREqbIdCJD93PBm/jA= -github.com/cockroachdb/datadriven v1.0.2/go.mod h1:a9RdTaap04u637JoCzcUoIcDmvwSUtcUFtT/C3kJlTU= -github.com/cockroachdb/errors v1.9.1 h1:yFVvsI0VxmRShfawbt/laCIDy/mtTqqnvoNgiy5bEV8= -github.com/cockroachdb/errors v1.9.1/go.mod h1:2sxOtL2WIc096WSZqZ5h8fa17rdDq9HZOZLBCor4mBk= -github.com/cockroachdb/logtags v0.0.0-20211118104740-dabe8e521a4f/go.mod h1:Vz9DsVWQQhf3vs21MhPMZpMGSht7O/2vFW2xusFUVOs= +github.com/cockroachdb/datadriven v1.0.3-0.20230413201302-be42291fc80f h1:otljaYPt5hWxV3MUfO5dFPFiOXg9CyG5/kCfayTqsJ4= +github.com/cockroachdb/datadriven v1.0.3-0.20230413201302-be42291fc80f/go.mod h1:a9RdTaap04u637JoCzcUoIcDmvwSUtcUFtT/C3kJlTU= +github.com/cockroachdb/errors v1.11.1 h1:xSEW75zKaKCWzR3OfxXUxgrk/NtT4G1MiOv5lWZazG8= +github.com/cockroachdb/errors v1.11.1/go.mod h1:8MUxA3Gi6b25tYlFEBGLf+D8aISL+M4MIpiWMSNRfxw= github.com/cockroachdb/logtags v0.0.0-20230118201751-21c54148d20b h1:r6VH0faHjZeQy818SGhaone5OnYfxFR/+AzdY3sf5aE= github.com/cockroachdb/logtags v0.0.0-20230118201751-21c54148d20b/go.mod h1:Vz9DsVWQQhf3vs21MhPMZpMGSht7O/2vFW2xusFUVOs= -github.com/cockroachdb/pebble v0.0.0-20230209160836-829675f94811 h1:ytcWPaNPhNoGMWEhDvS3zToKcDpRsLuRolQJBVGdozk= -github.com/cockroachdb/pebble v0.0.0-20230209160836-829675f94811/go.mod h1:Nb5lgvnQ2+oGlE/EyZy4+2/CxRh9KfvCXnag1vtpxVM= -github.com/cockroachdb/redact v1.1.3 h1:AKZds10rFSIj7qADf0g46UixK8NNLwWTNdCIGS5wfSQ= -github.com/cockroachdb/redact v1.1.3/go.mod h1:BVNblN9mBWFyMyqK1k3AAiSxhvhfK2oOZZ2lK+dpvRg= -github.com/codegangsta/inject v0.0.0-20150114235600-33e0aa1cb7c0/go.mod h1:4Zcjuz89kmFXt9morQgcfYZAYZ5n8WHjt81YYWIwtTM= -github.com/coreos/etcd v3.3.10+incompatible/go.mod h1:uF7uidLiAD3TWHmW31ZFd/JWoc32PjwdhPthX9715RE= -github.com/coreos/go-etcd v2.0.0+incompatible/go.mod h1:Jez6KQU2B/sWsbdaef3ED8NzMklzPG4d5KIOhIy30Tk= -github.com/coreos/go-semver v0.2.0/go.mod h1:nnelYz7RCh+5ahJtPPxZlU+153eP4D4r3EedlOD2RNk= -github.com/cpuguy83/go-md2man v1.0.10/go.mod h1:SmD6nW6nTyfqj6ABTjUi3V3JVMnlJmwcJI5acqYI6dE= +github.com/cockroachdb/pebble v1.1.0 h1:pcFh8CdCIt2kmEpK0OIatq67Ln9uGDYY3d5XnE0LJG4= +github.com/cockroachdb/pebble v1.1.0/go.mod h1:sEHm5NOXxyiAoKWhoFxT8xMgd/f3RA6qUqQ1BXKrh2E= +github.com/cockroachdb/redact v1.1.5 h1:u1PMllDkdFfPWaNGMyLD1+so+aq3uUItthCFqzwPJ30= +github.com/cockroachdb/redact v1.1.5/go.mod h1:BVNblN9mBWFyMyqK1k3AAiSxhvhfK2oOZZ2lK+dpvRg= +github.com/cockroachdb/tokenbucket v0.0.0-20230807174530-cc333fc44b06 h1:zuQyyAKVxetITBuuhv3BI9cMrmStnpT18zmgmTxunpo= +github.com/cockroachdb/tokenbucket v0.0.0-20230807174530-cc333fc44b06/go.mod h1:7nc4anLGjupUW/PeY5qiNYsdNXj7zopG+eqsS7To5IQ= +github.com/consensys/bavard v0.1.13 h1:oLhMLOFGTLdlda/kma4VOJazblc7IM5y5QPd2A/YjhQ= +github.com/consensys/bavard v0.1.13/go.mod h1:9ItSMtA/dXMAiL7BG6bqW2m3NdSEObYWoH223nGHukI= +github.com/consensys/gnark-crypto v0.12.1 h1:lHH39WuuFgVHONRl3J0LRBtuYdQTumFSDtJF7HpyG8M= +github.com/consensys/gnark-crypto v0.12.1/go.mod h1:v2Gy7L/4ZRosZ7Ivs+9SfUDr0f5UlG+EM5t7MPHiLuY= +github.com/crate-crypto/go-ipa v0.0.0-20231025140028-3c0104f4b233 h1:d28BXYi+wUpz1KBmiF9bWrjEMacUEREV6MBi2ODnrfQ= +github.com/crate-crypto/go-ipa v0.0.0-20231025140028-3c0104f4b233/go.mod h1:geZJZH3SzKCqnz5VT0q/DyIG/tvu/dZk+VIfXicupJs= +github.com/crate-crypto/go-kzg-4844 v1.0.0 h1:TsSgHwrkTKecKJ4kadtHi4b3xHW5dCFUDFnUp1TsawI= +github.com/crate-crypto/go-kzg-4844 v1.0.0/go.mod h1:1kMhvPgI0Ky3yIa+9lFySEBUBXkYxeOi8ZF1sYioxhc= github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= @@ -53,392 +50,214 @@ github.com/decred/dcrd/crypto/blake256 v1.0.0 h1:/8DMNYp9SGi5f0w7uCm6d6M4OU2rGFK github.com/decred/dcrd/crypto/blake256 v1.0.0/go.mod h1:sQl2p6Y26YV+ZOcSTP6thNdn47hh8kt6rqSlvmrXFAc= github.com/decred/dcrd/dcrec/secp256k1/v4 v4.0.1 h1:YLtO71vCjJRCBcrPMtQ9nqBsqpA1m5sE92cU+pd5Mcc= github.com/decred/dcrd/dcrec/secp256k1/v4 v4.0.1/go.mod h1:hyedUtir6IdtD/7lIxGeCxkaw7y45JueMRL4DIyJDKs= -github.com/dgraph-io/badger v1.6.0/go.mod h1:zwt7syl517jmP8s94KqSxTlM6IMsdhYy6psNgSztDR4= -github.com/dgryski/go-farm v0.0.0-20190423205320-6a90982ecee2/go.mod h1:SqUrOPUnsFjfmXRMNPybcSiG0BgUW2AuFH8PAnS2iTw= -github.com/dustin/go-humanize v1.0.0/go.mod h1:HtrtbFcZ19U5GC7JDqmcUSB87Iq5E25KnS6fMYU6eOk= -github.com/edsrzf/mmap-go v1.0.0 h1:CEBF7HpRnUCSJgGUb5h1Gm7e3VkmVDrR8lvWVLtrOFw= -github.com/eknkc/amber v0.0.0-20171010120322-cdade1c07385/go.mod h1:0vRUJqYpeSZifjYj7uP3BG/gKcuzL9xWVV/Y+cK33KM= -github.com/envoyproxy/go-control-plane v0.9.0/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4= -github.com/envoyproxy/go-control-plane v0.9.1-0.20191026205805-5f8ba28d4473/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4= -github.com/envoyproxy/go-control-plane v0.9.9-0.20210217033140-668b12f5399d/go.mod h1:cXg6YxExXjJnVBQHBLXeUAgxn2UodCpnH306RInaBQk= -github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c= -github.com/etcd-io/bbolt v1.3.3/go.mod h1:ZF2nL25h33cCyBtcyWeZ2/I3HQOfTP+0PIEvHjkjCrw= -github.com/ethereum/go-ethereum v1.11.5 h1:3M1uan+LAUvdn+7wCEFrcMM4LJTeuxDrPTg/f31a5QQ= -github.com/ethereum/go-ethereum v1.11.5/go.mod h1:it7x0DWnTDMfVFdXcU6Ti4KEFQynLHVRarcSlPr0HBo= -github.com/fasthttp-contrib/websocket v0.0.0-20160511215533-1f3b11f56072/go.mod h1:duJ4Jxv5lDcvg4QuQr0oowTf7dz4/CR8NtyCooz9HL8= -github.com/fatih/structs v1.1.0/go.mod h1:9NiDSp5zOcgEDl+j00MP/WkGVPOlPRLejGD8Ga6PJ7M= +github.com/ethereum/c-kzg-4844 v1.0.0 h1:0X1LBXxaEtYD9xsyj9B9ctQEZIpnvVDeoBx8aHEwTNA= +github.com/ethereum/c-kzg-4844 v1.0.0/go.mod h1:VewdlzQmpT5QSrVhbBuGoCdFJkpaJlO1aQputP83wc0= +github.com/ethereum/go-ethereum v1.13.5-0.20240402092557-0bd03dbc5597 h1:D5DaLAE5RTaiiJFWn0Z4asA4ULBmt6c/1W0EHMNrg/0= +github.com/ethereum/go-ethereum v1.13.5-0.20240402092557-0bd03dbc5597/go.mod h1:x2gtBG0WHLgY08FE97lfhjtpcR5vcSAZbi34JnrsBbQ= github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo= github.com/fsnotify/fsnotify v1.4.9/go.mod h1:znqG4EE+3YCdAaPaxE2ZRY/06pZUdp0tY4IgpuI1SZQ= github.com/fsnotify/fsnotify v1.6.0 h1:n+5WquG0fcWoWp6xPWfHdbskMCQaFnG6PfBrh1Ky4HY= -github.com/gavv/httpexpect v2.0.0+incompatible/go.mod h1:x+9tiU1YnrOvnB725RkpoLv1M62hOWzwo5OXotisrKc= -github.com/getsentry/sentry-go v0.12.0/go.mod h1:NSap0JBYWzHND8oMbyi0+XZhUalc1TBdRL1M71JZW2c= +github.com/fsnotify/fsnotify v1.6.0/go.mod h1:sl3t1tCWJFWoRz9R8WJCbQihKKwmorjAbSClcnxKAGw= +github.com/gballet/go-libpcsclite v0.0.0-20190607065134-2772fd86a8ff h1:tY80oXqGNY4FhTFhk+o9oFHGINQ/+vhlm8HFzi6znCI= +github.com/gballet/go-libpcsclite v0.0.0-20190607065134-2772fd86a8ff/go.mod h1:x7DCsMOv1taUwEWCzT4cmDeAkigA5/QCwUodaVOe8Ww= +github.com/gballet/go-verkle v0.1.1-0.20231031103413-a67434b50f46 h1:BAIP2GihuqhwdILrV+7GJel5lyPV3u1+PgzrWLc0TkE= +github.com/gballet/go-verkle v0.1.1-0.20231031103413-a67434b50f46/go.mod h1:QNpY22eby74jVhqH4WhDLDwxc/vqsern6pW+u2kbkpc= github.com/getsentry/sentry-go v0.18.0 h1:MtBW5H9QgdcJabtZcuJG80BMOwaBpkRDZkxRkNC1sN0= github.com/getsentry/sentry-go v0.18.0/go.mod h1:Kgon4Mby+FJ7ZWHFUAZgVaIa8sxHtnRJRLTXZr51aKQ= -github.com/gin-contrib/sse v0.0.0-20190301062529-5545eab6dad3/go.mod h1:VJ0WA2NBN22VlZ2dKZQPAPnyWw5XTlK1KymzLKsr59s= -github.com/gin-gonic/gin v1.4.0/go.mod h1:OW2EZn3DO8Ln9oIKOvM++LBO+5UPHJJDH72/q/3rZdM= -github.com/go-check/check v0.0.0-20180628173108-788fd7840127/go.mod h1:9ES+weclKsC9YodN5RgxqK/VD9HM9JsCSh7rNhMZE98= -github.com/go-errors/errors v1.0.1/go.mod h1:f4zRHt4oKfwPJE5k8C9vpYG+aDHdBFUsgrm6/TyX73Q= github.com/go-errors/errors v1.4.2 h1:J6MZopCL4uSllY1OfXM374weqZFFItUbrImctkmUxIA= -github.com/go-martini/martini v0.0.0-20170121215854-22fa46961aab/go.mod h1:/P9AEU963A2AYjv4d1V5eVL1CQbEJq6aCNHDDjibzu8= -github.com/go-ole/go-ole v1.2.1 h1:2lOsA72HgjxAuMlKpFiCbHTvu44PIVkZ5hqm3RSdI/E= -github.com/go-ole/go-ole v1.2.1/go.mod h1:7FAglXiTm7HKlQRDeOQ6ZNUHidzCWXuZWq/1dTyBNF8= -github.com/go-stack/stack v1.8.1 h1:ntEHSVwIt7PNXNpgPmVfMrNhLtgjlmnZha2kOpuRiDw= -github.com/go-stack/stack v1.8.1/go.mod h1:dcoOX6HbPZSZptuspn9bctJ+N/CnF5gGygcUP3XYfe4= -github.com/gobwas/httphead v0.0.0-20180130184737-2c6c146eadee/go.mod h1:L0fX3K22YWvt/FAX9NnzrNzcI4wNYi9Yku4O0LKYflo= -github.com/gobwas/pool v0.2.0/go.mod h1:q8bcK0KcYlCgd9e7WYLm9LpyS+YeLd8JVDW6WezmKEw= -github.com/gobwas/ws v1.0.2/go.mod h1:szmBTxLgaFppYjEmNtny/v3w89xOydFnnZMcgRRu/EM= +github.com/go-errors/errors v1.4.2/go.mod h1:sIVyrIiJhuEF+Pj9Ebtd6P/rEYROXFi3BopGUQ5a5Og= +github.com/go-ole/go-ole v1.2.5/go.mod h1:pprOEPIfldk/42T2oK7lQ4v4JSDwmV0As9GaiUsvbm0= +github.com/go-ole/go-ole v1.3.0 h1:Dt6ye7+vXGIKZ7Xtk4s6/xVdGDQynvom7xCFEdWr6uE= +github.com/go-ole/go-ole v1.3.0/go.mod h1:5LS6F96DhAwUc7C+1HLexzMXY1xGRSryjyPPKW6zv78= github.com/gofrs/flock v0.8.1 h1:+gYjHKf32LDeiEEFhQaotPbLuUXjY5ZqxKgXy7n59aw= github.com/gofrs/flock v0.8.1/go.mod h1:F1TvTiK9OcQqauNUHlbJvyl9Qa1QvF/gOUDKA14jxHU= -github.com/gogo/googleapis v0.0.0-20180223154316-0cd9801be74a/go.mod h1:gf4bu3Q80BeJ6H1S1vYPm8/ELATdvryBaNFGgqEef3s= -github.com/gogo/googleapis v1.4.1/go.mod h1:2lpHqI5OcWCtVElxXnPt+s8oJvMpySlOyM6xDCrzib4= -github.com/gogo/protobuf v1.2.0/go.mod h1:r8qH/GZQm5c6nD/R0oafs1akxWv10x8SbQlK7atdtwQ= github.com/gogo/protobuf v1.3.2 h1:Ov1cvc58UF3b5XjBnZv7+opcTcQFZebYjWzi34vdm4Q= github.com/gogo/protobuf v1.3.2/go.mod h1:P1XiOD3dCwIKUDQYPy72D8LYyHL2YPYrpS2s69NZV8Q= -github.com/gogo/status v1.1.0/go.mod h1:BFv9nrluPLmrS0EmGVvLaPNmRosr9KapBYd5/hpY1WM= -github.com/golang-jwt/jwt v3.2.2+incompatible/go.mod h1:8pz2t5EyA70fFQQSrl6XZXzqecmYZeUEB8OUGHkxJ+I= -github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q= -github.com/golang/mock v1.1.1/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A= github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= -github.com/golang/protobuf v1.3.1/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= -github.com/golang/protobuf v1.3.2/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= github.com/golang/protobuf v1.3.5/go.mod h1:6O5/vntMXwX2lRkT1hjjk0nAC1IDOTvTlVgjlRvqsdk= github.com/golang/protobuf v1.4.0-rc.1/go.mod h1:ceaxUfeHdC40wWswd/P6IGgMaK3YpKi5j83Wpe3EHw8= github.com/golang/protobuf v1.4.0-rc.1.0.20200221234624-67d41d38c208/go.mod h1:xKAWHe0F5eneWXFV3EuXVDTCmh+JuBKY0li0aMyXATA= github.com/golang/protobuf v1.4.0-rc.2/go.mod h1:LlEzMj4AhA7rCAGe4KMBDvJI+AwstrUpVNzEA03Pprs= github.com/golang/protobuf v1.4.0-rc.4.0.20200313231945-b860323f09d0/go.mod h1:WU3c8KckQ9AFe+yFwt9sWVRKCVIyN9cPHBJSNnbL67w= github.com/golang/protobuf v1.4.0/go.mod h1:jodUvKwWbYaEsadDk5Fwe5c77LiNKVO9IDvqG2KuDX0= -github.com/golang/protobuf v1.4.1/go.mod h1:U8fpvMrcmy5pZrNK1lt4xCsGvpyWQ/VVv6QDs8UjoX8= github.com/golang/protobuf v1.4.2/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI= -github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk= -github.com/golang/protobuf v1.5.2 h1:ROPKBNFfQgOUMifHyP+KYbvpjbdoFNs+aK7DXlji0Tw= -github.com/golang/protobuf v1.5.2/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY= -github.com/golang/snappy v0.0.3/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q= -github.com/golang/snappy v0.0.4 h1:yAGX7huGHXlcLOEtBnF4w7FQwA26wojNCwOYAEhLjQM= +github.com/golang/protobuf v1.5.4 h1:i7eJL8qZTpSEXOPTxNKhASYpMn+8e5Q6AdndVa1dWek= +github.com/golang/protobuf v1.5.4/go.mod h1:lnTiLA8Wa4RWRcIUkrtSVa5nRhsEGBg48fD6rSs7xps= github.com/golang/snappy v0.0.4/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q= -github.com/gomodule/redigo v1.7.1-0.20190724094224-574c33c3df38/go.mod h1:B4C85qUVwatsJoIUNIfCRsp7qO0iAmpGFZ4EELWSbC4= -github.com/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M= +github.com/golang/snappy v0.0.5-0.20220116011046-fa5810519dcb h1:PBC98N2aIaM3XXiurYmW7fx4GZkL8feAMVq7nEjURHk= +github.com/golang/snappy v0.0.5-0.20220116011046-fa5810519dcb/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q= github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU= github.com/google/go-cmp v0.3.1/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU= github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= -github.com/google/go-cmp v0.5.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= -github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.9 h1:O2Tfq5qg4qc4AmwVlvv0oLiVAGB7enBSJ2x2DqQFi38= -github.com/google/go-querystring v1.0.0/go.mod h1:odCYkC5MyYFN7vkCjXpyrEuKhc/BUO6wN/zVPAxq5ck= -github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg= -github.com/google/uuid v1.1.2/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= -github.com/gopherjs/gopherjs v0.0.0-20181017120253-0766667cb4d1/go.mod h1:wJfORRmW1u3UXTncJ5qlYoELFm8eSnnEO6hX4iZ3EWY= -github.com/gorilla/websocket v1.4.1/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE= +github.com/google/go-cmp v0.5.9/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY= +github.com/google/gofuzz v1.2.0 h1:xRy4A+RhZaiKjJ1bPfwQ8sedCA+YS2YcCHW6ec7JMi0= +github.com/google/gofuzz v1.2.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg= +github.com/google/subcommands v1.2.0/go.mod h1:ZjhPrFU+Olkh9WazFPsl27BQ4UPiG37m3yTrtFlrHVk= +github.com/google/uuid v1.3.0 h1:t6JiXgmwXMjEs8VusXIJk2BXHsn+wx8BZdTaoZ5fu7I= +github.com/google/uuid v1.3.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= github.com/gorilla/websocket v1.4.2 h1:+/TMaTYc4QFitKJxsQ7Yye35DkWvkdLcvGKqM+x0Ufc= github.com/gorilla/websocket v1.4.2/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE= -github.com/hashicorp/go-version v1.2.0/go.mod h1:fltr4n8CU8Ke44wwGCBoEymUuxUHl09ZGVZPK5anwXA= -github.com/hashicorp/hcl v1.0.0/go.mod h1:E5yfLk+7swimpb2L/Alb/PJmXilQ/rhwaUYs4T20WEQ= github.com/holiman/bloomfilter/v2 v2.0.3 h1:73e0e/V0tCydx14a0SCYS/EWCxgwLZ18CZcZKVu0fao= github.com/holiman/bloomfilter/v2 v2.0.3/go.mod h1:zpoh+gs7qcpqrHr3dB55AMiJwo0iURXE7ZOP9L9hSkA= -github.com/holiman/uint256 v1.2.0 h1:gpSYcPLWGv4sG43I2mVLiDZCNDh/EpGjSk8tmtxitHM= -github.com/holiman/uint256 v1.2.0/go.mod h1:y4ga/t+u+Xwd7CpDgZESaRcWy0I7XMlTMA25ApIH5Jw= +github.com/holiman/uint256 v1.2.4 h1:jUc4Nk8fm9jZabQuqr2JzednajVmBpC+oiTiXZJEApU= +github.com/holiman/uint256 v1.2.4/go.mod h1:EOMSn4q6Nyt9P6efbI3bueV4e1b3dGlUCXeiRV4ng7E= github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU= -github.com/hydrogen18/memlistener v0.0.0-20200120041712-dcc25e7acd91/go.mod h1:qEIFzExnS6016fRpRfxrExeVn2gbClQA99gQhnIcdhE= -github.com/imkira/go-interpol v1.1.0/go.mod h1:z0h2/2T3XF8kyEPpRgJ3kmNv+C43p+I/CoI+jC3w2iA= -github.com/inconshreveable/mousetrap v1.0.0/go.mod h1:PxqpIevigyE2G7u3NXJIT2ANytuPF1OarO4DADm73n8= -github.com/iris-contrib/blackfriday v2.0.0+incompatible/go.mod h1:UzZ2bDEoaSGPbkg6SAB4att1aAwTmVIx/5gCVqeyUdI= -github.com/iris-contrib/go.uuid v2.0.0+incompatible/go.mod h1:iz2lgM/1UnEf1kP0L/+fafWORmlnuysV2EMP8MW+qe0= -github.com/iris-contrib/jade v1.1.3/go.mod h1:H/geBymxJhShH5kecoiOCSssPX7QWYH7UaeZTSWddIk= -github.com/iris-contrib/pongo2 v0.0.1/go.mod h1:Ssh+00+3GAZqSQb30AvBRNxBx7rf0GqwkjqxNd0u65g= -github.com/iris-contrib/schema v0.0.1/go.mod h1:urYA3uvUNG1TIIjOSCzHr9/LmbQo8LrOcOqfqxa4hXw= -github.com/json-iterator/go v1.1.6/go.mod h1:+SdeFBvtyEkXs7REEP0seUULqWtbJapLOCVDaaPEHmU= -github.com/json-iterator/go v1.1.9/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4= -github.com/jtolds/gls v4.20.0+incompatible/go.mod h1:QJZ7F/aHp+rZTRtaJ1ow/lLfFfVYBRgL+9YlvaHOwJU= -github.com/k0kubun/colorstring v0.0.0-20150214042306-9440f1994b88/go.mod h1:3w7q1U84EfirKl04SVQ/s7nPm1ZPhiXd34z40TNz36k= -github.com/kataras/golog v0.0.10/go.mod h1:yJ8YKCmyL+nWjERB90Qwn+bdyBZsaQwU3bTVFgkFIp8= -github.com/kataras/iris/v12 v12.1.8/go.mod h1:LMYy4VlP67TQ3Zgriz8RE2h2kMZV2SgMYbq3UhfoFmE= -github.com/kataras/neffos v0.0.14/go.mod h1:8lqADm8PnbeFfL7CLXh1WHw53dG27MC3pgi2R1rmoTE= -github.com/kataras/pio v0.0.2/go.mod h1:hAoW0t9UmXi4R5Oyq5Z4irTbaTsOemSrDGUtaTl7Dro= -github.com/kataras/sitemap v0.0.5/go.mod h1:KY2eugMKiPwsJgx7+U103YZehfvNGOXURubcGyk0Bz8= +github.com/huin/goupnp v1.3.0 h1:UvLUlWDNpoUdYzb2TCn+MuTWtcjXKSza2n6CBdQ0xXc= +github.com/huin/goupnp v1.3.0/go.mod h1:gnGPsThkYa7bFi/KWmEysQRf48l2dvR5bxr2OFckNX8= +github.com/jackpal/go-nat-pmp v1.0.2 h1:KzKSgb7qkJvOUTqYl9/Hg/me3pWgBmERKrTGD7BdWus= +github.com/jackpal/go-nat-pmp v1.0.2/go.mod h1:QPH045xvCAeXUZOxsnwmrtiCoxIr9eob+4orBN1SBKc= github.com/kisielk/errcheck v1.5.0/go.mod h1:pFxgyoBC7bSaBwPgfKdkLd5X25qrDl4LWUI2bnpBCr8= github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck= -github.com/klauspost/compress v1.8.2/go.mod h1:RyIbtBH6LamlWaDj8nUwkbUhJ87Yi3uG0guNDohfE1A= -github.com/klauspost/compress v1.9.7/go.mod h1:RyIbtBH6LamlWaDj8nUwkbUhJ87Yi3uG0guNDohfE1A= github.com/klauspost/compress v1.15.15 h1:EF27CXIuDsYJ6mmvtBRlEuB2UVOqHG1tAXgZ7yIO+lw= github.com/klauspost/compress v1.15.15/go.mod h1:ZcK2JAFqKOpnBlxcLsJzYfrS9X1akm9fHZNnD9+Vo/4= -github.com/klauspost/cpuid v1.2.1/go.mod h1:Pj4uuM528wm8OyEC2QMXAi2YiTZ96dNQPGgoMS4s3ek= -github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo= -github.com/kr/pretty v0.3.0/go.mod h1:640gp4NfQd8pI5XOwp5fnNeVWj67G7CFk/SaSQn7NBk= github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE= github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk= -github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ= -github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI= github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY= github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE= github.com/kylelemons/godebug v1.1.0 h1:RPNrshWIDI6G2gRW9EHilWtl7Z6Sb1BR0xunSBf0SNc= -github.com/labstack/echo/v4 v4.5.0/go.mod h1:czIriw4a0C1dFun+ObrXp7ok03xON0N1awStJ6ArI7Y= -github.com/labstack/gommon v0.3.0/go.mod h1:MULnywXg0yavhxWKc+lOruYdAhDwPK9wf0OL7NoOu+k= -github.com/magiconair/properties v1.8.0/go.mod h1:PppfXfuXeibc/6YijjN8zIbojt8czPbwD3XqdrwzmxQ= -github.com/mattn/go-colorable v0.1.2/go.mod h1:U0ppj6V5qS13XJ6of8GYAs25YV2eR4EVcfRqFIhoBtE= -github.com/mattn/go-colorable v0.1.8/go.mod h1:u6P/XSegPjTcexA+o6vUJrdnUu04hMope9wVRipJSqc= -github.com/mattn/go-colorable v0.1.11/go.mod h1:u5H1YNBxpqRaxsYJYSkiCWKzEfiAb1Gb520KVy5xxl4= -github.com/mattn/go-isatty v0.0.7/go.mod h1:Iq45c/XA43vh69/j3iqttzPXn0bhXyGjM0Hdxcsrc5s= -github.com/mattn/go-isatty v0.0.8/go.mod h1:Iq45c/XA43vh69/j3iqttzPXn0bhXyGjM0Hdxcsrc5s= -github.com/mattn/go-isatty v0.0.9/go.mod h1:YNRxwqDuOph6SZLI9vUUz6OYw3QyUt7WiY2yME+cCiQ= -github.com/mattn/go-isatty v0.0.12/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Kysco4FUpU= -github.com/mattn/go-isatty v0.0.14/go.mod h1:7GGIvUiUoEMVVmxf/4nioHXj79iQHKdU27kJ6hsGG94= -github.com/mattn/go-runewidth v0.0.9 h1:Lm995f3rfxdpd6TSmuVCHVb/QhupuXlYr8sCI/QdE+0= +github.com/kylelemons/godebug v1.1.0/go.mod h1:9/0rRGxNHcop5bhtWyNeEfOS8JIWk580+fNqagV/RAw= +github.com/leanovate/gopter v0.2.9 h1:fQjYxZaynp97ozCzfOyOuAGOU4aU/z37zf/tOujFk7c= +github.com/leanovate/gopter v0.2.9/go.mod h1:U2L/78B+KVFIx2VmW6onHJQzXtFb+p5y3y2Sh+Jxxv8= github.com/mattn/go-runewidth v0.0.9/go.mod h1:H031xJmbD/WCDINGzjvQ9THkh0rPKHF+m2gUSrubnMI= -github.com/mattn/goveralls v0.0.2/go.mod h1:8d1ZMHsd7fW6IRPKQh46F2WRpyib5/X4FOpevwGNQEw= +github.com/mattn/go-runewidth v0.0.13 h1:lTGmDsbAYt5DmK6OnoV7EuIF1wEIFAcxld6ypU4OSgU= +github.com/mattn/go-runewidth v0.0.13/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w= github.com/matttproud/golang_protobuf_extensions v1.0.4 h1:mmDVorXM7PCGKw94cs5zkfA9PSy5pEvNWRP0ET0TIVo= github.com/matttproud/golang_protobuf_extensions v1.0.4/go.mod h1:BSXmuO+STAnVfrANrmjBb36TMTDstsz7MSK+HVaYKv4= -github.com/mediocregopher/radix/v3 v3.4.2/go.mod h1:8FL3F6UQRXHXIBSPUs5h0RybMF8i4n7wVopoX3x7Bv8= -github.com/microcosm-cc/bluemonday v1.0.2/go.mod h1:iVP4YcDBq+n/5fb23BhYFvIMq/leAFZyRl6bYmGDlGc= -github.com/mitchellh/go-homedir v1.1.0/go.mod h1:SfyaCUpYCn1Vlf4IUYiD9fPX4A5wJrkLzIz1N1q0pr0= -github.com/mitchellh/mapstructure v1.1.2/go.mod h1:FVVH3fgwuzCH5S8UJGiWEs2h04kUh9fWfEaFds41c1Y= -github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q= -github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q= -github.com/modern-go/reflect2 v0.0.0-20180701023420-4b7aa43c6742/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0= -github.com/modern-go/reflect2 v1.0.1/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0= -github.com/moul/http2curl v1.0.0/go.mod h1:8UbvGypXm98wA/IqH45anm5Y2Z6ep6O31QGOAZ3H0fQ= -github.com/nats-io/jwt v0.3.0/go.mod h1:fRYCDE99xlTsqUzISS1Bi75UBJ6ljOJQOAAu5VglpSg= -github.com/nats-io/nats.go v1.9.1/go.mod h1:ZjDU1L/7fJ09jvUSRVBR2e7+RnLiiIQyqyzEE/Zbp4w= -github.com/nats-io/nkeys v0.1.0/go.mod h1:xpnFELMwJABBLVhffcfd1MZx6VsNRFpEugbxziKVo7w= -github.com/nats-io/nuid v1.0.1/go.mod h1:19wcPz3Ph3q0Jbyiqsd0kePYG7A95tJPxeL+1OSON2c= +github.com/mmcloughlin/addchain v0.4.0 h1:SobOdjm2xLj1KkXN5/n0xTIWyZA2+s99UCY1iPfkHRY= +github.com/mmcloughlin/addchain v0.4.0/go.mod h1:A86O+tHqZLMNO4w6ZZ4FlVQEadcoqkyU72HC5wJ4RlU= +github.com/mmcloughlin/profile v0.1.1/go.mod h1:IhHD7q1ooxgwTgjxQYkACGA77oFTDdFVejUS1/tS/qU= github.com/nxadm/tail v1.4.4 h1:DQuhQpB1tVlglWS2hLQ5OV6B5r8aGxSrPc5Qo6uTN78= github.com/nxadm/tail v1.4.4/go.mod h1:kenIhsEOeOJmVchQTgglprH7qJGnHDVpk1VPCcaMI8A= github.com/olekukonko/tablewriter v0.0.5 h1:P2Ga83D34wi1o9J6Wh1mRuqd4mF/x/lgBS7N7AbDhec= github.com/olekukonko/tablewriter v0.0.5/go.mod h1:hPp6KlRPjbx+hW8ykQs1w3UBbZlj6HuIJcUGPhkA7kY= github.com/onsi/ginkgo v1.6.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE= -github.com/onsi/ginkgo v1.10.3/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE= github.com/onsi/ginkgo v1.12.1/go.mod h1:zj2OWP4+oCPe1qIXoGWkgMRwljMUYCdkwsT2108oapk= github.com/onsi/ginkgo v1.14.0 h1:2mOpI4JVVPBN+WQRa0WKH2eXR+Ey+uK4n7Zj0aYpIQA= github.com/onsi/ginkgo v1.14.0/go.mod h1:iSB4RoI2tjJc9BBv4NKIKWKya62Rps+oPG/Lv9klQyY= github.com/onsi/gomega v1.7.1/go.mod h1:XdKZgCCFLUoM/7CFJVPcG8C1xQ1AJ0vpAezJrB7JYyY= github.com/onsi/gomega v1.10.1 h1:o0+MgICZLuZ7xjH7Vx6zS/zcu93/BEp1VwkIW1mEXCE= github.com/onsi/gomega v1.10.1/go.mod h1:iN09h71vgCQne3DLsj+A5owkum+a2tYe+TOCB1ybHNo= -github.com/pelletier/go-toml v1.2.0/go.mod h1:5z9KED0ma1S8pY6P1sdut58dfprrGBbd/94hg7ilaic= github.com/pingcap/errors v0.11.4 h1:lFuQV/oaUMGcD2tqt+01ROSmJs75VG1ToEOkZIZ4nE4= github.com/pingcap/errors v0.11.4/go.mod h1:Oi8TUi2kEtXXLMJk9l1cGmz20kV3TaQ0usTwv5KuLY8= github.com/pkg/diff v0.0.0-20210226163009-20ebb0f2a09e/go.mod h1:pJLUxLENpZxwdsKMEsNbx1VGcRFpLqf3715MtcvvzbA= -github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4= github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= github.com/prometheus/client_golang v1.14.0 h1:nJdhIvne2eSX/XRAFV9PcvFFRbrjbcTUj0VP62TMhnw= github.com/prometheus/client_golang v1.14.0/go.mod h1:8vpkKitgIVNcqrRBWh1C4TIUQgYNtG/XQE4E/Zae36Y= -github.com/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA= github.com/prometheus/client_model v0.3.0 h1:UBgGFHqYdG/TPFD1B1ogZywDqEkwp3fBMvqdiQ7Xew4= github.com/prometheus/client_model v0.3.0/go.mod h1:LDGWKZIo7rky3hgvBe+caln+Dr3dPggB5dvjtD7w9+w= github.com/prometheus/common v0.39.0 h1:oOyhkDq05hPZKItWVBkJ6g6AtGxi+fy7F4JvUV8uhsI= github.com/prometheus/common v0.39.0/go.mod h1:6XBZ7lYdLCbkAVhwRsWTZn+IN5AB9F/NXd5w0BbEX0Y= github.com/prometheus/procfs v0.9.0 h1:wzCHvIvM5SxWqYvwgVL7yJY8Lz3PKn49KQtpgMYJfhI= github.com/prometheus/procfs v0.9.0/go.mod h1:+pB4zwohETzFnmlpe6yd2lSc+0/46IYZRB/chUwxUZY= -github.com/rogpeppe/go-internal v1.6.1/go.mod h1:xXDCJY+GAPziupqXw64V24skbSoqbTEfhy4qGm1nDQc= -github.com/rogpeppe/go-internal v1.8.1/go.mod h1:JeRgkft04UBgHMgCIwADu4Pn6Mtm5d4nPKWu0nJ5d+o= +github.com/rivo/uniseg v0.2.0 h1:S1pD9weZBuJdFmowNwbpi7BJ8TNftyUImj/0WQi72jY= +github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc= github.com/rogpeppe/go-internal v1.9.0 h1:73kH8U+JUqXU8lRuOHeVHaa/SZPifC7BkcraZVejAe8= github.com/rogpeppe/go-internal v1.9.0/go.mod h1:WtVeX8xhTBvf0smdhujwtBcq4Qrzq/fJaraNFVN+nFs= -github.com/russross/blackfriday v1.5.2/go.mod h1:JO/DiYxRf+HjHt06OyowR9PTA263kcR/rfWxYHBV53g= -github.com/ryanuber/columnize v2.1.0+incompatible/go.mod h1:sm1tb6uqfes/u+d4ooFouqFdy9/2g9QGwK3SQygK0Ts= -github.com/schollz/closestmatch v2.1.0+incompatible/go.mod h1:RtP1ddjLong6gTkbtmuhtR2uUrrJOpYzYRvbcPAid+g= -github.com/sergi/go-diff v1.0.0/go.mod h1:0CfEIISq7TuYL3j771MWULgwwjU+GofnZX9QAmXWZgo= github.com/shirou/gopsutil v3.21.4-0.20210419000835-c7a38de76ee5+incompatible h1:Bn1aCHHRnjv4Bl16T8rcaFjYSrGrIZvpiGO6P3Q4GpU= github.com/shirou/gopsutil v3.21.4-0.20210419000835-c7a38de76ee5+incompatible/go.mod h1:5b4v6he4MtMOwMlS0TUMTu2PcXUg8+E1lC7eC3UO/RA= -github.com/shurcooL/sanitized_anchor_name v1.0.0/go.mod h1:1NzhyTcUVG4SuEtjjoZeVRXNmyL/1OwPU0+IJeTBvfc= -github.com/smartystreets/assertions v0.0.0-20180927180507-b2de0cb4f26d/go.mod h1:OnSkiWE9lh6wB0YB77sQom3nweQdgAjqCqsofrRNTgc= -github.com/smartystreets/goconvey v1.6.4/go.mod h1:syvi0/a8iFYH4r/RixwvyeAJjdLS9QV7WQ/tjFTllLA= -github.com/spf13/afero v1.1.2/go.mod h1:j4pytiNVoe2o6bmDsKpLACNPDBIoEAkihy7loJ1B0CQ= -github.com/spf13/cast v1.3.0/go.mod h1:Qx5cxh0v+4UWYiBimWS+eyWzqEqokIECu5etghLkUJE= -github.com/spf13/cobra v0.0.5/go.mod h1:3K3wKZymM7VvHMDS9+Akkh4K60UwM26emMESw8tLCHU= -github.com/spf13/jwalterweatherman v1.0.0/go.mod h1:cQK4TGJAtQXfYWX+Ddv3mKDzgVb68N+wFjFa4jdeBTo= -github.com/spf13/pflag v1.0.3/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4= -github.com/spf13/viper v1.3.2/go.mod h1:ZiWeW+zYFKm7srdB9IoDzzZXaJaI5eL9QjNiN/DMA2s= +github.com/status-im/keycard-go v0.2.0 h1:QDLFswOQu1r5jsycloeQh3bVU8n/NatHHaZobtDnDzA= +github.com/status-im/keycard-go v0.2.0/go.mod h1:wlp8ZLbsmrF6g6WjugPAx+IzoLrkdf9+mHxBEeo3Hbg= github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= -github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs= github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI= -github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4= -github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA= -github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= -github.com/stretchr/testify v1.8.0 h1:pSgiaMZlXftHpm5L7V1+rVB+AZJydKsMxsQBIJw4PKk= +github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk= +github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo= +github.com/supranational/blst v0.3.11 h1:LyU6FolezeWAhvQk0k6O/d49jqgO52MSDDfYgbeoEm4= +github.com/supranational/blst v0.3.11/go.mod h1:jZJtfjgudtNl4en1tzwPIV3KjUnQUvG3/j+w+fVonLw= github.com/syndtr/goleveldb v1.0.1-0.20210819022825-2ae1ddf74ef7 h1:epCh84lMvA70Z7CTTCmYQn2CKbY8j86K7/FAIr141uY= github.com/syndtr/goleveldb v1.0.1-0.20210819022825-2ae1ddf74ef7/go.mod h1:q4W45IWZaF22tdD+VEXcAWRA037jwmWEB5VWYORlTpc= -github.com/tklauser/go-sysconf v0.3.5 h1:uu3Xl4nkLzQfXNsWn15rPc/HQCJKObbt1dKJeWp3vU4= -github.com/tklauser/go-sysconf v0.3.5/go.mod h1:MkWzOF4RMCshBAMXuhXJs64Rte09mITnppBXY/rYEFI= -github.com/tklauser/numcpus v0.2.2 h1:oyhllyrScuYI6g+h/zUvNXNp1wy7x8qQy3t/piefldA= -github.com/tklauser/numcpus v0.2.2/go.mod h1:x3qojaO3uyYt0i56EW/VUYs7uBvdl2fkfZFu0T9wgjM= -github.com/ugorji/go v1.1.4/go.mod h1:uQMGLiO92mf5W77hV/PUCpI3pbzQx3CRekS0kk+RGrc= -github.com/ugorji/go v1.1.7/go.mod h1:kZn38zHttfInRq0xu/PH0az30d+z6vm202qpg1oXVMw= -github.com/ugorji/go/codec v0.0.0-20181204163529-d75b2dcb6bc8/go.mod h1:VFNgLljTbGfSG7qAOspJ7OScBnGdDN/yBr0sguwnwf0= -github.com/ugorji/go/codec v1.1.7/go.mod h1:Ax+UKWsSmolVDwsd+7N3ZtXu+yMGCf907BLYF3GoBXY= -github.com/urfave/negroni v1.0.0/go.mod h1:Meg73S6kFm/4PpbYdq35yYWoCZ9mS/YSx+lKnmiohz4= -github.com/valyala/bytebufferpool v1.0.0/go.mod h1:6bBcMArwyJ5K/AmCkWv1jt77kVWyCJ6HpOuEn7z0Csc= -github.com/valyala/fasthttp v1.6.0/go.mod h1:FstJa9V+Pj9vQ7OJie2qMHdwemEDaDiSdBnvPM1Su9w= -github.com/valyala/fasttemplate v1.0.1/go.mod h1:UQGH1tvbgY+Nz5t2n7tXsz52dQxojPUpymEIMZ47gx8= -github.com/valyala/fasttemplate v1.2.1/go.mod h1:KHLXt3tVN2HBp8eijSv/kGJopbvo7S+qRAEEKiv+SiQ= -github.com/valyala/tcplisten v0.0.0-20161114210144-ceec8f93295a/go.mod h1:v3UYOV9WzVtRmSR+PDvWpU/qWl4Wa5LApYYX4ZtKbio= -github.com/xeipuuv/gojsonpointer v0.0.0-20180127040702-4e3ac2762d5f/go.mod h1:N2zxlSyiKSe5eX1tZViRH5QA0qijqEDrYZiPEAiq3wU= -github.com/xeipuuv/gojsonreference v0.0.0-20180127040603-bd5ef7bd5415/go.mod h1:GwrjFmJcFw6At/Gs6z4yjiIwzuJ1/+UwLxMQDVQXShQ= -github.com/xeipuuv/gojsonschema v1.2.0/go.mod h1:anYRn/JVcOK2ZgGU+IjEV4nwlhoK5sQluxsYJ78Id3Y= -github.com/xordataexchange/crypt v0.0.3-0.20170626215501-b2862e3d0a77/go.mod h1:aYKd//L2LvnjZzWKhF00oedf4jCCReLcmhLdhm1A27Q= -github.com/yalp/jsonpath v0.0.0-20180802001716-5cc68e5049a0/go.mod h1:/LWChgwKmvncFJFHJ7Gvn9wZArjbV5/FppcK2fKk/tI= -github.com/yudai/gojsondiff v1.0.0/go.mod h1:AY32+k2cwILAkW1fbgxQ5mUmMiZFgLIV+FBNExI05xg= -github.com/yudai/golcs v0.0.0-20170316035057-ecda9a501e82/go.mod h1:lgjkn3NuSvDfVJdfcVVdX+jpBxNmX4rDAzaS45IcYoM= -github.com/yudai/pp v2.0.1+incompatible/go.mod h1:PuxR/8QJ7cyCkFp/aUDS+JY727OFEZkTdatxwunjIkc= +github.com/tklauser/go-sysconf v0.3.12 h1:0QaGUFOdQaIVdPgfITYzaTegZvdCjmYO52cSFAEVmqU= +github.com/tklauser/go-sysconf v0.3.12/go.mod h1:Ho14jnntGE1fpdOqQEEaiKRpvIavV0hSfmBq8nJbHYI= +github.com/tklauser/numcpus v0.6.1 h1:ng9scYS7az0Bk4OZLvrNXNSAO2Pxr1XXRAPyjhIx+Fk= +github.com/tklauser/numcpus v0.6.1/go.mod h1:1XfjsgE2zo8GVw7POkMbHENHzVg3GzmoZ9fESEdAacY= +github.com/tyler-smith/go-bip39 v1.1.0 h1:5eUemwrMargf3BSLRRCalXT93Ns6pQJIjYQN2nyfOP8= +github.com/tyler-smith/go-bip39 v1.1.0/go.mod h1:gUYDtqQw1JS3ZJ8UWVcGTGqqr6YIN3CWg+kkNaLt55U= github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= -github.com/yuin/goldmark v1.3.5/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k= -golang.org/x/crypto v0.0.0-20181203042331-505ab145d0a9/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4= golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= -golang.org/x/crypto v0.0.0-20190701094942-4def268fd1a4/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= -golang.org/x/crypto v0.0.0-20191227163750-53104e6ec876/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= -golang.org/x/crypto v0.0.0-20210322153248-0c34fe9e7dc2/go.mod h1:T9bdIzuCu7OtxOm1hfPfRQxPLYneinmdGuTeoZ9dtd4= -golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc= -golang.org/x/crypto v0.1.0 h1:MDRAIl0xIo9Io2xV565hzXHw3zVseKrJKodhohM5CjU= -golang.org/x/crypto v0.1.0/go.mod h1:RecgLatLF4+eUMCP1PoPZQb+cVrJcOPbHkTkbkB9sbw= -golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= -golang.org/x/exp v0.0.0-20230206171751-46f607a40771 h1:xP7rWLUr1e1n2xkK5YB4LI0hPEy3LJC6Wk+D4pGlOJg= -golang.org/x/exp v0.0.0-20230206171751-46f607a40771/go.mod h1:CxIveKay+FTh1D0yPZemJVgC/95VzuuOLq5Qi4xnoYc= -golang.org/x/lint v0.0.0-20181026193005-c67002cb31c3/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE= -golang.org/x/lint v0.0.0-20190227174305-5b3e6a55c961/go.mod h1:wehouNa3lNwaWXcvxsM5YxQ5yQlVC4a0KAMCusXpPoU= -golang.org/x/lint v0.0.0-20190313153728-d0100b6bd8b3/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc= -golang.org/x/lint v0.0.0-20210508222113-6edffad5e616/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY= -golang.org/x/mod v0.1.1-0.20191105210325-c90efee705ee/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg= +golang.org/x/crypto v0.21.0 h1:X31++rzVUdKhX5sWmSOFZxx8UW/ldWx55cbf08iNAMA= +golang.org/x/crypto v0.21.0/go.mod h1:0BP7YvVV9gBbVKyeTG0Gyn+gZm94bibOW5BjDEYAOMs= +golang.org/x/exp v0.0.0-20231110203233-9a3e6036ecaa h1:FRnLl4eNAQl8hwxVVC17teOw8kdjVDVAiFMtgUdTSRQ= +golang.org/x/exp v0.0.0-20231110203233-9a3e6036ecaa/go.mod h1:zk2irFbV9DP96SEBUUAy67IdHUaZuSnrz1n472HUCLE= golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= -golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= -golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= -golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= +golang.org/x/mod v0.14.0 h1:dGoOF9QVLYng8IHTm7BAyWqCqSheQ5pYWGhzW00YJr0= +golang.org/x/mod v0.14.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c= golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= -golang.org/x/net v0.0.0-20181220203305-927f97764cc3/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= -golang.org/x/net v0.0.0-20190213061140-3a22650c66bd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= -golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= -golang.org/x/net v0.0.0-20190327091125-710a502c58a2/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= -golang.org/x/net v0.0.0-20190503192946-f4e77d36d62c/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= -golang.org/x/net v0.0.0-20190827160401-ba9fcec4b297/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= -golang.org/x/net v0.0.0-20191209160850-c0dbc17a3553/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.0.0-20200520004742-59133d7f0dd7/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= golang.org/x/net v0.0.0-20200813134508-3edf25e44fcc/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA= golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= -golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= -golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM= -golang.org/x/net v0.0.0-20211008194852-3b03d305991f/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= -golang.org/x/net v0.4.0 h1:Q5QPcMlvfxFTAPV0+07Xz/MpK9NTXu2VDUuy0FeMfaU= -golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U= +golang.org/x/net v0.21.0 h1:AQyQV4dYCvJ7vGmJyKki9+PBdyvhkSd8EIx/qb0AYv4= +golang.org/x/net v0.21.0/go.mod h1:bIjVDfnllIU7BJ2DNgfnXvpSvtn8VRwhlsaeUTyUS44= golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= -golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= -golang.org/x/sync v0.0.0-20190227155943-e225da77a7e6/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= -golang.org/x/sync v0.1.0 h1:wsuoTGHzEhffawBOhz5CYhcrV4IdKZbEyZjBMuTp12o= -golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sync v0.5.0 h1:60k92dhOjHxJkrqnwsfl8KuaHbn/5dl0lUPUklKo3qE= +golang.org/x/sync v0.5.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk= golang.org/x/sys v0.0.0-20180909124046-d0be0721c37e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= -golang.org/x/sys v0.0.0-20181205085412-a5c9d58dba9a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= -golang.org/x/sys v0.0.0-20190222072716-a9d3bda3a223/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20190626221950-04f50cda93cb/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20190813064441-fde4db37ae7a/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20190904154756-749cb33beabd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20190916202348-b4ddaad3f8a3/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20191005200804-aed5e4c7ecf9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20191120155948-bd437916bb0e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20200116001909-b77594299b42/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20200223170610-d5e6a3e2c0ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200519105757-fe76b779f299/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200814200057-3d37ad5750ed/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20210316164454-77fc1eacc6aa/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20210324051608-47abb6519492/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20210403161142-5e06dd20ab57/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20210510120138-977fb7262007/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20210630005230-0f9fa26af87c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20210927094055-39ccf1dd6fa6/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20211007075335-d3039528d8ac/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20220209214540-3681064d5158/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.5.0 h1:MUK/U/4lj1t1oPg0HfuXDN/Z1wv31ZJ/YcPiGccS4DU= +golang.org/x/sys v0.0.0-20220908164124-27713097b956/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.1.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= +golang.org/x/sys v0.8.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.11.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.18.0 h1:DBdB3niSjOA/O0blCZBqDefyWNYveAYMNF1Wum0DYQ4= +golang.org/x/sys v0.18.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk= golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= -golang.org/x/text v0.3.5/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= -golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= -golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ= -golang.org/x/text v0.7.0 h1:4BRB4x83lYWy72KwLD/qYDuTu7q9PjSagHvijDw7cLo= -golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8= -golang.org/x/time v0.0.0-20201208040808-7e3f01d25324/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= +golang.org/x/text v0.14.0 h1:ScX5w1eTa3QqT8oi6+ziP7dTV1S2+ALU0bI+0zXKWiQ= +golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU= golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= -golang.org/x/tools v0.0.0-20181221001348-537d06c36207/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= -golang.org/x/tools v0.0.0-20190114222345-bf090417da8b/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= -golang.org/x/tools v0.0.0-20190226205152-f727befe758c/go.mod h1:9Yl7xja0Znq3iFh3HoIrodX9oNMXvdceNzlUR8zjMvY= -golang.org/x/tools v0.0.0-20190311212946-11955173bddd/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs= -golang.org/x/tools v0.0.0-20190327201419-c70d86f8b7cf/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs= -golang.org/x/tools v0.0.0-20190328211700-ab21143f2384/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs= -golang.org/x/tools v0.0.0-20190524140312-2c0ae7006135/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q= golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= -golang.org/x/tools v0.0.0-20200130002326-2f3ba24bd6e7/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= golang.org/x/tools v0.0.0-20200619180055-7c47624df98f/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= golang.org/x/tools v0.0.0-20210106214847-113979e3529a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= -golang.org/x/tools v0.1.3/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk= +golang.org/x/tools v0.15.0 h1:zdAyfUGbYmuVokhzVmghFl2ZJh5QhcfebBgmVPFYA+8= +golang.org/x/tools v0.15.0/go.mod h1:hpksKq4dtpQWS1uQ61JkdqWM3LscIS6Slf+VVkm+wQk= golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 h1:go1bK/D/BFZV2I8cIQd1NKEZ+0owSTG1fDTci4IqFcE= golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= -golang.org/x/xerrors v0.0.0-20220517211312-f3a8303e98df h1:5Pf6pFKu98ODmgnpvkJ3kFUOQGGLIzLIkbzUHp47618= -google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM= -google.golang.org/appengine v1.4.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4= -google.golang.org/genproto v0.0.0-20180518175338-11a468237815/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc= -google.golang.org/genproto v0.0.0-20180817151627-c66870c02cf8/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc= -google.golang.org/genproto v0.0.0-20190819201941-24fa4b261c55/go.mod h1:DMBHOl98Agz4BDEuKkezgsaosCRResVns1a3J2ZsMNc= -google.golang.org/genproto v0.0.0-20200526211855-cb27e3aa2013/go.mod h1:NbSheEEYHJ7i3ixzK3sjbqSGDJWnxyFXZblF3eUsNvo= -google.golang.org/genproto v0.0.0-20210624195500-8bfb893ecb84/go.mod h1:SzzZ/N+nwJDaO1kznhnlzqS8ocJICar6hYhVyhi++24= -google.golang.org/grpc v1.12.0/go.mod h1:yo6s7OP7yaDglbqo1J04qKzAhqBH6lvTonzMVmEdcZw= -google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c= -google.golang.org/grpc v1.23.0/go.mod h1:Y5yQAOtifL1yxbo5wqy6BxZv8vAUGQwXBOALyacEbxg= -google.golang.org/grpc v1.25.1/go.mod h1:c3i+UQWmh7LiEpx4sFZnkU36qjEYZ0imhYfXVyQciAY= -google.golang.org/grpc v1.27.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk= -google.golang.org/grpc v1.38.0/go.mod h1:NREThFqKR1f3iQ6oBuvc5LadQuXVGo9rkm5ZGrQdJfM= google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8= google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0= google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQJ+fmap5saPgwCLgHXTUD7jkjRqWcaiX5VyM= google.golang.org/protobuf v1.20.1-0.20200309200217-e05f789c0967/go.mod h1:A+miEFZTKqfCUM6K7xSMQL9OKL/b6hQv+e19PK+JZNE= google.golang.org/protobuf v1.21.0/go.mod h1:47Nbq4nVaFHyn7ilMalzfO3qCViNmqZ2kzikPIcrTAo= -google.golang.org/protobuf v1.22.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU= google.golang.org/protobuf v1.23.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU= -google.golang.org/protobuf v1.23.1-0.20200526195155-81db48ad09cc/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU= -google.golang.org/protobuf v1.25.0/go.mod h1:9JNX74DMeImyA3h4bdi1ymwjUzf21/xIlbajtzgsN7c= -google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw= -google.golang.org/protobuf v1.26.0/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc= -google.golang.org/protobuf v1.28.1 h1:d0NfwRgPtno5B1Wa6L2DAG+KivqkdutMf1UhdNx175w= -google.golang.org/protobuf v1.28.1/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I= +google.golang.org/protobuf v1.33.0 h1:uNO2rsAINq/JlFpSdYEKIZ0uKD/R9cpdv0T+yoGwGmI= +google.golang.org/protobuf v1.33.0/go.mod h1:c6P6GXX6sHbq/GpV6MGZEdwhWPcYBgnhAHhKbcUYpos= gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= -gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= -gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk= -gopkg.in/errgo.v2 v2.1.0/go.mod h1:hNsd1EY+bozCKY1Ytp96fpM3vjJbqLJn88ws8XvfDNI= +gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q= gopkg.in/fsnotify.v1 v1.4.7/go.mod h1:Tz8NjZHkW78fSQdbUxIjBTcgA1z1m8ZHf0WmKUhAMys= -gopkg.in/go-playground/assert.v1 v1.2.1/go.mod h1:9RXL0bg/zibRAgZUYszZSwO/z8Y/a8bDuhia5mkpMnE= -gopkg.in/go-playground/validator.v8 v8.18.2/go.mod h1:RX2a/7Ha8BgOhfk7j780h4/u/RRjR0eouCJSH80/M2Y= -gopkg.in/ini.v1 v1.51.1/go.mod h1:pNLf8WUiyNEtQjuu5G5vTm06TEv9tsIgeAvK8hOrP4k= -gopkg.in/mgo.v2 v2.0.0-20180705113604-9856a29383ce/go.mod h1:yeKp02qBN3iKW1OzL3MGk2IdtZzaj7SFntXj72NppTA= -gopkg.in/natefinch/npipe.v2 v2.0.0-20160621034901-c1b8fa8bdcce h1:+JknDZhAj8YMt7GC73Ei8pv4MzjDUNPHgQWJdtMAaDU= -gopkg.in/natefinch/npipe.v2 v2.0.0-20160621034901-c1b8fa8bdcce/go.mod h1:5AcXVHNjg+BDxry382+8OKon8SEWiKktQR07RKPsv1c= gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7 h1:uRGJdciOHaEIrze2W8Q3AKkepLTh2hOroT7a+7czfdQ= gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7/go.mod h1:dt/ZhP58zS4L8KSrWDmTeBkI65Dw0HsyUHuEVlX15mw= -gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= gopkg.in/yaml.v2 v2.2.4/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= gopkg.in/yaml.v2 v2.3.0/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY= -gopkg.in/yaml.v3 v3.0.0-20191120175047-4206685974f2/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= -gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= -gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= +gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ= gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= -honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= -honnef.co/go/tools v0.0.0-20190523083050-ea95bdfd59fc/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= +gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= +rsc.io/tmplfunc v0.0.3 h1:53XFQh69AfOa8Tw0Jm7t+GV7KZhOi6jzsCzTtKbMvzU= +rsc.io/tmplfunc v0.0.3/go.mod h1:AG3sTPzElb1Io3Yg4voV9AGZJuleGAwaVRxL9M49PhA= diff --git a/geth-utils/src/block.rs b/geth-utils/src/block.rs index 1df6fd9514..7f95617c9f 100644 --- a/geth-utils/src/block.rs +++ b/geth-utils/src/block.rs @@ -25,7 +25,9 @@ pub fn trace(config: &str) -> Result { // Return the trace match result.is_empty() || result.starts_with("Failed") { - true => Err(Error::TracingError(result)), + true => Ok(format!( + "[\n{{\n\"gas\": 0,\n\"failed\": true,\n\"invalid\": true,\n\"returnValue\": \"{result}\",\n\"structLogs\": []\n}}\n]" + )), false => Ok(result), } } diff --git a/zkevm-circuits/src/evm_circuit/execution.rs b/zkevm-circuits/src/evm_circuit/execution.rs index e4c628ed16..d746780e9b 100644 --- a/zkevm-circuits/src/evm_circuit/execution.rs +++ b/zkevm-circuits/src/evm_circuit/execution.rs @@ -129,6 +129,8 @@ mod sload; mod sstore; mod stop; mod swap; +mod tload; +mod tstore; use self::{ begin_chunk::BeginChunkGadget, block_ctx::BlockCtxGadget, end_chunk::EndChunkGadget, @@ -214,6 +216,8 @@ use sload::SloadGadget; use sstore::SstoreGadget; use stop::StopGadget; use swap::SwapGadget; +use tload::TloadGadget; +use tstore::TstoreGadget; pub(crate) trait ExecutionGadget { const NAME: &'static str; @@ -318,6 +322,8 @@ pub struct ExecutionConfig { signextend_gadget: Box>, sload_gadget: Box>, sstore_gadget: Box>, + tload_gadget: Box>, + tstore_gadget: Box>, stop_gadget: Box>, swap_gadget: Box>, blockhash_gadget: Box>, @@ -647,6 +653,8 @@ impl ExecutionConfig { signextend_gadget: configure_gadget!(), sload_gadget: configure_gadget!(), sstore_gadget: configure_gadget!(), + tload_gadget: configure_gadget!(), + tstore_gadget: configure_gadget!(), stop_gadget: configure_gadget!(), swap_gadget: configure_gadget!(), block_ctx_gadget: configure_gadget!(), @@ -1575,6 +1583,8 @@ impl ExecutionConfig { ExecutionState::SIGNEXTEND => assign_exec_step!(self.signextend_gadget), ExecutionState::SLOAD => assign_exec_step!(self.sload_gadget), ExecutionState::SSTORE => assign_exec_step!(self.sstore_gadget), + ExecutionState::TLOAD => assign_exec_step!(self.tload_gadget), + ExecutionState::TSTORE => assign_exec_step!(self.tstore_gadget), ExecutionState::STOP => assign_exec_step!(self.stop_gadget), ExecutionState::SWAP => assign_exec_step!(self.swap_gadget), // dummy errors diff --git a/zkevm-circuits/src/evm_circuit/execution/sstore.rs b/zkevm-circuits/src/evm_circuit/execution/sstore.rs index 8c6a57cf6e..f54e7dfd6e 100644 --- a/zkevm-circuits/src/evm_circuit/execution/sstore.rs +++ b/zkevm-circuits/src/evm_circuit/execution/sstore.rs @@ -56,7 +56,7 @@ impl ExecutionGadget for SstoreGadget { let tx_id = cb.call_context(None, CallContextFieldTag::TxId); - // constrain not in static call + // Constrain we're not in a STATICCALL context. let is_static = cb.call_context(None, CallContextFieldTag::IsStatic); cb.require_zero("is_static is false", is_static.expr()); diff --git a/zkevm-circuits/src/evm_circuit/execution/tload.rs b/zkevm-circuits/src/evm_circuit/execution/tload.rs new file mode 100644 index 0000000000..c0eeda6bcd --- /dev/null +++ b/zkevm-circuits/src/evm_circuit/execution/tload.rs @@ -0,0 +1,164 @@ +use crate::{ + evm_circuit::{ + execution::ExecutionGadget, + step::ExecutionState, + util::{ + common_gadget::SameContextGadget, + constraint_builder::{EVMConstraintBuilder, StepStateTransition, Transition::Delta}, + CachedRegion, Cell, StepRws, + }, + witness::{Block, Call, Chunk, ExecStep, Transaction}, + }, + table::CallContextFieldTag, + util::{ + word::{WordExpr, WordLoHiCell}, + Expr, + }, +}; +use bus_mapping::evm::OpcodeId; +use eth_types::Field; +use halo2_proofs::{circuit::Value, plonk::Error}; + +#[derive(Clone, Debug)] +pub(crate) struct TloadGadget { + same_context: SameContextGadget, + tx_id: Cell, + callee_address: WordLoHiCell, + key: WordLoHiCell, + value: WordLoHiCell, +} + +impl ExecutionGadget for TloadGadget { + const NAME: &'static str = "TLOAD"; + + const EXECUTION_STATE: ExecutionState = ExecutionState::TLOAD; + + fn configure(cb: &mut EVMConstraintBuilder) -> Self { + let opcode = cb.query_cell(); + + let tx_id = cb.call_context(None, CallContextFieldTag::TxId); + let callee_address = cb.call_context_read_as_word(None, CallContextFieldTag::CalleeAddress); + + let key = cb.query_word_unchecked(); + // Pop the key from the stack + cb.stack_pop(key.to_word()); + + let value = cb.query_word_unchecked(); + cb.account_transient_storage_read( + callee_address.to_word(), + key.to_word(), + value.to_word(), + tx_id.expr(), + ); + + cb.stack_push(value.to_word()); + + let step_state_transition = StepStateTransition { + rw_counter: Delta(5.expr()), + program_counter: Delta(1.expr()), + reversible_write_counter: Delta(0.expr()), + gas_left: Delta(-OpcodeId::TLOAD.constant_gas_cost().expr()), + ..Default::default() + }; + let same_context = SameContextGadget::construct(cb, opcode, step_state_transition); + + Self { + same_context, + tx_id, + callee_address, + key, + value, + } + } + + fn assign_exec_step( + &self, + region: &mut CachedRegion<'_, '_, F>, + offset: usize, + block: &Block, + _chunk: &Chunk, + tx: &Transaction, + call: &Call, + step: &ExecStep, + ) -> Result<(), Error> { + self.same_context.assign_exec_step(region, offset, step)?; + + self.tx_id + .assign(region, offset, Value::known(F::from(tx.id)))?; + self.callee_address + .assign_h160(region, offset, call.address)?; + + let mut rws = StepRws::new(block, step); + + rws.offset_add(2); + + let key = rws.next().stack_value(); + rws.next(); // TLOAD rw + let value = rws.next().stack_value(); + + self.key.assign_u256(region, offset, key)?; + self.value.assign_u256(region, offset, value)?; + + Ok(()) + } +} + +#[cfg(test)] +mod test { + + use crate::{evm_circuit::test::rand_word, test_util::CircuitTestBuilder}; + use eth_types::{bytecode, Word}; + use mock::{test_ctx::helpers::tx_from_1_to_0, TestContext, MOCK_ACCOUNTS}; + + fn test_ok(key: Word, value: Word) { + // Here we use two bytecodes to test both is_persistent(STOP) or not(REVERT) + // Besides, in bytecode we use two TLOADs, + // the first TLOAD is used to test cold, and the second is used to test warm + let bytecode_success = bytecode! { + PUSH32(key) + TLOAD + STOP + }; + let bytecode_failure = bytecode! { + PUSH32(key) + TLOAD + PUSH32(0) + PUSH32(0) + REVERT + }; + for bytecode in [bytecode_success, bytecode_failure] { + let ctx = TestContext::<2, 1>::new( + None, + |accs| { + accs[0] + .address(MOCK_ACCOUNTS[0]) + .balance(Word::from(10u64.pow(19))) + .code(bytecode) + .storage(vec![(key, value)].into_iter()); + accs[1] + .address(MOCK_ACCOUNTS[1]) + .balance(Word::from(10u64.pow(19))); + }, + tx_from_1_to_0, + |block, _txs| block, + ) + .unwrap(); + + CircuitTestBuilder::new_from_test_ctx(ctx).run(); + } + } + + #[test] + fn tload_gadget_simple() { + let key = 0x030201.into(); + let value = 0x060504.into(); + test_ok(key, value); + } + + #[test] + fn tload_gadget_rand() { + let key = rand_word(); + let value = rand_word(); + test_ok(key, value); + } +} diff --git a/zkevm-circuits/src/evm_circuit/execution/tstore.rs b/zkevm-circuits/src/evm_circuit/execution/tstore.rs new file mode 100644 index 0000000000..d50bbb0a68 --- /dev/null +++ b/zkevm-circuits/src/evm_circuit/execution/tstore.rs @@ -0,0 +1,181 @@ +use crate::{ + evm_circuit::{ + execution::ExecutionGadget, + step::ExecutionState, + util::{ + common_gadget::SameContextGadget, + constraint_builder::{ + ConstrainBuilderCommon, EVMConstraintBuilder, ReversionInfo, StepStateTransition, + Transition::Delta, + }, + CachedRegion, Cell, StepRws, + }, + witness::{Block, Call, Chunk, ExecStep, Transaction}, + }, + table::CallContextFieldTag, + util::{ + word::{Word32Cell, WordExpr, WordLoHiCell}, + Expr, + }, +}; +use bus_mapping::evm::OpcodeId; +use eth_types::Field; +use halo2_proofs::{circuit::Value, plonk::Error}; + +#[derive(Clone, Debug)] +pub(crate) struct TstoreGadget { + same_context: SameContextGadget, + tx_id: Cell, + is_static: Cell, + reversion_info: ReversionInfo, + callee_address: WordLoHiCell, + key: Word32Cell, + value: Word32Cell, + value_prev: Word32Cell, +} + +impl ExecutionGadget for TstoreGadget { + const NAME: &'static str = "TSTORE"; + + const EXECUTION_STATE: ExecutionState = ExecutionState::TSTORE; + + fn configure(cb: &mut EVMConstraintBuilder) -> Self { + let opcode = cb.query_cell(); + + let tx_id = cb.call_context(None, CallContextFieldTag::TxId); + + // constraint not in static call + let is_static = cb.call_context(None, CallContextFieldTag::IsStatic); + cb.require_zero("is_static is false", is_static.expr()); + + let mut reversion_info = cb.reversion_info_read(None); + let callee_address = cb.call_context_read_as_word(None, CallContextFieldTag::CalleeAddress); + + let key = cb.query_word32(); + // Pop the key from the stack + cb.stack_pop(key.to_word()); + + let value = cb.query_word32(); + // Pop the value from the stack + cb.stack_pop(value.to_word()); + + let value_prev = cb.query_word32(); + cb.account_transient_storage_write( + callee_address.to_word(), + key.to_word(), + value.to_word(), + value_prev.to_word(), + tx_id.expr(), + Some(&mut reversion_info), + ); + + let step_state_transition = StepStateTransition { + rw_counter: Delta(8.expr()), + program_counter: Delta(1.expr()), + stack_pointer: Delta(2.expr()), + reversible_write_counter: Delta(1.expr()), + gas_left: Delta(-OpcodeId::TSTORE.constant_gas_cost().expr()), + ..Default::default() + }; + let same_context = SameContextGadget::construct(cb, opcode, step_state_transition); + + Self { + same_context, + tx_id, + is_static, + reversion_info, + callee_address, + key, + value, + value_prev, + } + } + + fn assign_exec_step( + &self, + region: &mut CachedRegion<'_, '_, F>, + offset: usize, + block: &Block, + _chunk: &Chunk, + tx: &Transaction, + call: &Call, + step: &ExecStep, + ) -> Result<(), Error> { + self.same_context.assign_exec_step(region, offset, step)?; + + self.tx_id + .assign(region, offset, Value::known(F::from(tx.id)))?; + self.is_static + .assign(region, offset, Value::known(F::from(call.is_static as u64)))?; + self.reversion_info.assign( + region, + offset, + call.rw_counter_end_of_reversion, + call.is_persistent, + )?; + self.callee_address + .assign_h160(region, offset, call.address)?; + + let mut rws = StepRws::new(block, step); + + rws.offset_add(5); + + let key = rws.next().stack_value(); + let value = rws.next().stack_value(); + self.key.assign_u256(region, offset, key)?; + self.value.assign_u256(region, offset, value)?; + + let (_, value_prev, _, _) = rws.next().storage_value_aux(); + self.value_prev.assign_u256(region, offset, value_prev)?; + + Ok(()) + } +} + +#[cfg(test)] +mod test { + + use crate::test_util::CircuitTestBuilder; + use eth_types::{bytecode, Word}; + use mock::{test_ctx::helpers::tx_from_1_to_0, TestContext, MOCK_ACCOUNTS}; + + #[test] + fn tstore_gadget_no_refund() { + test_ok( + 0x030201.into(), + 0x060504.into(), + 0x060504.into(), + 0x060504.into(), + ); + } + + fn test_ok(key: Word, value: Word, value_prev: Word, original_value: Word) { + let bytecode = bytecode! { + PUSH32(value_prev) + PUSH32(key) + TSTORE + PUSH32(value) + PUSH32(key) + TSTORE + STOP + }; + let ctx = TestContext::<2, 1>::new( + None, + |accs| { + accs[0] + .address(MOCK_ACCOUNTS[0]) + .balance(Word::from(10u64.pow(19))) + .code(bytecode) + .storage(vec![(key, original_value)].into_iter()); + accs[1] + .address(MOCK_ACCOUNTS[1]) + .balance(Word::from(10u64.pow(19))); + }, + tx_from_1_to_0, + |block, _txs| block, + ) + .unwrap(); + + CircuitTestBuilder::new_from_test_ctx(ctx).run(); + } +} diff --git a/zkevm-circuits/src/evm_circuit/param.rs b/zkevm-circuits/src/evm_circuit/param.rs index f205e14475..6b684b4704 100644 --- a/zkevm-circuits/src/evm_circuit/param.rs +++ b/zkevm-circuits/src/evm_circuit/param.rs @@ -9,7 +9,7 @@ use halo2_proofs::{ use std::collections::HashMap; // Step dimension -pub(crate) const STEP_WIDTH: usize = 139; +pub(crate) const STEP_WIDTH: usize = 140; /// Step height pub const MAX_STEP_HEIGHT: usize = 19; /// The height of the state of a step, used by gates that connect two diff --git a/zkevm-circuits/src/evm_circuit/step.rs b/zkevm-circuits/src/evm_circuit/step.rs index f26f9290f6..d045f18451 100644 --- a/zkevm-circuits/src/evm_circuit/step.rs +++ b/zkevm-circuits/src/evm_circuit/step.rs @@ -119,6 +119,8 @@ pub enum ExecutionState { MSIZE, GAS, JUMPDEST, + TLOAD, + TSTORE, /// PUSH0, PUSH1, PUSH2, ..., PUSH32 PUSH, /// DUP1, DUP2, ..., DUP16 @@ -309,6 +311,8 @@ impl From<&ExecStep> for ExecutionState { OpcodeId::SHL | OpcodeId::SHR => ExecutionState::SHL_SHR, OpcodeId::SLOAD => ExecutionState::SLOAD, OpcodeId::SSTORE => ExecutionState::SSTORE, + OpcodeId::TLOAD => ExecutionState::TLOAD, + OpcodeId::TSTORE => ExecutionState::TSTORE, OpcodeId::CALLDATASIZE => ExecutionState::CALLDATASIZE, OpcodeId::CALLDATACOPY => ExecutionState::CALLDATACOPY, OpcodeId::CHAINID => ExecutionState::CHAINID, @@ -506,6 +510,8 @@ impl ExecutionState { Self::MSIZE => vec![OpcodeId::MSIZE], Self::GAS => vec![OpcodeId::GAS], Self::JUMPDEST => vec![OpcodeId::JUMPDEST], + Self::TLOAD => vec![OpcodeId::TLOAD], + Self::TSTORE => vec![OpcodeId::TSTORE], Self::PUSH => vec![ OpcodeId::PUSH0, OpcodeId::PUSH1, diff --git a/zkevm-circuits/src/evm_circuit/util/constraint_builder.rs b/zkevm-circuits/src/evm_circuit/util/constraint_builder.rs index 6fdcd6d12b..318a759c50 100644 --- a/zkevm-circuits/src/evm_circuit/util/constraint_builder.rs +++ b/zkevm-circuits/src/evm_circuit/util/constraint_builder.rs @@ -1209,6 +1209,56 @@ impl<'a, F: Field> EVMConstraintBuilder<'a, F> { ); } + // Account Transient Storage + pub(crate) fn account_transient_storage_read( + &mut self, + account_address: WordLoHi>, + key: WordLoHi>, + value: WordLoHi>, + tx_id: Expression, + ) { + self.rw_lookup( + "account_transient_storage_read", + false.expr(), + Target::TransientStorage, + RwValues::new( + tx_id, + account_address.compress(), + 0.expr(), + key, + value.clone(), + value, + WordLoHi::zero(), + ), + ); + } + + #[allow(clippy::too_many_arguments)] + pub(crate) fn account_transient_storage_write( + &mut self, + account_address: WordLoHi>, + key: WordLoHi>, + value: WordLoHi>, + value_prev: WordLoHi>, + tx_id: Expression, + reversion_info: Option<&mut ReversionInfo>, + ) { + self.reversible_write( + "account_transient_storage_write", + Target::TransientStorage, + RwValues::new( + tx_id, + account_address.compress(), + 0.expr(), + key, + value, + value_prev, + WordLoHi::zero(), + ), + reversion_info, + ); + } + // Call context pub(crate) fn call_context( &mut self, diff --git a/zkevm-circuits/src/witness/rw.rs b/zkevm-circuits/src/witness/rw.rs index a87f819d9a..6530a8a583 100644 --- a/zkevm-circuits/src/witness/rw.rs +++ b/zkevm-circuits/src/witness/rw.rs @@ -276,6 +276,16 @@ pub enum Rw { tx_id: usize, committed_value: Word, }, + /// AccountTransientStorage + AccountTransientStorage { + rw_counter: usize, + is_write: bool, + account_address: Address, + storage_key: Word, + value: Word, + value_prev: Word, + tx_id: usize, + }, /// CallContext CallContext { rw_counter: usize, @@ -609,6 +619,12 @@ impl Rw { committed_value, .. } => (*value, *value_prev, *tx_id, *committed_value), + Self::AccountTransientStorage { + value, + value_prev, + tx_id, + .. + } => (*value, *value_prev, *tx_id, Word::zero()), _ => unreachable!(), } } @@ -665,6 +681,7 @@ impl Rw { | Self::Memory { rw_counter, .. } | Self::Stack { rw_counter, .. } | Self::AccountStorage { rw_counter, .. } + | Self::AccountTransientStorage { rw_counter, .. } | Self::TxAccessListAccount { rw_counter, .. } | Self::TxAccessListAccountStorage { rw_counter, .. } | Self::TxRefund { rw_counter, .. } @@ -682,6 +699,7 @@ impl Rw { Self::Memory { is_write, .. } | Self::Stack { is_write, .. } | Self::AccountStorage { is_write, .. } + | Self::AccountTransientStorage { is_write, .. } | Self::TxAccessListAccount { is_write, .. } | Self::TxAccessListAccountStorage { is_write, .. } | Self::TxRefund { is_write, .. } @@ -700,6 +718,7 @@ impl Rw { Self::Memory { .. } => Target::Memory, Self::Stack { .. } => Target::Stack, Self::AccountStorage { .. } => Target::Storage, + Self::AccountTransientStorage { .. } => Target::TransientStorage, Self::TxAccessListAccount { .. } => Target::TxAccessListAccount, Self::TxAccessListAccountStorage { .. } => Target::TxAccessListAccountStorage, Self::TxRefund { .. } => Target::TxRefund, @@ -714,6 +733,7 @@ impl Rw { pub(crate) fn id(&self) -> Option { match self { Self::AccountStorage { tx_id, .. } + | Self::AccountTransientStorage { tx_id, .. } | Self::TxAccessListAccount { tx_id, .. } | Self::TxAccessListAccountStorage { tx_id, .. } | Self::TxRefund { tx_id, .. } @@ -742,6 +762,9 @@ impl Rw { } | Self::AccountStorage { account_address, .. + } + | Self::AccountTransientStorage { + account_address, .. } => Some(*account_address), Self::Memory { memory_address, .. } => Some(U256::from(*memory_address).to_address()), Self::Stack { stack_pointer, .. } => { @@ -776,6 +799,7 @@ impl Rw { | Self::Memory { .. } | Self::Stack { .. } | Self::AccountStorage { .. } + | Self::AccountTransientStorage { .. } | Self::TxAccessListAccount { .. } | Self::TxAccessListAccountStorage { .. } | Self::TxRefund { .. } @@ -786,6 +810,7 @@ impl Rw { pub(crate) fn storage_key(&self) -> Option { match self { Self::AccountStorage { storage_key, .. } + | Self::AccountTransientStorage { storage_key, .. } | Self::TxAccessListAccountStorage { storage_key, .. } => Some(*storage_key), Self::Padding { .. } | Self::Start { .. } @@ -808,6 +833,7 @@ impl Rw { | Self::StepState { value, .. } | Self::Account { value, .. } | Self::AccountStorage { value, .. } + | Self::AccountTransientStorage { value, .. } | Self::Stack { value, .. } | Self::TxLog { value, .. } => *value, Self::TxAccessListAccount { is_warm, .. } @@ -819,9 +845,9 @@ impl Rw { pub(crate) fn value_prev_assignment(&self) -> Option { match self { - Self::Account { value_prev, .. } | Self::AccountStorage { value_prev, .. } => { - Some(*value_prev) - } + Self::Account { value_prev, .. } + | Self::AccountStorage { value_prev, .. } + | Self::AccountTransientStorage { value_prev, .. } => Some(*value_prev), Self::TxAccessListAccount { is_warm_prev, .. } | Self::TxAccessListAccountStorage { is_warm_prev, .. } => { Some(U256::from(*is_warm_prev as u64)) @@ -867,6 +893,13 @@ impl From> for RwMap { rw_map.insert(Target::Storage, vec![rw]); } } + Rw::AccountTransientStorage { .. } => { + if let Some(vrw) = rw_map.get_mut(&Target::TransientStorage) { + vrw.push(rw) + } else { + rw_map.insert(Target::TransientStorage, vec![rw]); + } + } Rw::TxAccessListAccount { .. } => { if let Some(vrw) = rw_map.get_mut(&Target::TxAccessListAccount) { vrw.push(rw) @@ -1056,6 +1089,22 @@ impl From<&operation::OperationContainer> for RwMap { }) .collect(), ); + rws.insert( + Target::TransientStorage, + container + .transient_storage + .iter() + .map(|op| Rw::AccountTransientStorage { + rw_counter: op.rwc().into(), + is_write: op.rw().is_write(), + account_address: op.op().address, + storage_key: op.op().key, + value: op.op().value, + value_prev: op.op().value_prev, + tx_id: op.op().tx_id, + }) + .collect(), + ); rws.insert( Target::CallContext, container