From f8488f28cb93695fdd163cc22e69e4abd44ad16a Mon Sep 17 00:00:00 2001 From: aofengli <996177263@qq.com> Date: Mon, 13 Mar 2023 14:41:48 +0800 Subject: [PATCH 01/17] add evm --- bank/bank.pb.go | 2 +- bank/query.pb.go | 4 +- bank/tx.pb.go | 2 +- client/base_client.go | 8 +- common/crypto/keys/ed25519/keys.pb.go | 2 +- common/crypto/keys/multisig/keys.pb.go | 2 +- common/crypto/keys/secp256k1/keys.pb.go | 2 +- common/crypto/types/multisig.pb.go | 2 +- ethermint/client.go | 51 + ethermint/clinet_test.go | 52 + ethermint/export.go | 5 + ethermint/types/validation.go | 39 + ethermint/x/evm/types/access_list.go | 55 + ethermint/x/evm/types/access_list_tx.go | 241 + ethermint/x/evm/types/codec.go | 76 + ethermint/x/evm/types/dynamic_fee_tx.go | 281 ++ ethermint/x/evm/types/errors.go | 130 + ethermint/x/evm/types/evm.pb.go | 3781 ++++++++++++++++ ethermint/x/evm/types/key.go | 60 + ethermint/x/evm/types/legacy_tx.go | 212 + ethermint/x/evm/types/msg.go | 315 ++ ethermint/x/evm/types/query.pb.go | 5337 +++++++++++++++++++++++ ethermint/x/evm/types/tx.pb.go | 2910 ++++++++++++ ethermint/x/evm/types/tx_data.go | 120 + ethermint/x/evm/types/utils.go | 109 + feegrant/feegrant.pb.go | 22 +- feegrant/query.pb.go | 4 +- feegrant/tx.pb.go | 4 +- go.mod | 14 +- go.sum | 622 ++- gov/gov.pb.go | 40 +- gov/query.pb.go | 4 +- gov/tx.pb.go | 4 +- ibc/transfer/query.pb.go | 4 +- ibc/transfer/tx.pb.go | 4 +- proto/ethermint/evm/v1/evm.proto | 232 + proto/ethermint/evm/v1/query.proto | 272 ++ proto/ethermint/evm/v1/tx.proto | 175 + staking/query.pb.go | 4 +- staking/staking.pb.go | 1237 +++--- staking/tx.pb.go | 18 +- store/commit_info.pb.go | 44 +- store/listening.pb.go | 15 +- store/snapshot.pb.go | 46 +- store/types/snapshots/snapshot.pb.go | 42 +- types/abci.pb.go | 2 +- types/auth/auth.pb.go | 2 +- types/auth/query.pb.go | 4 +- types/client.go | 3 +- types/coin.pb.go | 2 +- types/kv/kv.pb.go | 2 +- types/query/pagination.pb.go | 18 +- types/tx/builder.go | 1 + types/tx/signing/signing.pb.go | 3 +- types/tx/tx.pb.go | 3 +- 55 files changed, 15841 insertions(+), 804 deletions(-) create mode 100644 ethermint/client.go create mode 100644 ethermint/clinet_test.go create mode 100644 ethermint/export.go create mode 100644 ethermint/types/validation.go create mode 100644 ethermint/x/evm/types/access_list.go create mode 100644 ethermint/x/evm/types/access_list_tx.go create mode 100644 ethermint/x/evm/types/codec.go create mode 100644 ethermint/x/evm/types/dynamic_fee_tx.go create mode 100644 ethermint/x/evm/types/errors.go create mode 100644 ethermint/x/evm/types/evm.pb.go create mode 100644 ethermint/x/evm/types/key.go create mode 100644 ethermint/x/evm/types/legacy_tx.go create mode 100644 ethermint/x/evm/types/msg.go create mode 100644 ethermint/x/evm/types/query.pb.go create mode 100644 ethermint/x/evm/types/tx.pb.go create mode 100644 ethermint/x/evm/types/tx_data.go create mode 100644 ethermint/x/evm/types/utils.go create mode 100644 proto/ethermint/evm/v1/evm.proto create mode 100644 proto/ethermint/evm/v1/query.proto create mode 100644 proto/ethermint/evm/v1/tx.proto diff --git a/bank/bank.pb.go b/bank/bank.pb.go index f2daa8e..1936ca6 100644 --- a/bank/bank.pb.go +++ b/bank/bank.pb.go @@ -5,8 +5,8 @@ package bank import ( fmt "fmt" + proto "github.com/cosmos/gogoproto/proto" _ "github.com/gogo/protobuf/gogoproto" - proto "github.com/gogo/protobuf/proto" github_com_irisnet_core_sdk_go_types "github.com/irisnet/core-sdk-go/types" types "github.com/irisnet/core-sdk-go/types" _ "github.com/regen-network/cosmos-proto" diff --git a/bank/query.pb.go b/bank/query.pb.go index 76f9d67..fc7d02a 100644 --- a/bank/query.pb.go +++ b/bank/query.pb.go @@ -6,9 +6,9 @@ package bank import ( context "context" fmt "fmt" + grpc1 "github.com/cosmos/gogoproto/grpc" + proto "github.com/cosmos/gogoproto/proto" _ "github.com/gogo/protobuf/gogoproto" - grpc1 "github.com/gogo/protobuf/grpc" - proto "github.com/gogo/protobuf/proto" github_com_irisnet_core_sdk_go_types "github.com/irisnet/core-sdk-go/types" types "github.com/irisnet/core-sdk-go/types" query "github.com/irisnet/core-sdk-go/types/query" diff --git a/bank/tx.pb.go b/bank/tx.pb.go index a911d3b..c5d98b8 100644 --- a/bank/tx.pb.go +++ b/bank/tx.pb.go @@ -5,8 +5,8 @@ package bank import ( fmt "fmt" + proto "github.com/cosmos/gogoproto/proto" _ "github.com/gogo/protobuf/gogoproto" - proto "github.com/gogo/protobuf/proto" github_com_irisnet_core_sdk_go_types "github.com/irisnet/core-sdk-go/types" types "github.com/irisnet/core-sdk-go/types" io "io" diff --git a/client/base_client.go b/client/base_client.go index 46792bc..b21171a 100644 --- a/client/base_client.go +++ b/client/base_client.go @@ -1,5 +1,4 @@ // Package modules is to warpped the API provided by each module of IRITA -// package client import ( @@ -22,6 +21,7 @@ import ( commoncache "github.com/irisnet/core-sdk-go/common/cache" commoncodec "github.com/irisnet/core-sdk-go/common/codec" sdklog "github.com/irisnet/core-sdk-go/common/log" + sdk "github.com/irisnet/core-sdk-go/types" sdktypes "github.com/irisnet/core-sdk-go/types" "github.com/irisnet/core-sdk-go/types/tx" ) @@ -134,6 +134,10 @@ func (base *baseClient) BuildAndSignWithAccount(addr string, accountNumber, sequ return txByte, nil } +func (base *baseClient) BroadcastTx(txBytes []byte, mode sdk.BroadcastMode) (res sdk.ResultTx, err sdk.Error) { + return base.broadcastTx(txBytes, mode) +} + func (base *baseClient) BuildAndSendWithAccount(addr string, accountNumber, sequence uint64, msg []sdktypes.Msg, baseTx sdktypes.BaseTx) (sdktypes.ResultTx, sdktypes.Error) { txByte, ctx, err := base.buildTxWithAccount(addr, accountNumber, sequence, msg, baseTx) if err != nil { @@ -480,7 +484,7 @@ type locker struct { logger log.Logger } -//NewLocker implement the function of lock, can lock resources according to conditions +// NewLocker implement the function of lock, can lock resources according to conditions func NewLocker(size int) *locker { shards := make([]chan int, size) for i := 0; i < size; i++ { diff --git a/common/crypto/keys/ed25519/keys.pb.go b/common/crypto/keys/ed25519/keys.pb.go index 8a263ce..9c5511f 100644 --- a/common/crypto/keys/ed25519/keys.pb.go +++ b/common/crypto/keys/ed25519/keys.pb.go @@ -5,8 +5,8 @@ package ed25519 import ( fmt "fmt" + proto "github.com/cosmos/gogoproto/proto" _ "github.com/gogo/protobuf/gogoproto" - proto "github.com/gogo/protobuf/proto" io "io" math "math" math_bits "math/bits" diff --git a/common/crypto/keys/multisig/keys.pb.go b/common/crypto/keys/multisig/keys.pb.go index cc3021e..7cae8a7 100644 --- a/common/crypto/keys/multisig/keys.pb.go +++ b/common/crypto/keys/multisig/keys.pb.go @@ -5,8 +5,8 @@ package multisig import ( fmt "fmt" + proto "github.com/cosmos/gogoproto/proto" _ "github.com/gogo/protobuf/gogoproto" - proto "github.com/gogo/protobuf/proto" types "github.com/irisnet/core-sdk-go/common/codec/types" io "io" math "math" diff --git a/common/crypto/keys/secp256k1/keys.pb.go b/common/crypto/keys/secp256k1/keys.pb.go index 72727e0..cc7167a 100644 --- a/common/crypto/keys/secp256k1/keys.pb.go +++ b/common/crypto/keys/secp256k1/keys.pb.go @@ -5,8 +5,8 @@ package secp256k1 import ( fmt "fmt" + proto "github.com/cosmos/gogoproto/proto" _ "github.com/gogo/protobuf/gogoproto" - proto "github.com/gogo/protobuf/proto" io "io" math "math" math_bits "math/bits" diff --git a/common/crypto/types/multisig.pb.go b/common/crypto/types/multisig.pb.go index 6e506bb..e5c011f 100644 --- a/common/crypto/types/multisig.pb.go +++ b/common/crypto/types/multisig.pb.go @@ -5,8 +5,8 @@ package types import ( fmt "fmt" + proto "github.com/cosmos/gogoproto/proto" _ "github.com/gogo/protobuf/gogoproto" - proto "github.com/gogo/protobuf/proto" io "io" math "math" math_bits "math/bits" diff --git a/ethermint/client.go b/ethermint/client.go new file mode 100644 index 0000000..fc653cc --- /dev/null +++ b/ethermint/client.go @@ -0,0 +1,51 @@ +package ethermint + +import ( + "github.com/ethereum/go-ethereum/common/hexutil" + codectypes "github.com/irisnet/core-sdk-go/common/codec/types" + evmtypes "github.com/irisnet/core-sdk-go/ethermint/x/evm/types" + sdktypes "github.com/irisnet/core-sdk-go/types" + "github.com/pkg/errors" +) + +type Client struct { + sdktypes.BaseClient + txConfig sdktypes.TxConfig +} + +// NewClient grant NewClient +func NewClient(bc sdktypes.BaseClient, txConfig sdktypes.TxConfig) Client { + return Client{ + BaseClient: bc, + txConfig: txConfig, + } +} + +func (cli *Client) RegisterInterfaceTypes(registry codectypes.InterfaceRegistry) { + evmtypes.RegisterInterfaces(registry) +} + +func (cli *Client) BuildEvmTx(hexData string, feePayerAddr string, evmDemon string) ([]byte, error) { + data, err := hexutil.Decode(hexData) + if err != nil { + return nil, errors.Wrap(err, "failed to decode ethereum tx hex bytes") + } + msg := &evmtypes.MsgEthereumTx{} + if err := msg.UnmarshalBinary(data); err != nil { + return nil, err + } + if err := msg.ValidateBasic(); err != nil { + return nil, err + } + if len(feePayerAddr) > 0 { + msg.SetFeePayer(feePayerAddr) + } + + builder := cli.txConfig.NewTxBuilder() + tx, err := msg.BuildTx(builder, evmDemon) + if err != nil { + return nil, err + } + + return cli.txConfig.TxEncoder()(tx) +} diff --git a/ethermint/clinet_test.go b/ethermint/clinet_test.go new file mode 100644 index 0000000..7013d57 --- /dev/null +++ b/ethermint/clinet_test.go @@ -0,0 +1,52 @@ +package ethermint + +import ( + "fmt" + "testing" + + sdk "github.com/irisnet/core-sdk-go" + "github.com/irisnet/core-sdk-go/common/crypto" + "github.com/irisnet/core-sdk-go/types" + sdktypes "github.com/irisnet/core-sdk-go/types" + "github.com/irisnet/core-sdk-go/types/store" +) + +func TestClient(t *testing.T) { + + nodeURI := "tcp://localhost:26657" + grpcAddr := "localhost:9090" + chainID := "wenchangchain" + + bech32AddressPrefix := sdktypes.AddrPrefixCfg{ + AccountAddr: "iaa", + ValidatorAddr: "iva", + ConsensusAddr: "ica", + AccountPub: "iap", + ValidatorPub: "ivp", + ConsensusPub: "icp", + } + options := []sdktypes.Option{ + sdktypes.KeyDAOOption(store.NewMemory(nil)), + sdktypes.TimeoutOption(10), + sdktypes.KeyManagerOption(crypto.NewKeyManager()), + sdktypes.Bech32AddressPrefixOption(&bech32AddressPrefix), + sdktypes.BIP44PathOption(""), + } + cfg, err := types.NewClientConfig(nodeURI, grpcAddr, chainID, options...) + if err != nil { + panic(err) + } + + sdkClient := sdk.NewClient(cfg) + fmt.Println(sdkClient.EncodingConfig().TxConfig) + + //cli := NewClient(nil, txCfg) + //txData := "0xf901470701831e8480941a6640c32b7e6413e839e9dfdb53970ee809b7fb80b8e4990711900000000000000000000000005892e7eeaea5ba624f5ba2900dbab8d2ea36d62b000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000a0000000000000000000000000000000000000000000000000000000000000001a687474703a2f2f6578616d706c652e636f6d2f746f6b656e2f33000000000000000000000000000000000000000000000000000000000000000000000000000974657374686173683200000000000000000000000000000000000000000000008209b2a05dc08aff9f0dac1ed240435510bdd53d8f8eb3f95c44a44f874e9e33ffd2407aa06090bf14d011822f2ff252081684c8e31a5e87d8735ee2f21acc32e87d28304f" + //feePayer := "0x4579DB44FD3A6F645194058914E0A8D5E8F20DB8" + //evmDenom := "ugas" + //rawTx, err := cli.BuildEvmTx(txData, feePayer, evmDenom) + //if err != nil { + // return + //} + //t.Log(rawTx) +} diff --git a/ethermint/export.go b/ethermint/export.go new file mode 100644 index 0000000..8833e04 --- /dev/null +++ b/ethermint/export.go @@ -0,0 +1,5 @@ +package ethermint + +type IClient interface { + BuildEvmTx(hexData string, feePayerAddr string, evmDemon string) error +} diff --git a/ethermint/types/validation.go b/ethermint/types/validation.go new file mode 100644 index 0000000..15e27ee --- /dev/null +++ b/ethermint/types/validation.go @@ -0,0 +1,39 @@ +package types + +import ( + "bytes" + "math" + + sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" + "github.com/ethereum/go-ethereum/common" +) + +// IsEmptyHash returns true if the hash corresponds to an empty ethereum hex hash. +func IsEmptyHash(hash string) bool { + return bytes.Equal(common.HexToHash(hash).Bytes(), common.Hash{}.Bytes()) +} + +// IsZeroAddress returns true if the address corresponds to an empty ethereum hex address. +func IsZeroAddress(address string) bool { + return bytes.Equal(common.HexToAddress(address).Bytes(), common.Address{}.Bytes()) +} + +// ValidateAddress returns an error if the provided string is either not a hex formatted string address +func ValidateAddress(address string) error { + if !common.IsHexAddress(address) { + return sdkerrors.Wrapf( + sdkerrors.ErrInvalidAddress, "address '%s' is not a valid ethereum hex address", + address, + ) + } + return nil +} + +// SafeInt64 checks for overflows while casting a uint64 to int64 value. +func SafeInt64(value uint64) (int64, error) { + if value > uint64(math.MaxInt64) { + return 0, sdkerrors.Wrapf(sdkerrors.ErrInvalidHeight, "uint64 value %v cannot exceed %v", value, int64(math.MaxInt64)) + } + + return int64(value), nil +} diff --git a/ethermint/x/evm/types/access_list.go b/ethermint/x/evm/types/access_list.go new file mode 100644 index 0000000..7ebc63f --- /dev/null +++ b/ethermint/x/evm/types/access_list.go @@ -0,0 +1,55 @@ +package types + +import ( + "github.com/ethereum/go-ethereum/common" + ethtypes "github.com/ethereum/go-ethereum/core/types" +) + +// AccessList is an EIP-2930 access list that represents the slice of +// the protobuf AccessTuples. +type AccessList []AccessTuple + +// NewAccessList creates a new protobuf-compatible AccessList from an ethereum +// core AccessList type +func NewAccessList(ethAccessList *ethtypes.AccessList) AccessList { + if ethAccessList == nil { + return nil + } + + al := AccessList{} + for _, tuple := range *ethAccessList { + storageKeys := make([]string, len(tuple.StorageKeys)) + + for i := range tuple.StorageKeys { + storageKeys[i] = tuple.StorageKeys[i].String() + } + + al = append(al, AccessTuple{ + Address: tuple.Address.String(), + StorageKeys: storageKeys, + }) + } + + return al +} + +// ToEthAccessList is an utility function to convert the protobuf compatible +// AccessList to eth core AccessList from go-ethereum +func (al AccessList) ToEthAccessList() *ethtypes.AccessList { + var ethAccessList ethtypes.AccessList + + for _, tuple := range al { + storageKeys := make([]common.Hash, len(tuple.StorageKeys)) + + for i := range tuple.StorageKeys { + storageKeys[i] = common.HexToHash(tuple.StorageKeys[i]) + } + + ethAccessList = append(ethAccessList, ethtypes.AccessTuple{ + Address: common.HexToAddress(tuple.Address), + StorageKeys: storageKeys, + }) + } + + return ðAccessList +} diff --git a/ethermint/x/evm/types/access_list_tx.go b/ethermint/x/evm/types/access_list_tx.go new file mode 100644 index 0000000..436103d --- /dev/null +++ b/ethermint/x/evm/types/access_list_tx.go @@ -0,0 +1,241 @@ +package types + +import ( + "math/big" + + sdk "github.com/cosmos/cosmos-sdk/types" + sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" + "github.com/ethereum/go-ethereum/common" + ethtypes "github.com/ethereum/go-ethereum/core/types" + "github.com/irisnet/core-sdk-go/ethermint/types" +) + +func newAccessListTx(tx *ethtypes.Transaction) (*AccessListTx, error) { + txData := &AccessListTx{ + Nonce: tx.Nonce(), + Data: tx.Data(), + GasLimit: tx.Gas(), + } + + v, r, s := tx.RawSignatureValues() + if to := tx.To(); to != nil { + txData.To = to.Hex() + } + + if tx.Value() != nil { + amountInt, err := SafeNewIntFromBigInt(tx.Value()) + if err != nil { + return nil, err + } + txData.Amount = &amountInt + } + + if tx.GasPrice() != nil { + gasPriceInt, err := SafeNewIntFromBigInt(tx.GasPrice()) + if err != nil { + return nil, err + } + txData.GasPrice = &gasPriceInt + } + + if tx.AccessList() != nil { + al := tx.AccessList() + txData.Accesses = NewAccessList(&al) + } + + txData.SetSignatureValues(tx.ChainId(), v, r, s) + return txData, nil +} + +// TxType returns the tx type +func (tx *AccessListTx) TxType() uint8 { + return ethtypes.AccessListTxType +} + +// Copy returns an instance with the same field values +func (tx *AccessListTx) Copy() TxData { + return &AccessListTx{ + ChainID: tx.ChainID, + Nonce: tx.Nonce, + GasPrice: tx.GasPrice, + GasLimit: tx.GasLimit, + To: tx.To, + Amount: tx.Amount, + Data: common.CopyBytes(tx.Data), + Accesses: tx.Accesses, + V: common.CopyBytes(tx.V), + R: common.CopyBytes(tx.R), + S: common.CopyBytes(tx.S), + } +} + +// GetChainID returns the chain id field from the AccessListTx +func (tx *AccessListTx) GetChainID() *big.Int { + if tx.ChainID == nil { + return nil + } + + return tx.ChainID.BigInt() +} + +// GetAccessList returns the AccessList field. +func (tx *AccessListTx) GetAccessList() ethtypes.AccessList { + if tx.Accesses == nil { + return nil + } + return *tx.Accesses.ToEthAccessList() +} + +// GetData returns the a copy of the input data bytes. +func (tx *AccessListTx) GetData() []byte { + return common.CopyBytes(tx.Data) +} + +// GetGas returns the gas limit. +func (tx *AccessListTx) GetGas() uint64 { + return tx.GasLimit +} + +// GetGasPrice returns the gas price field. +func (tx *AccessListTx) GetGasPrice() *big.Int { + if tx.GasPrice == nil { + return nil + } + return tx.GasPrice.BigInt() +} + +// GetGasTipCap returns the gas price field. +func (tx *AccessListTx) GetGasTipCap() *big.Int { + return tx.GetGasPrice() +} + +// GetGasFeeCap returns the gas price field. +func (tx *AccessListTx) GetGasFeeCap() *big.Int { + return tx.GetGasPrice() +} + +// GetValue returns the tx amount. +func (tx *AccessListTx) GetValue() *big.Int { + if tx.Amount == nil { + return nil + } + + return tx.Amount.BigInt() +} + +// GetNonce returns the account sequence for the transaction. +func (tx *AccessListTx) GetNonce() uint64 { return tx.Nonce } + +// GetTo returns the pointer to the recipient address. +func (tx *AccessListTx) GetTo() *common.Address { + if tx.To == "" { + return nil + } + to := common.HexToAddress(tx.To) + return &to +} + +// AsEthereumData returns an AccessListTx transaction tx from the proto-formatted +// TxData defined on the Cosmos EVM. +func (tx *AccessListTx) AsEthereumData() ethtypes.TxData { + v, r, s := tx.GetRawSignatureValues() + return ðtypes.AccessListTx{ + ChainID: tx.GetChainID(), + Nonce: tx.GetNonce(), + GasPrice: tx.GetGasPrice(), + Gas: tx.GetGas(), + To: tx.GetTo(), + Value: tx.GetValue(), + Data: tx.GetData(), + AccessList: tx.GetAccessList(), + V: v, + R: r, + S: s, + } +} + +// GetRawSignatureValues returns the V, R, S signature values of the transaction. +// The return values should not be modified by the caller. +func (tx *AccessListTx) GetRawSignatureValues() (v, r, s *big.Int) { + return rawSignatureValues(tx.V, tx.R, tx.S) +} + +// SetSignatureValues sets the signature values to the transaction. +func (tx *AccessListTx) SetSignatureValues(chainID, v, r, s *big.Int) { + if v != nil { + tx.V = v.Bytes() + } + if r != nil { + tx.R = r.Bytes() + } + if s != nil { + tx.S = s.Bytes() + } + if chainID != nil { + chainIDInt := sdk.NewIntFromBigInt(chainID) + tx.ChainID = &chainIDInt + } +} + +// Validate performs a stateless validation of the tx fields. +func (tx AccessListTx) Validate() error { + gasPrice := tx.GetGasPrice() + if gasPrice == nil { + return sdkerrors.Wrap(ErrInvalidGasPrice, "cannot be nil") + } + if !IsValidInt256(gasPrice) { + return sdkerrors.Wrap(ErrInvalidGasPrice, "out of bound") + } + + if gasPrice.Sign() == -1 { + return sdkerrors.Wrapf(ErrInvalidGasPrice, "gas price cannot be negative %s", gasPrice) + } + + amount := tx.GetValue() + // Amount can be 0 + if amount != nil && amount.Sign() == -1 { + return sdkerrors.Wrapf(ErrInvalidAmount, "amount cannot be negative %s", amount) + } + if !IsValidInt256(amount) { + return sdkerrors.Wrap(ErrInvalidAmount, "out of bound") + } + + if !IsValidInt256(tx.Fee()) { + return sdkerrors.Wrap(ErrInvalidGasFee, "out of bound") + } + + if tx.To != "" { + if err := types.ValidateAddress(tx.To); err != nil { + return sdkerrors.Wrap(err, "invalid to address") + } + } + + if tx.GetChainID() == nil { + return sdkerrors.Wrap( + sdkerrors.ErrInvalidChainID, + "chain ID must be present on AccessList txs", + ) + } + + return nil +} + +// Fee returns gasprice * gaslimit. +func (tx AccessListTx) Fee() *big.Int { + return fee(tx.GetGasPrice(), tx.GetGas()) +} + +// Cost returns amount + gasprice * gaslimit. +func (tx AccessListTx) Cost() *big.Int { + return cost(tx.Fee(), tx.GetValue()) +} + +// EffectiveFee is the same as Fee for AccessListTx +func (tx AccessListTx) EffectiveFee(baseFee *big.Int) *big.Int { + return tx.Fee() +} + +// EffectiveCost is the same as Cost for AccessListTx +func (tx AccessListTx) EffectiveCost(baseFee *big.Int) *big.Int { + return tx.Cost() +} diff --git a/ethermint/x/evm/types/codec.go b/ethermint/x/evm/types/codec.go new file mode 100644 index 0000000..2dd0a3e --- /dev/null +++ b/ethermint/x/evm/types/codec.go @@ -0,0 +1,76 @@ +package types + +import ( + sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" + proto "github.com/gogo/protobuf/proto" + "github.com/irisnet/core-sdk-go/common/codec" + codectypes "github.com/irisnet/core-sdk-go/common/codec/types" + cryptocodec "github.com/irisnet/core-sdk-go/common/crypto/codec" + sdktypes "github.com/irisnet/core-sdk-go/types" +) + +var ( + amino = codec.NewLegacyAmino() + ModuleCdc = codec.NewAminoCodec(amino) +) + +func init() { + cryptocodec.RegisterCrypto(amino) +} + +type ( + ExtensionOptionsEthereumTxI interface{} +) + +// RegisterInterfaces registers the client interfaces to protobuf Any. +func RegisterInterfaces(registry codectypes.InterfaceRegistry) { + registry.RegisterImplementations( + (*sdktypes.Msg)(nil), + &MsgEthereumTx{}, + ) + registry.RegisterInterface( + "ethermint.evm.v1.ExtensionOptionsEthereumTx", + (*ExtensionOptionsEthereumTxI)(nil), + &ExtensionOptionsEthereumTx{}, + ) + registry.RegisterInterface( + "ethermint.evm.v1.TxData", + (*TxData)(nil), + &DynamicFeeTx{}, + &AccessListTx{}, + &LegacyTx{}, + ) + +} + +// PackClientState constructs a new Any packed with the given tx data value. It returns +// an error if the client state can't be casted to a protobuf message or if the concrete +// implemention is not registered to the protobuf codec. +func PackTxData(txData TxData) (*codectypes.Any, error) { + msg, ok := txData.(proto.Message) + if !ok { + return nil, sdkerrors.Wrapf(sdkerrors.ErrPackAny, "cannot proto marshal %T", txData) + } + + anyTxData, err := codectypes.NewAnyWithValue(msg) + if err != nil { + return nil, sdkerrors.Wrap(sdkerrors.ErrPackAny, err.Error()) + } + + return anyTxData, nil +} + +// UnpackTxData unpacks an Any into a TxData. It returns an error if the +// client state can't be unpacked into a TxData. +func UnpackTxData(any *codectypes.Any) (TxData, error) { + if any == nil { + return nil, sdkerrors.Wrap(sdkerrors.ErrUnpackAny, "protobuf Any message cannot be nil") + } + + txData, ok := any.GetCachedValue().(TxData) + if !ok { + return nil, sdkerrors.Wrapf(sdkerrors.ErrUnpackAny, "cannot unpack Any into TxData %T", any) + } + + return txData, nil +} diff --git a/ethermint/x/evm/types/dynamic_fee_tx.go b/ethermint/x/evm/types/dynamic_fee_tx.go new file mode 100644 index 0000000..d17fa18 --- /dev/null +++ b/ethermint/x/evm/types/dynamic_fee_tx.go @@ -0,0 +1,281 @@ +package types + +import ( + "math/big" + + sdk "github.com/cosmos/cosmos-sdk/types" + sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" + + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/common/math" + ethtypes "github.com/ethereum/go-ethereum/core/types" + + "github.com/irisnet/core-sdk-go/ethermint/types" +) + +func newDynamicFeeTx(tx *ethtypes.Transaction) (*DynamicFeeTx, error) { + txData := &DynamicFeeTx{ + Nonce: tx.Nonce(), + Data: tx.Data(), + GasLimit: tx.Gas(), + } + + v, r, s := tx.RawSignatureValues() + if to := tx.To(); to != nil { + txData.To = to.Hex() + } + + if tx.Value() != nil { + amountInt, err := SafeNewIntFromBigInt(tx.Value()) + if err != nil { + return nil, err + } + txData.Amount = &amountInt + } + + if tx.GasFeeCap() != nil { + gasFeeCapInt, err := SafeNewIntFromBigInt(tx.GasFeeCap()) + if err != nil { + return nil, err + } + txData.GasFeeCap = &gasFeeCapInt + } + + if tx.GasTipCap() != nil { + gasTipCapInt, err := SafeNewIntFromBigInt(tx.GasTipCap()) + if err != nil { + return nil, err + } + txData.GasTipCap = &gasTipCapInt + } + + if tx.AccessList() != nil { + al := tx.AccessList() + txData.Accesses = NewAccessList(&al) + } + + txData.SetSignatureValues(tx.ChainId(), v, r, s) + return txData, nil +} + +// TxType returns the tx type +func (tx *DynamicFeeTx) TxType() uint8 { + return ethtypes.DynamicFeeTxType +} + +// Copy returns an instance with the same field values +func (tx *DynamicFeeTx) Copy() TxData { + return &DynamicFeeTx{ + ChainID: tx.ChainID, + Nonce: tx.Nonce, + GasTipCap: tx.GasTipCap, + GasFeeCap: tx.GasFeeCap, + GasLimit: tx.GasLimit, + To: tx.To, + Amount: tx.Amount, + Data: common.CopyBytes(tx.Data), + Accesses: tx.Accesses, + V: common.CopyBytes(tx.V), + R: common.CopyBytes(tx.R), + S: common.CopyBytes(tx.S), + } +} + +// GetChainID returns the chain id field from the DynamicFeeTx +func (tx *DynamicFeeTx) GetChainID() *big.Int { + if tx.ChainID == nil { + return nil + } + + return tx.ChainID.BigInt() +} + +// GetAccessList returns the AccessList field. +func (tx *DynamicFeeTx) GetAccessList() ethtypes.AccessList { + if tx.Accesses == nil { + return nil + } + return *tx.Accesses.ToEthAccessList() +} + +// GetData returns the a copy of the input data bytes. +func (tx *DynamicFeeTx) GetData() []byte { + return common.CopyBytes(tx.Data) +} + +// GetGas returns the gas limit. +func (tx *DynamicFeeTx) GetGas() uint64 { + return tx.GasLimit +} + +// GetGasPrice returns the gas fee cap field. +func (tx *DynamicFeeTx) GetGasPrice() *big.Int { + return tx.GetGasFeeCap() +} + +// GetGasTipCap returns the gas tip cap field. +func (tx *DynamicFeeTx) GetGasTipCap() *big.Int { + if tx.GasTipCap == nil { + return nil + } + return tx.GasTipCap.BigInt() +} + +// GetGasFeeCap returns the gas fee cap field. +func (tx *DynamicFeeTx) GetGasFeeCap() *big.Int { + if tx.GasFeeCap == nil { + return nil + } + return tx.GasFeeCap.BigInt() +} + +// GetValue returns the tx amount. +func (tx *DynamicFeeTx) GetValue() *big.Int { + if tx.Amount == nil { + return nil + } + + return tx.Amount.BigInt() +} + +// GetNonce returns the account sequence for the transaction. +func (tx *DynamicFeeTx) GetNonce() uint64 { return tx.Nonce } + +// GetTo returns the pointer to the recipient address. +func (tx *DynamicFeeTx) GetTo() *common.Address { + if tx.To == "" { + return nil + } + to := common.HexToAddress(tx.To) + return &to +} + +// AsEthereumData returns an DynamicFeeTx transaction tx from the proto-formatted +// TxData defined on the Cosmos EVM. +func (tx *DynamicFeeTx) AsEthereumData() ethtypes.TxData { + v, r, s := tx.GetRawSignatureValues() + return ðtypes.DynamicFeeTx{ + ChainID: tx.GetChainID(), + Nonce: tx.GetNonce(), + GasTipCap: tx.GetGasTipCap(), + GasFeeCap: tx.GetGasFeeCap(), + Gas: tx.GetGas(), + To: tx.GetTo(), + Value: tx.GetValue(), + Data: tx.GetData(), + AccessList: tx.GetAccessList(), + V: v, + R: r, + S: s, + } +} + +// GetRawSignatureValues returns the V, R, S signature values of the transaction. +// The return values should not be modified by the caller. +func (tx *DynamicFeeTx) GetRawSignatureValues() (v, r, s *big.Int) { + return rawSignatureValues(tx.V, tx.R, tx.S) +} + +// SetSignatureValues sets the signature values to the transaction. +func (tx *DynamicFeeTx) SetSignatureValues(chainID, v, r, s *big.Int) { + if v != nil { + tx.V = v.Bytes() + } + if r != nil { + tx.R = r.Bytes() + } + if s != nil { + tx.S = s.Bytes() + } + if chainID != nil { + chainIDInt := sdk.NewIntFromBigInt(chainID) + tx.ChainID = &chainIDInt + } +} + +// Validate performs a stateless validation of the tx fields. +func (tx DynamicFeeTx) Validate() error { + if tx.GasTipCap == nil { + return sdkerrors.Wrap(ErrInvalidGasCap, "gas tip cap cannot nil") + } + + if tx.GasFeeCap == nil { + return sdkerrors.Wrap(ErrInvalidGasCap, "gas fee cap cannot nil") + } + + if tx.GasTipCap.IsNegative() { + return sdkerrors.Wrapf(ErrInvalidGasCap, "gas tip cap cannot be negative %s", tx.GasTipCap) + } + + if tx.GasFeeCap.IsNegative() { + return sdkerrors.Wrapf(ErrInvalidGasCap, "gas fee cap cannot be negative %s", tx.GasFeeCap) + } + + if !IsValidInt256(tx.GetGasTipCap()) { + return sdkerrors.Wrap(ErrInvalidGasCap, "out of bound") + } + + if !IsValidInt256(tx.GetGasFeeCap()) { + return sdkerrors.Wrap(ErrInvalidGasCap, "out of bound") + } + + if tx.GasFeeCap.LT(*tx.GasTipCap) { + return sdkerrors.Wrapf( + ErrInvalidGasCap, "max priority fee per gas higher than max fee per gas (%s > %s)", + tx.GasTipCap, tx.GasFeeCap, + ) + } + + if !IsValidInt256(tx.Fee()) { + return sdkerrors.Wrap(ErrInvalidGasFee, "out of bound") + } + + amount := tx.GetValue() + // Amount can be 0 + if amount != nil && amount.Sign() == -1 { + return sdkerrors.Wrapf(ErrInvalidAmount, "amount cannot be negative %s", amount) + } + if !IsValidInt256(amount) { + return sdkerrors.Wrap(ErrInvalidAmount, "out of bound") + } + + if tx.To != "" { + if err := types.ValidateAddress(tx.To); err != nil { + return sdkerrors.Wrap(err, "invalid to address") + } + } + + if tx.GetChainID() == nil { + return sdkerrors.Wrap( + sdkerrors.ErrInvalidChainID, + "chain ID must be present on AccessList txs", + ) + } + + return nil +} + +// Fee returns gasprice * gaslimit. +func (tx DynamicFeeTx) Fee() *big.Int { + return fee(tx.GetGasFeeCap(), tx.GasLimit) +} + +// Cost returns amount + gasprice * gaslimit. +func (tx DynamicFeeTx) Cost() *big.Int { + return cost(tx.Fee(), tx.GetValue()) +} + +// GetEffectiveGasPrice returns the effective gas price +func (tx *DynamicFeeTx) GetEffectiveGasPrice(baseFee *big.Int) *big.Int { + return math.BigMin(new(big.Int).Add(tx.GasTipCap.BigInt(), baseFee), tx.GasFeeCap.BigInt()) +} + +// EffectiveFee returns effective_gasprice * gaslimit. +func (tx DynamicFeeTx) EffectiveFee(baseFee *big.Int) *big.Int { + return fee(tx.GetEffectiveGasPrice(baseFee), tx.GasLimit) +} + +// EffectiveCost returns amount + effective_gasprice * gaslimit. +func (tx DynamicFeeTx) EffectiveCost(baseFee *big.Int) *big.Int { + return cost(tx.EffectiveFee(baseFee), tx.GetValue()) +} diff --git a/ethermint/x/evm/types/errors.go b/ethermint/x/evm/types/errors.go new file mode 100644 index 0000000..d7a4dba --- /dev/null +++ b/ethermint/x/evm/types/errors.go @@ -0,0 +1,130 @@ +package types + +import ( + "errors" + "fmt" + + sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/common/hexutil" + "github.com/ethereum/go-ethereum/core/vm" +) + +const ( + codeErrInvalidState = uint32(iota) + 2 // NOTE: code 1 is reserved for internal errors + codeErrExecutionReverted // IMPORTANT: Do not move this error as it complies with the JSON-RPC error standard + codeErrChainConfigNotFound + codeErrInvalidChainConfig + codeErrZeroAddress + codeErrEmptyHash + codeErrBloomNotFound + codeErrTxReceiptNotFound + codeErrCreateDisabled + codeErrCallDisabled + codeErrInvalidAmount + codeErrInvalidGasPrice + codeErrInvalidGasFee + codeErrVMExecution + codeErrInvalidRefund + codeErrInconsistentGas + codeErrInvalidGasCap + codeErrInvalidBaseFee + codeErrGasOverflow + codeErrInvalidAccount +) + +var ( + // ErrInvalidState returns an error resulting from an invalid Storage State. + ErrInvalidState = sdkerrors.Register(ModuleName, codeErrInvalidState, "invalid storage state") + + // ErrExecutionReverted returns an error resulting from an error in EVM execution. + ErrExecutionReverted = sdkerrors.Register(ModuleName, codeErrExecutionReverted, vm.ErrExecutionReverted.Error()) + + // ErrChainConfigNotFound returns an error if the chain config cannot be found on the store. + ErrChainConfigNotFound = sdkerrors.Register(ModuleName, codeErrChainConfigNotFound, "chain configuration not found") + + // ErrInvalidChainConfig returns an error resulting from an invalid ChainConfig. + ErrInvalidChainConfig = sdkerrors.Register(ModuleName, codeErrInvalidChainConfig, "invalid chain configuration") + + // ErrZeroAddress returns an error resulting from an zero (empty) ethereum Address. + ErrZeroAddress = sdkerrors.Register(ModuleName, codeErrZeroAddress, "invalid zero address") + + // ErrEmptyHash returns an error resulting from an empty ethereum Hash. + ErrEmptyHash = sdkerrors.Register(ModuleName, codeErrEmptyHash, "empty hash") + + // ErrBloomNotFound returns an error if the block bloom cannot be found on the store. + ErrBloomNotFound = sdkerrors.Register(ModuleName, codeErrBloomNotFound, "block bloom not found") + + // ErrTxReceiptNotFound returns an error if the transaction receipt could not be found + ErrTxReceiptNotFound = sdkerrors.Register(ModuleName, codeErrTxReceiptNotFound, "transaction receipt not found") + + // ErrCreateDisabled returns an error if the EnableCreate parameter is false. + ErrCreateDisabled = sdkerrors.Register(ModuleName, codeErrCreateDisabled, "EVM Create operation is disabled") + + // ErrCallDisabled returns an error if the EnableCall parameter is false. + ErrCallDisabled = sdkerrors.Register(ModuleName, codeErrCallDisabled, "EVM Call operation is disabled") + + // ErrInvalidAmount returns an error if a tx contains an invalid amount. + ErrInvalidAmount = sdkerrors.Register(ModuleName, codeErrInvalidAmount, "invalid transaction amount") + + // ErrInvalidGasPrice returns an error if an invalid gas price is provided to the tx. + ErrInvalidGasPrice = sdkerrors.Register(ModuleName, codeErrInvalidGasPrice, "invalid gas price") + + // ErrInvalidGasFee returns an error if the tx gas fee is out of bound. + ErrInvalidGasFee = sdkerrors.Register(ModuleName, codeErrInvalidGasFee, "invalid gas fee") + + // ErrVMExecution returns an error resulting from an error in EVM execution. + ErrVMExecution = sdkerrors.Register(ModuleName, codeErrVMExecution, "evm transaction execution failed") + + // ErrInvalidRefund returns an error if a the gas refund value is invalid. + ErrInvalidRefund = sdkerrors.Register(ModuleName, codeErrInvalidRefund, "invalid gas refund amount") + + // ErrInconsistentGas returns an error if a the gas differs from the expected one. + ErrInconsistentGas = sdkerrors.Register(ModuleName, codeErrInconsistentGas, "inconsistent gas") + + // ErrInvalidGasCap returns an error if a the gas cap value is negative or invalid + ErrInvalidGasCap = sdkerrors.Register(ModuleName, codeErrInvalidGasCap, "invalid gas cap") + + // ErrInvalidBaseFee returns an error if a the base fee cap value is invalid + ErrInvalidBaseFee = sdkerrors.Register(ModuleName, codeErrInvalidBaseFee, "invalid base fee") + + // ErrGasOverflow returns an error if gas computation overlow/underflow + ErrGasOverflow = sdkerrors.Register(ModuleName, codeErrGasOverflow, "gas computation overflow/underflow") + + // ErrInvalidAccount returns an error if the account is not an EVM compatible account + ErrInvalidAccount = sdkerrors.Register(ModuleName, codeErrInvalidAccount, "account type is not a valid ethereum account") +) + +// NewExecErrorWithReason unpacks the revert return bytes and returns a wrapped error +// with the return reason. +func NewExecErrorWithReason(revertReason []byte) *RevertError { + result := common.CopyBytes(revertReason) + reason, errUnpack := abi.UnpackRevert(result) + err := errors.New("execution reverted") + if errUnpack == nil { + err = fmt.Errorf("execution reverted: %v", reason) + } + return &RevertError{ + error: err, + reason: hexutil.Encode(result), + } +} + +// RevertError is an API error that encompass an EVM revert with JSON error +// code and a binary data blob. +type RevertError struct { + error + reason string // revert reason hex encoded +} + +// ErrorCode returns the JSON error code for a revert. +// See: https://github.com/ethereum/wiki/wiki/JSON-RPC-Error-Codes-Improvement-Proposal +func (e *RevertError) ErrorCode() int { + return 3 +} + +// ErrorData returns the hex encoded revert reason. +func (e *RevertError) ErrorData() interface{} { + return e.reason +} diff --git a/ethermint/x/evm/types/evm.pb.go b/ethermint/x/evm/types/evm.pb.go new file mode 100644 index 0000000..d06837d --- /dev/null +++ b/ethermint/x/evm/types/evm.pb.go @@ -0,0 +1,3781 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: ethermint/evm/v1/evm.proto + +package types + +import ( + fmt "fmt" + github_com_cosmos_cosmos_sdk_types "github.com/cosmos/cosmos-sdk/types" + proto "github.com/cosmos/gogoproto/proto" + _ "github.com/gogo/protobuf/gogoproto" + io "io" + math "math" + math_bits "math/bits" +) + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the proto package it is being compiled against. +// A compilation error at this line likely means your copy of the +// proto package needs to be updated. +const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package + +// Params defines the EVM module parameters +type Params struct { + // evm denom represents the token denomination used to run the EVM state + // transitions. + EvmDenom string `protobuf:"bytes,1,opt,name=evm_denom,json=evmDenom,proto3" json:"evm_denom,omitempty" yaml:"evm_denom"` + // enable create toggles state transitions that use the vm.Create function + EnableCreate bool `protobuf:"varint,2,opt,name=enable_create,json=enableCreate,proto3" json:"enable_create,omitempty" yaml:"enable_create"` + // enable call toggles state transitions that use the vm.Call function + EnableCall bool `protobuf:"varint,3,opt,name=enable_call,json=enableCall,proto3" json:"enable_call,omitempty" yaml:"enable_call"` + // extra eips defines the additional EIPs for the vm.Config + ExtraEIPs []int64 `protobuf:"varint,4,rep,packed,name=extra_eips,json=extraEips,proto3" json:"extra_eips,omitempty" yaml:"extra_eips"` + // chain config defines the EVM chain configuration parameters + ChainConfig ChainConfig `protobuf:"bytes,5,opt,name=chain_config,json=chainConfig,proto3" json:"chain_config" yaml:"chain_config"` +} + +func (m *Params) Reset() { *m = Params{} } +func (m *Params) String() string { return proto.CompactTextString(m) } +func (*Params) ProtoMessage() {} +func (*Params) Descriptor() ([]byte, []int) { + return fileDescriptor_d21ecc92c8c8583e, []int{0} +} +func (m *Params) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *Params) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_Params.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *Params) XXX_Merge(src proto.Message) { + xxx_messageInfo_Params.Merge(m, src) +} +func (m *Params) XXX_Size() int { + return m.Size() +} +func (m *Params) XXX_DiscardUnknown() { + xxx_messageInfo_Params.DiscardUnknown(m) +} + +var xxx_messageInfo_Params proto.InternalMessageInfo + +func (m *Params) GetEvmDenom() string { + if m != nil { + return m.EvmDenom + } + return "" +} + +func (m *Params) GetEnableCreate() bool { + if m != nil { + return m.EnableCreate + } + return false +} + +func (m *Params) GetEnableCall() bool { + if m != nil { + return m.EnableCall + } + return false +} + +func (m *Params) GetExtraEIPs() []int64 { + if m != nil { + return m.ExtraEIPs + } + return nil +} + +func (m *Params) GetChainConfig() ChainConfig { + if m != nil { + return m.ChainConfig + } + return ChainConfig{} +} + +// ChainConfig defines the Ethereum ChainConfig parameters using *sdk.Int values +// instead of *big.Int. +type ChainConfig struct { + // Homestead switch block (nil no fork, 0 = already homestead) + HomesteadBlock *github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,1,opt,name=homestead_block,json=homesteadBlock,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"homestead_block,omitempty" yaml:"homestead_block"` + // TheDAO hard-fork switch block (nil no fork) + DAOForkBlock *github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,2,opt,name=dao_fork_block,json=daoForkBlock,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"dao_fork_block,omitempty" yaml:"dao_fork_block"` + // Whether the nodes supports or opposes the DAO hard-fork + DAOForkSupport bool `protobuf:"varint,3,opt,name=dao_fork_support,json=daoForkSupport,proto3" json:"dao_fork_support,omitempty" yaml:"dao_fork_support"` + // EIP150 implements the Gas price changes + // (https://github.com/ethereum/EIPs/issues/150) EIP150 HF block (nil no fork) + EIP150Block *github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,4,opt,name=eip150_block,json=eip150Block,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"eip150_block,omitempty" yaml:"eip150_block"` + // EIP150 HF hash (needed for header only clients as only gas pricing changed) + EIP150Hash string `protobuf:"bytes,5,opt,name=eip150_hash,json=eip150Hash,proto3" json:"eip150_hash,omitempty" yaml:"byzantium_block"` + // EIP155Block HF block + EIP155Block *github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,6,opt,name=eip155_block,json=eip155Block,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"eip155_block,omitempty" yaml:"eip155_block"` + // EIP158 HF block + EIP158Block *github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,7,opt,name=eip158_block,json=eip158Block,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"eip158_block,omitempty" yaml:"eip158_block"` + // Byzantium switch block (nil no fork, 0 = already on byzantium) + ByzantiumBlock *github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,8,opt,name=byzantium_block,json=byzantiumBlock,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"byzantium_block,omitempty" yaml:"byzantium_block"` + // Constantinople switch block (nil no fork, 0 = already activated) + ConstantinopleBlock *github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,9,opt,name=constantinople_block,json=constantinopleBlock,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"constantinople_block,omitempty" yaml:"constantinople_block"` + // Petersburg switch block (nil same as Constantinople) + PetersburgBlock *github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,10,opt,name=petersburg_block,json=petersburgBlock,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"petersburg_block,omitempty" yaml:"petersburg_block"` + // Istanbul switch block (nil no fork, 0 = already on istanbul) + IstanbulBlock *github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,11,opt,name=istanbul_block,json=istanbulBlock,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"istanbul_block,omitempty" yaml:"istanbul_block"` + // Eip-2384 (bomb delay) switch block (nil no fork, 0 = already activated) + MuirGlacierBlock *github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,12,opt,name=muir_glacier_block,json=muirGlacierBlock,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"muir_glacier_block,omitempty" yaml:"muir_glacier_block"` + // Berlin switch block (nil = no fork, 0 = already on berlin) + BerlinBlock *github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,13,opt,name=berlin_block,json=berlinBlock,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"berlin_block,omitempty" yaml:"berlin_block"` + // London switch block (nil = no fork, 0 = already on london) + LondonBlock *github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,17,opt,name=london_block,json=londonBlock,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"london_block,omitempty" yaml:"london_block"` + // Eip-4345 (bomb delay) switch block (nil = no fork, 0 = already activated) + ArrowGlacierBlock *github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,18,opt,name=arrow_glacier_block,json=arrowGlacierBlock,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"arrow_glacier_block,omitempty" yaml:"arrow_glacier_block"` + // EIP-3675 (TheMerge) switch block (nil = no fork, 0 = already in merge proceedings) + MergeForkBlock *github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,19,opt,name=merge_fork_block,json=mergeForkBlock,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"merge_fork_block,omitempty" yaml:"merge_fork_block"` +} + +func (m *ChainConfig) Reset() { *m = ChainConfig{} } +func (m *ChainConfig) String() string { return proto.CompactTextString(m) } +func (*ChainConfig) ProtoMessage() {} +func (*ChainConfig) Descriptor() ([]byte, []int) { + return fileDescriptor_d21ecc92c8c8583e, []int{1} +} +func (m *ChainConfig) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ChainConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ChainConfig.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *ChainConfig) XXX_Merge(src proto.Message) { + xxx_messageInfo_ChainConfig.Merge(m, src) +} +func (m *ChainConfig) XXX_Size() int { + return m.Size() +} +func (m *ChainConfig) XXX_DiscardUnknown() { + xxx_messageInfo_ChainConfig.DiscardUnknown(m) +} + +var xxx_messageInfo_ChainConfig proto.InternalMessageInfo + +func (m *ChainConfig) GetDAOForkSupport() bool { + if m != nil { + return m.DAOForkSupport + } + return false +} + +func (m *ChainConfig) GetEIP150Hash() string { + if m != nil { + return m.EIP150Hash + } + return "" +} + +// State represents a single Storage key value pair item. +type State struct { + Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` + Value string `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"` +} + +func (m *State) Reset() { *m = State{} } +func (m *State) String() string { return proto.CompactTextString(m) } +func (*State) ProtoMessage() {} +func (*State) Descriptor() ([]byte, []int) { + return fileDescriptor_d21ecc92c8c8583e, []int{2} +} +func (m *State) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *State) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_State.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *State) XXX_Merge(src proto.Message) { + xxx_messageInfo_State.Merge(m, src) +} +func (m *State) XXX_Size() int { + return m.Size() +} +func (m *State) XXX_DiscardUnknown() { + xxx_messageInfo_State.DiscardUnknown(m) +} + +var xxx_messageInfo_State proto.InternalMessageInfo + +func (m *State) GetKey() string { + if m != nil { + return m.Key + } + return "" +} + +func (m *State) GetValue() string { + if m != nil { + return m.Value + } + return "" +} + +// TransactionLogs define the logs generated from a transaction execution +// with a given hash. It it used for import/export data as transactions are not +// persisted on blockchain state after an upgrade. +type TransactionLogs struct { + Hash string `protobuf:"bytes,1,opt,name=hash,proto3" json:"hash,omitempty"` + Logs []*Log `protobuf:"bytes,2,rep,name=logs,proto3" json:"logs,omitempty"` +} + +func (m *TransactionLogs) Reset() { *m = TransactionLogs{} } +func (m *TransactionLogs) String() string { return proto.CompactTextString(m) } +func (*TransactionLogs) ProtoMessage() {} +func (*TransactionLogs) Descriptor() ([]byte, []int) { + return fileDescriptor_d21ecc92c8c8583e, []int{3} +} +func (m *TransactionLogs) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *TransactionLogs) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_TransactionLogs.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *TransactionLogs) XXX_Merge(src proto.Message) { + xxx_messageInfo_TransactionLogs.Merge(m, src) +} +func (m *TransactionLogs) XXX_Size() int { + return m.Size() +} +func (m *TransactionLogs) XXX_DiscardUnknown() { + xxx_messageInfo_TransactionLogs.DiscardUnknown(m) +} + +var xxx_messageInfo_TransactionLogs proto.InternalMessageInfo + +func (m *TransactionLogs) GetHash() string { + if m != nil { + return m.Hash + } + return "" +} + +func (m *TransactionLogs) GetLogs() []*Log { + if m != nil { + return m.Logs + } + return nil +} + +// Log represents an protobuf compatible Ethereum Log that defines a contract +// log event. These events are generated by the LOG opcode and stored/indexed by +// the node. +type Log struct { + // address of the contract that generated the event + Address string `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"` + // list of topics provided by the contract. + Topics []string `protobuf:"bytes,2,rep,name=topics,proto3" json:"topics,omitempty"` + // supplied by the contract, usually ABI-encoded + Data []byte `protobuf:"bytes,3,opt,name=data,proto3" json:"data,omitempty"` + // block in which the transaction was included + BlockNumber uint64 `protobuf:"varint,4,opt,name=block_number,json=blockNumber,proto3" json:"blockNumber"` + // hash of the transaction + TxHash string `protobuf:"bytes,5,opt,name=tx_hash,json=txHash,proto3" json:"transactionHash"` + // index of the transaction in the block + TxIndex uint64 `protobuf:"varint,6,opt,name=tx_index,json=txIndex,proto3" json:"transactionIndex"` + // hash of the block in which the transaction was included + BlockHash string `protobuf:"bytes,7,opt,name=block_hash,json=blockHash,proto3" json:"blockHash"` + // index of the log in the block + Index uint64 `protobuf:"varint,8,opt,name=index,proto3" json:"logIndex"` + // The Removed field is true if this log was reverted due to a chain + // reorganisation. You must pay attention to this field if you receive logs + // through a filter query. + Removed bool `protobuf:"varint,9,opt,name=removed,proto3" json:"removed,omitempty"` +} + +func (m *Log) Reset() { *m = Log{} } +func (m *Log) String() string { return proto.CompactTextString(m) } +func (*Log) ProtoMessage() {} +func (*Log) Descriptor() ([]byte, []int) { + return fileDescriptor_d21ecc92c8c8583e, []int{4} +} +func (m *Log) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *Log) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_Log.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *Log) XXX_Merge(src proto.Message) { + xxx_messageInfo_Log.Merge(m, src) +} +func (m *Log) XXX_Size() int { + return m.Size() +} +func (m *Log) XXX_DiscardUnknown() { + xxx_messageInfo_Log.DiscardUnknown(m) +} + +var xxx_messageInfo_Log proto.InternalMessageInfo + +func (m *Log) GetAddress() string { + if m != nil { + return m.Address + } + return "" +} + +func (m *Log) GetTopics() []string { + if m != nil { + return m.Topics + } + return nil +} + +func (m *Log) GetData() []byte { + if m != nil { + return m.Data + } + return nil +} + +func (m *Log) GetBlockNumber() uint64 { + if m != nil { + return m.BlockNumber + } + return 0 +} + +func (m *Log) GetTxHash() string { + if m != nil { + return m.TxHash + } + return "" +} + +func (m *Log) GetTxIndex() uint64 { + if m != nil { + return m.TxIndex + } + return 0 +} + +func (m *Log) GetBlockHash() string { + if m != nil { + return m.BlockHash + } + return "" +} + +func (m *Log) GetIndex() uint64 { + if m != nil { + return m.Index + } + return 0 +} + +func (m *Log) GetRemoved() bool { + if m != nil { + return m.Removed + } + return false +} + +// TxResult stores results of Tx execution. +type TxResult struct { + // contract_address contains the ethereum address of the created contract (if + // any). If the state transition is an evm.Call, the contract address will be + // empty. + ContractAddress string `protobuf:"bytes,1,opt,name=contract_address,json=contractAddress,proto3" json:"contract_address,omitempty" yaml:"contract_address"` + // bloom represents the bloom filter bytes + Bloom []byte `protobuf:"bytes,2,opt,name=bloom,proto3" json:"bloom,omitempty"` + // tx_logs contains the transaction hash and the proto-compatible ethereum + // logs. + TxLogs TransactionLogs `protobuf:"bytes,3,opt,name=tx_logs,json=txLogs,proto3" json:"tx_logs" yaml:"tx_logs"` + // ret defines the bytes from the execution. + Ret []byte `protobuf:"bytes,4,opt,name=ret,proto3" json:"ret,omitempty"` + // reverted flag is set to true when the call has been reverted + Reverted bool `protobuf:"varint,5,opt,name=reverted,proto3" json:"reverted,omitempty"` + // gas_used notes the amount of gas consumed while execution + GasUsed uint64 `protobuf:"varint,6,opt,name=gas_used,json=gasUsed,proto3" json:"gas_used,omitempty"` +} + +func (m *TxResult) Reset() { *m = TxResult{} } +func (m *TxResult) String() string { return proto.CompactTextString(m) } +func (*TxResult) ProtoMessage() {} +func (*TxResult) Descriptor() ([]byte, []int) { + return fileDescriptor_d21ecc92c8c8583e, []int{5} +} +func (m *TxResult) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *TxResult) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_TxResult.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *TxResult) XXX_Merge(src proto.Message) { + xxx_messageInfo_TxResult.Merge(m, src) +} +func (m *TxResult) XXX_Size() int { + return m.Size() +} +func (m *TxResult) XXX_DiscardUnknown() { + xxx_messageInfo_TxResult.DiscardUnknown(m) +} + +var xxx_messageInfo_TxResult proto.InternalMessageInfo + +// AccessTuple is the element type of an access list. +type AccessTuple struct { + // hex formatted ethereum address + Address string `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"` + // hex formatted hashes of the storage keys + StorageKeys []string `protobuf:"bytes,2,rep,name=storage_keys,json=storageKeys,proto3" json:"storageKeys"` +} + +func (m *AccessTuple) Reset() { *m = AccessTuple{} } +func (m *AccessTuple) String() string { return proto.CompactTextString(m) } +func (*AccessTuple) ProtoMessage() {} +func (*AccessTuple) Descriptor() ([]byte, []int) { + return fileDescriptor_d21ecc92c8c8583e, []int{6} +} +func (m *AccessTuple) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *AccessTuple) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_AccessTuple.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *AccessTuple) XXX_Merge(src proto.Message) { + xxx_messageInfo_AccessTuple.Merge(m, src) +} +func (m *AccessTuple) XXX_Size() int { + return m.Size() +} +func (m *AccessTuple) XXX_DiscardUnknown() { + xxx_messageInfo_AccessTuple.DiscardUnknown(m) +} + +var xxx_messageInfo_AccessTuple proto.InternalMessageInfo + +// TraceConfig holds extra parameters to trace functions. +type TraceConfig struct { + // custom javascript tracer + Tracer string `protobuf:"bytes,1,opt,name=tracer,proto3" json:"tracer,omitempty"` + // overrides the default timeout of 5 seconds for JavaScript-based tracing + // calls + Timeout string `protobuf:"bytes,2,opt,name=timeout,proto3" json:"timeout,omitempty"` + // number of blocks the tracer is willing to go back + Reexec uint64 `protobuf:"varint,3,opt,name=reexec,proto3" json:"reexec,omitempty"` + // disable stack capture + DisableStack bool `protobuf:"varint,5,opt,name=disable_stack,json=disableStack,proto3" json:"disableStack"` + // disable storage capture + DisableStorage bool `protobuf:"varint,6,opt,name=disable_storage,json=disableStorage,proto3" json:"disableStorage"` + // print output during capture end + Debug bool `protobuf:"varint,8,opt,name=debug,proto3" json:"debug,omitempty"` + // maximum length of output, but zero means unlimited + Limit int32 `protobuf:"varint,9,opt,name=limit,proto3" json:"limit,omitempty"` + // Chain overrides, can be used to execute a trace using future fork rules + Overrides *ChainConfig `protobuf:"bytes,10,opt,name=overrides,proto3" json:"overrides,omitempty"` + // enable memory capture + EnableMemory bool `protobuf:"varint,11,opt,name=enable_memory,json=enableMemory,proto3" json:"enableMemory"` + // enable return data capture + EnableReturnData bool `protobuf:"varint,12,opt,name=enable_return_data,json=enableReturnData,proto3" json:"enableReturnData"` +} + +func (m *TraceConfig) Reset() { *m = TraceConfig{} } +func (m *TraceConfig) String() string { return proto.CompactTextString(m) } +func (*TraceConfig) ProtoMessage() {} +func (*TraceConfig) Descriptor() ([]byte, []int) { + return fileDescriptor_d21ecc92c8c8583e, []int{7} +} +func (m *TraceConfig) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *TraceConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_TraceConfig.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *TraceConfig) XXX_Merge(src proto.Message) { + xxx_messageInfo_TraceConfig.Merge(m, src) +} +func (m *TraceConfig) XXX_Size() int { + return m.Size() +} +func (m *TraceConfig) XXX_DiscardUnknown() { + xxx_messageInfo_TraceConfig.DiscardUnknown(m) +} + +var xxx_messageInfo_TraceConfig proto.InternalMessageInfo + +func (m *TraceConfig) GetTracer() string { + if m != nil { + return m.Tracer + } + return "" +} + +func (m *TraceConfig) GetTimeout() string { + if m != nil { + return m.Timeout + } + return "" +} + +func (m *TraceConfig) GetReexec() uint64 { + if m != nil { + return m.Reexec + } + return 0 +} + +func (m *TraceConfig) GetDisableStack() bool { + if m != nil { + return m.DisableStack + } + return false +} + +func (m *TraceConfig) GetDisableStorage() bool { + if m != nil { + return m.DisableStorage + } + return false +} + +func (m *TraceConfig) GetDebug() bool { + if m != nil { + return m.Debug + } + return false +} + +func (m *TraceConfig) GetLimit() int32 { + if m != nil { + return m.Limit + } + return 0 +} + +func (m *TraceConfig) GetOverrides() *ChainConfig { + if m != nil { + return m.Overrides + } + return nil +} + +func (m *TraceConfig) GetEnableMemory() bool { + if m != nil { + return m.EnableMemory + } + return false +} + +func (m *TraceConfig) GetEnableReturnData() bool { + if m != nil { + return m.EnableReturnData + } + return false +} + +func init() { + proto.RegisterType((*Params)(nil), "ethermint.evm.v1.Params") + proto.RegisterType((*ChainConfig)(nil), "ethermint.evm.v1.ChainConfig") + proto.RegisterType((*State)(nil), "ethermint.evm.v1.State") + proto.RegisterType((*TransactionLogs)(nil), "ethermint.evm.v1.TransactionLogs") + proto.RegisterType((*Log)(nil), "ethermint.evm.v1.Log") + proto.RegisterType((*TxResult)(nil), "ethermint.evm.v1.TxResult") + proto.RegisterType((*AccessTuple)(nil), "ethermint.evm.v1.AccessTuple") + proto.RegisterType((*TraceConfig)(nil), "ethermint.evm.v1.TraceConfig") +} + +func init() { proto.RegisterFile("ethermint/evm/v1/evm.proto", fileDescriptor_d21ecc92c8c8583e) } + +var fileDescriptor_d21ecc92c8c8583e = []byte{ + // 1483 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x57, 0x4f, 0x4f, 0x1c, 0xb7, + 0x1b, 0x06, 0x76, 0x81, 0x59, 0xef, 0xb0, 0x3b, 0x18, 0xc2, 0x6f, 0x43, 0xf4, 0x63, 0xe8, 0x1c, + 0x2a, 0x2a, 0x25, 0x6c, 0x20, 0x45, 0x8d, 0x12, 0xf5, 0xc0, 0x02, 0x49, 0xa0, 0x69, 0x8a, 0x0c, + 0x55, 0xa5, 0x4a, 0xd5, 0xc8, 0x3b, 0xe3, 0x0c, 0x53, 0x66, 0xc6, 0x2b, 0xdb, 0xb3, 0xd9, 0xad, + 0xfa, 0x01, 0x2a, 0xf5, 0xd2, 0x8f, 0xd0, 0xaf, 0xd0, 0x6f, 0x11, 0xf5, 0x94, 0x4b, 0xa5, 0xaa, + 0x87, 0x51, 0x44, 0x6e, 0x1c, 0xf7, 0x13, 0x54, 0x63, 0x7b, 0xff, 0x82, 0xda, 0xc2, 0x69, 0xfd, + 0xbc, 0x7f, 0x9e, 0xc7, 0x7e, 0xfd, 0x7a, 0xec, 0x05, 0xab, 0x44, 0x9c, 0x11, 0x16, 0x87, 0x89, + 0xa8, 0x93, 0x76, 0x5c, 0x6f, 0x6f, 0xe5, 0x3f, 0x9b, 0x2d, 0x46, 0x05, 0x85, 0xd6, 0xc0, 0xb7, + 0x99, 0x1b, 0xdb, 0x5b, 0xab, 0xcb, 0x01, 0x0d, 0xa8, 0x74, 0xd6, 0xf3, 0x91, 0x8a, 0x73, 0xfe, + 0x98, 0x01, 0x73, 0xc7, 0x98, 0xe1, 0x98, 0xc3, 0x2d, 0x50, 0x22, 0xed, 0xd8, 0xf5, 0x49, 0x42, + 0xe3, 0xda, 0xf4, 0xfa, 0xf4, 0x46, 0xa9, 0xb1, 0xdc, 0xcb, 0x6c, 0xab, 0x8b, 0xe3, 0xe8, 0x89, + 0x33, 0x70, 0x39, 0xc8, 0x20, 0xed, 0x78, 0x3f, 0x1f, 0xc2, 0xcf, 0xc1, 0x02, 0x49, 0x70, 0x33, + 0x22, 0xae, 0xc7, 0x08, 0x16, 0xa4, 0x36, 0xb3, 0x3e, 0xbd, 0x61, 0x34, 0x6a, 0xbd, 0xcc, 0x5e, + 0xd6, 0x69, 0xa3, 0x6e, 0x07, 0x99, 0x0a, 0xef, 0x49, 0x08, 0x3f, 0x03, 0xe5, 0xbe, 0x1f, 0x47, + 0x51, 0xad, 0x20, 0x93, 0x57, 0x7a, 0x99, 0x0d, 0xc7, 0x93, 0x71, 0x14, 0x39, 0x08, 0xe8, 0x54, + 0x1c, 0x45, 0x70, 0x17, 0x00, 0xd2, 0x11, 0x0c, 0xbb, 0x24, 0x6c, 0xf1, 0x5a, 0x71, 0xbd, 0xb0, + 0x51, 0x68, 0x38, 0x17, 0x99, 0x5d, 0x3a, 0xc8, 0xad, 0x07, 0x87, 0xc7, 0xbc, 0x97, 0xd9, 0x8b, + 0x9a, 0x64, 0x10, 0xe8, 0xa0, 0x92, 0x04, 0x07, 0x61, 0x8b, 0xc3, 0xef, 0x80, 0xe9, 0x9d, 0xe1, + 0x30, 0x71, 0x3d, 0x9a, 0xbc, 0x0e, 0x83, 0xda, 0xec, 0xfa, 0xf4, 0x46, 0x79, 0xfb, 0xff, 0x9b, + 0x93, 0x75, 0xdb, 0xdc, 0xcb, 0xa3, 0xf6, 0x64, 0x50, 0xe3, 0xde, 0xdb, 0xcc, 0x9e, 0xea, 0x65, + 0xf6, 0x92, 0xa2, 0x1e, 0x25, 0x70, 0x50, 0xd9, 0x1b, 0x46, 0x3a, 0xbf, 0x55, 0x40, 0x79, 0x24, + 0x13, 0xc6, 0xa0, 0x7a, 0x46, 0x63, 0xc2, 0x05, 0xc1, 0xbe, 0xdb, 0x8c, 0xa8, 0x77, 0xae, 0x4b, + 0xbc, 0xff, 0x57, 0x66, 0x7f, 0x1c, 0x84, 0xe2, 0x2c, 0x6d, 0x6e, 0x7a, 0x34, 0xae, 0x7b, 0x94, + 0xc7, 0x94, 0xeb, 0x9f, 0x07, 0xdc, 0x3f, 0xaf, 0x8b, 0x6e, 0x8b, 0xf0, 0xcd, 0xc3, 0x44, 0xf4, + 0x32, 0x7b, 0x45, 0x09, 0x4f, 0x50, 0x39, 0xa8, 0x32, 0xb0, 0x34, 0x72, 0x03, 0xec, 0x82, 0x8a, + 0x8f, 0xa9, 0xfb, 0x9a, 0xb2, 0x73, 0xad, 0x36, 0x23, 0xd5, 0x4e, 0xfe, 0xbb, 0xda, 0x45, 0x66, + 0x9b, 0xfb, 0xbb, 0x5f, 0x3d, 0xa3, 0xec, 0x5c, 0x72, 0xf6, 0x32, 0xfb, 0x8e, 0x52, 0x1f, 0x67, + 0x76, 0x90, 0xe9, 0x63, 0x3a, 0x08, 0x83, 0xdf, 0x00, 0x6b, 0x10, 0xc0, 0xd3, 0x56, 0x8b, 0x32, + 0xa1, 0x77, 0xf6, 0xc1, 0x45, 0x66, 0x57, 0x34, 0xe5, 0x89, 0xf2, 0xf4, 0x32, 0xfb, 0x7f, 0x13, + 0xa4, 0x3a, 0xc7, 0x41, 0x15, 0x4d, 0xab, 0x43, 0x21, 0x07, 0x26, 0x09, 0x5b, 0x5b, 0x3b, 0x0f, + 0xf5, 0x8a, 0x8a, 0x72, 0x45, 0xc7, 0x37, 0x5a, 0x51, 0xf9, 0xe0, 0xf0, 0x78, 0x6b, 0xe7, 0x61, + 0x7f, 0x41, 0x7a, 0x1f, 0x47, 0x69, 0x1d, 0x54, 0x56, 0x50, 0xad, 0xe6, 0x10, 0x68, 0xe8, 0x9e, + 0x61, 0x7e, 0x26, 0xbb, 0xa4, 0xd4, 0xd8, 0xb8, 0xc8, 0x6c, 0xa0, 0x98, 0x5e, 0x60, 0x7e, 0x36, + 0xdc, 0x97, 0x66, 0xf7, 0x07, 0x9c, 0x88, 0x30, 0x8d, 0xfb, 0x5c, 0x40, 0x25, 0xe7, 0x51, 0x83, + 0xf9, 0xef, 0xe8, 0xf9, 0xcf, 0xdd, 0x7a, 0xfe, 0x3b, 0xd7, 0xcd, 0x7f, 0x67, 0x7c, 0xfe, 0x2a, + 0x66, 0x20, 0xfa, 0x58, 0x8b, 0xce, 0xdf, 0x5a, 0xf4, 0xf1, 0x75, 0xa2, 0x8f, 0xc7, 0x45, 0x55, + 0x4c, 0xde, 0xec, 0x13, 0x95, 0xa8, 0x19, 0xb7, 0x6f, 0xf6, 0x2b, 0x45, 0xad, 0x0c, 0x2c, 0x4a, + 0xee, 0x47, 0xb0, 0xec, 0xd1, 0x84, 0x8b, 0xdc, 0x96, 0xd0, 0x56, 0x44, 0xb4, 0x66, 0x49, 0x6a, + 0x1e, 0xde, 0x48, 0xf3, 0x9e, 0x3e, 0xd9, 0xd7, 0xf0, 0x39, 0x68, 0x69, 0xdc, 0xac, 0xd4, 0x5b, + 0xc0, 0x6a, 0x11, 0x41, 0x18, 0x6f, 0xa6, 0x2c, 0xd0, 0xca, 0x40, 0x2a, 0x1f, 0xdc, 0x48, 0x59, + 0x9f, 0x83, 0x49, 0x2e, 0x07, 0x55, 0x87, 0x26, 0xa5, 0xf8, 0x3d, 0xa8, 0x84, 0xf9, 0x34, 0x9a, + 0x69, 0xa4, 0xf5, 0xca, 0x52, 0x6f, 0xef, 0x46, 0x7a, 0xfa, 0x30, 0x8f, 0x33, 0x39, 0x68, 0xa1, + 0x6f, 0x50, 0x5a, 0x29, 0x80, 0x71, 0x1a, 0x32, 0x37, 0x88, 0xb0, 0x17, 0x12, 0xa6, 0xf5, 0x4c, + 0xa9, 0xf7, 0xfc, 0x46, 0x7a, 0x77, 0x95, 0xde, 0x55, 0x36, 0x07, 0x59, 0xb9, 0xf1, 0xb9, 0xb2, + 0x29, 0x59, 0x1f, 0x98, 0x4d, 0xc2, 0xa2, 0x30, 0xd1, 0x82, 0x0b, 0x52, 0x70, 0xf7, 0x46, 0x82, + 0xba, 0x4f, 0x47, 0x79, 0x1c, 0x54, 0x56, 0x70, 0xa0, 0x12, 0xd1, 0xc4, 0xa7, 0x7d, 0x95, 0xc5, + 0xdb, 0xab, 0x8c, 0xf2, 0x38, 0xa8, 0xac, 0xa0, 0x52, 0xe9, 0x80, 0x25, 0xcc, 0x18, 0x7d, 0x33, + 0x51, 0x43, 0x28, 0xc5, 0x5e, 0xdc, 0x48, 0x6c, 0x55, 0x89, 0x5d, 0x43, 0xe7, 0xa0, 0x45, 0x69, + 0x1d, 0xab, 0x22, 0x05, 0x56, 0x4c, 0x58, 0x40, 0x46, 0xef, 0x81, 0xa5, 0xdb, 0xb7, 0xe6, 0x24, + 0x97, 0x83, 0x2a, 0xd2, 0x34, 0xf8, 0xf6, 0x1f, 0x15, 0x8d, 0x8a, 0x55, 0x3d, 0x2a, 0x1a, 0x55, + 0xcb, 0x3a, 0x2a, 0x1a, 0x96, 0xb5, 0x88, 0x16, 0xba, 0x34, 0xa2, 0x6e, 0xfb, 0x91, 0xca, 0x40, + 0x65, 0xf2, 0x06, 0x73, 0x7d, 0x90, 0x51, 0xc5, 0xc3, 0x02, 0x47, 0x5d, 0x2e, 0x34, 0x5d, 0x1d, + 0xcc, 0x9e, 0x88, 0xfc, 0x5d, 0x60, 0x81, 0xc2, 0x39, 0xe9, 0xaa, 0x0b, 0x12, 0xe5, 0x43, 0xb8, + 0x0c, 0x66, 0xdb, 0x38, 0x4a, 0xd5, 0x03, 0xa3, 0x84, 0x14, 0x70, 0x8e, 0x41, 0xf5, 0x94, 0xe1, + 0x84, 0x63, 0x4f, 0x84, 0x34, 0x79, 0x49, 0x03, 0x0e, 0x21, 0x28, 0xca, 0x0f, 0xb5, 0xca, 0x95, + 0x63, 0xf8, 0x09, 0x28, 0x46, 0x34, 0xe0, 0xb5, 0x99, 0xf5, 0xc2, 0x46, 0x79, 0xfb, 0xce, 0xd5, + 0x2b, 0xfe, 0x25, 0x0d, 0x90, 0x0c, 0x71, 0x7e, 0x9f, 0x01, 0x85, 0x97, 0x34, 0x80, 0x35, 0x30, + 0x8f, 0x7d, 0x9f, 0x11, 0xce, 0x35, 0x53, 0x1f, 0xc2, 0x15, 0x30, 0x27, 0x68, 0x2b, 0xf4, 0x14, + 0x5d, 0x09, 0x69, 0x94, 0x0b, 0xfb, 0x58, 0x60, 0x79, 0xd5, 0x99, 0x48, 0x8e, 0xe1, 0x36, 0x30, + 0xe5, 0xca, 0xdc, 0x24, 0x8d, 0x9b, 0x84, 0xc9, 0x1b, 0xab, 0xd8, 0xa8, 0x5e, 0x66, 0x76, 0x59, + 0xda, 0x5f, 0x49, 0x33, 0x1a, 0x05, 0xf0, 0x3e, 0x98, 0x17, 0x9d, 0xd1, 0xcb, 0x66, 0xe9, 0x32, + 0xb3, 0xab, 0x62, 0xb8, 0xcc, 0xfc, 0x2e, 0x41, 0x73, 0xa2, 0x23, 0xef, 0x94, 0x3a, 0x30, 0x44, + 0xc7, 0x0d, 0x13, 0x9f, 0x74, 0xe4, 0x7d, 0x52, 0x6c, 0x2c, 0x5f, 0x66, 0xb6, 0x35, 0x12, 0x7e, + 0x98, 0xfb, 0xd0, 0xbc, 0xe8, 0xc8, 0x01, 0xbc, 0x0f, 0x80, 0x9a, 0x92, 0x54, 0x50, 0xb7, 0xc1, + 0xc2, 0x65, 0x66, 0x97, 0xa4, 0x55, 0x72, 0x0f, 0x87, 0xd0, 0x01, 0xb3, 0x8a, 0xdb, 0x90, 0xdc, + 0xe6, 0x65, 0x66, 0x1b, 0x11, 0x0d, 0x14, 0xa7, 0x72, 0xe5, 0xa5, 0x62, 0x24, 0xa6, 0x6d, 0xe2, + 0xcb, 0x0f, 0xae, 0x81, 0xfa, 0xd0, 0xf9, 0x79, 0x06, 0x18, 0xa7, 0x1d, 0x44, 0x78, 0x1a, 0x09, + 0xf8, 0x0c, 0x58, 0x1e, 0x4d, 0x04, 0xc3, 0x9e, 0x70, 0xc7, 0x4a, 0xdb, 0xb8, 0x37, 0xec, 0xb0, + 0xc9, 0x08, 0x07, 0x55, 0xfb, 0xa6, 0x5d, 0x5d, 0xff, 0x65, 0x30, 0xdb, 0x8c, 0x28, 0x8d, 0x65, + 0x27, 0x98, 0x48, 0x01, 0x88, 0x64, 0xd5, 0xe4, 0x2e, 0x17, 0xe4, 0x43, 0xee, 0xa3, 0xab, 0xbb, + 0x3c, 0xd1, 0x2a, 0x8d, 0x15, 0xfd, 0x98, 0xab, 0x28, 0x6d, 0x9d, 0xef, 0xe4, 0xb5, 0x95, 0xad, + 0x64, 0x81, 0x02, 0x23, 0x42, 0x6e, 0x9a, 0x89, 0xf2, 0x21, 0x5c, 0x05, 0x06, 0x23, 0x6d, 0xc2, + 0x04, 0xf1, 0xe5, 0xe6, 0x18, 0x68, 0x80, 0xe1, 0x5d, 0x60, 0x04, 0x98, 0xbb, 0x29, 0x27, 0xbe, + 0xda, 0x09, 0x34, 0x1f, 0x60, 0xfe, 0x35, 0x27, 0xfe, 0x93, 0xe2, 0x4f, 0xbf, 0xda, 0x53, 0x0e, + 0x06, 0xe5, 0x5d, 0xcf, 0x23, 0x9c, 0x9f, 0xa6, 0xad, 0x88, 0xfc, 0x43, 0x87, 0x6d, 0x03, 0x93, + 0x0b, 0xca, 0x70, 0x40, 0xdc, 0x73, 0xd2, 0xd5, 0x7d, 0xa6, 0xba, 0x46, 0xdb, 0xbf, 0x20, 0x5d, + 0x8e, 0x46, 0x81, 0x96, 0x78, 0x5f, 0x00, 0xe5, 0x53, 0x86, 0x3d, 0xa2, 0x1f, 0x9d, 0x79, 0xaf, + 0xe6, 0x90, 0x69, 0x09, 0x8d, 0x72, 0x6d, 0x11, 0xc6, 0x84, 0xa6, 0x42, 0x9f, 0xa7, 0x3e, 0xcc, + 0x33, 0x18, 0x21, 0x1d, 0xe2, 0xc9, 0x32, 0x16, 0x91, 0x46, 0x70, 0x07, 0x2c, 0xf8, 0x21, 0x97, + 0xaf, 0x71, 0x2e, 0xb0, 0x77, 0xae, 0x96, 0xdf, 0xb0, 0x2e, 0x33, 0xdb, 0xd4, 0x8e, 0x93, 0xdc, + 0x8e, 0xc6, 0x10, 0x7c, 0x0a, 0xaa, 0xc3, 0x34, 0x39, 0x5b, 0x59, 0x1b, 0xa3, 0x01, 0x2f, 0x33, + 0xbb, 0x32, 0x08, 0x95, 0x1e, 0x34, 0x81, 0xf3, 0x9d, 0xf6, 0x49, 0x33, 0x0d, 0x64, 0xf3, 0x19, + 0x48, 0x81, 0xdc, 0x1a, 0x85, 0x71, 0x28, 0x64, 0xb3, 0xcd, 0x22, 0x05, 0xe0, 0x53, 0x50, 0xa2, + 0x6d, 0xc2, 0x58, 0xe8, 0x13, 0x2e, 0x6f, 0xdf, 0x7f, 0x7b, 0xca, 0xa3, 0x61, 0x7c, 0xbe, 0x38, + 0xfd, 0x4f, 0x23, 0x26, 0x31, 0x65, 0x5d, 0x79, 0x9d, 0xea, 0xc5, 0x29, 0xc7, 0x97, 0xd2, 0x8e, + 0xc6, 0x10, 0x6c, 0x00, 0xa8, 0xd3, 0x18, 0x11, 0x29, 0x4b, 0x5c, 0x79, 0xfe, 0x4d, 0x99, 0x2b, + 0x4f, 0xa1, 0xf2, 0x22, 0xe9, 0xdc, 0xc7, 0x02, 0xa3, 0x2b, 0x96, 0xa3, 0xa2, 0x51, 0xb4, 0x66, + 0x8f, 0x8a, 0xc6, 0xbc, 0x65, 0x0c, 0xd6, 0xaf, 0x67, 0x81, 0x96, 0xfa, 0x78, 0x84, 0xbe, 0xf1, + 0xea, 0xed, 0xc5, 0xda, 0xf4, 0xbb, 0x8b, 0xb5, 0xe9, 0xf7, 0x17, 0x6b, 0xd3, 0xbf, 0x7c, 0x58, + 0x9b, 0x7a, 0xf7, 0x61, 0x6d, 0xea, 0xcf, 0x0f, 0x6b, 0x53, 0xdf, 0x7e, 0x3a, 0xf2, 0x39, 0x0f, + 0x59, 0xc8, 0x13, 0x22, 0xea, 0x1e, 0x65, 0x24, 0xff, 0x9a, 0x3f, 0x08, 0x68, 0x7d, 0xf8, 0x67, + 0xb1, 0x23, 0xff, 0x2e, 0xca, 0x0f, 0x7c, 0x73, 0x4e, 0xfe, 0x0d, 0x7c, 0xf4, 0x77, 0x00, 0x00, + 0x00, 0xff, 0xff, 0x43, 0xb1, 0x8d, 0x48, 0x4c, 0x0e, 0x00, 0x00, +} + +func (m *Params) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Params) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *Params) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + { + size, err := m.ChainConfig.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintEvm(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x2a + if len(m.ExtraEIPs) > 0 { + dAtA3 := make([]byte, len(m.ExtraEIPs)*10) + var j2 int + for _, num1 := range m.ExtraEIPs { + num := uint64(num1) + for num >= 1<<7 { + dAtA3[j2] = uint8(uint64(num)&0x7f | 0x80) + num >>= 7 + j2++ + } + dAtA3[j2] = uint8(num) + j2++ + } + i -= j2 + copy(dAtA[i:], dAtA3[:j2]) + i = encodeVarintEvm(dAtA, i, uint64(j2)) + i-- + dAtA[i] = 0x22 + } + if m.EnableCall { + i-- + if m.EnableCall { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x18 + } + if m.EnableCreate { + i-- + if m.EnableCreate { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x10 + } + if len(m.EvmDenom) > 0 { + i -= len(m.EvmDenom) + copy(dAtA[i:], m.EvmDenom) + i = encodeVarintEvm(dAtA, i, uint64(len(m.EvmDenom))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ChainConfig) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ChainConfig) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ChainConfig) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.MergeForkBlock != nil { + { + size := m.MergeForkBlock.Size() + i -= size + if _, err := m.MergeForkBlock.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + i = encodeVarintEvm(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0x9a + } + if m.ArrowGlacierBlock != nil { + { + size := m.ArrowGlacierBlock.Size() + i -= size + if _, err := m.ArrowGlacierBlock.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + i = encodeVarintEvm(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0x92 + } + if m.LondonBlock != nil { + { + size := m.LondonBlock.Size() + i -= size + if _, err := m.LondonBlock.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + i = encodeVarintEvm(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0x8a + } + if m.BerlinBlock != nil { + { + size := m.BerlinBlock.Size() + i -= size + if _, err := m.BerlinBlock.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + i = encodeVarintEvm(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x6a + } + if m.MuirGlacierBlock != nil { + { + size := m.MuirGlacierBlock.Size() + i -= size + if _, err := m.MuirGlacierBlock.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + i = encodeVarintEvm(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x62 + } + if m.IstanbulBlock != nil { + { + size := m.IstanbulBlock.Size() + i -= size + if _, err := m.IstanbulBlock.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + i = encodeVarintEvm(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x5a + } + if m.PetersburgBlock != nil { + { + size := m.PetersburgBlock.Size() + i -= size + if _, err := m.PetersburgBlock.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + i = encodeVarintEvm(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x52 + } + if m.ConstantinopleBlock != nil { + { + size := m.ConstantinopleBlock.Size() + i -= size + if _, err := m.ConstantinopleBlock.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + i = encodeVarintEvm(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x4a + } + if m.ByzantiumBlock != nil { + { + size := m.ByzantiumBlock.Size() + i -= size + if _, err := m.ByzantiumBlock.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + i = encodeVarintEvm(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x42 + } + if m.EIP158Block != nil { + { + size := m.EIP158Block.Size() + i -= size + if _, err := m.EIP158Block.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + i = encodeVarintEvm(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x3a + } + if m.EIP155Block != nil { + { + size := m.EIP155Block.Size() + i -= size + if _, err := m.EIP155Block.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + i = encodeVarintEvm(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x32 + } + if len(m.EIP150Hash) > 0 { + i -= len(m.EIP150Hash) + copy(dAtA[i:], m.EIP150Hash) + i = encodeVarintEvm(dAtA, i, uint64(len(m.EIP150Hash))) + i-- + dAtA[i] = 0x2a + } + if m.EIP150Block != nil { + { + size := m.EIP150Block.Size() + i -= size + if _, err := m.EIP150Block.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + i = encodeVarintEvm(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x22 + } + if m.DAOForkSupport { + i-- + if m.DAOForkSupport { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x18 + } + if m.DAOForkBlock != nil { + { + size := m.DAOForkBlock.Size() + i -= size + if _, err := m.DAOForkBlock.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + i = encodeVarintEvm(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if m.HomesteadBlock != nil { + { + size := m.HomesteadBlock.Size() + i -= size + if _, err := m.HomesteadBlock.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + i = encodeVarintEvm(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *State) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *State) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *State) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Value) > 0 { + i -= len(m.Value) + copy(dAtA[i:], m.Value) + i = encodeVarintEvm(dAtA, i, uint64(len(m.Value))) + i-- + dAtA[i] = 0x12 + } + if len(m.Key) > 0 { + i -= len(m.Key) + copy(dAtA[i:], m.Key) + i = encodeVarintEvm(dAtA, i, uint64(len(m.Key))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *TransactionLogs) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *TransactionLogs) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *TransactionLogs) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Logs) > 0 { + for iNdEx := len(m.Logs) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Logs[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintEvm(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + } + if len(m.Hash) > 0 { + i -= len(m.Hash) + copy(dAtA[i:], m.Hash) + i = encodeVarintEvm(dAtA, i, uint64(len(m.Hash))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *Log) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *Log) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *Log) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Removed { + i-- + if m.Removed { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x48 + } + if m.Index != 0 { + i = encodeVarintEvm(dAtA, i, uint64(m.Index)) + i-- + dAtA[i] = 0x40 + } + if len(m.BlockHash) > 0 { + i -= len(m.BlockHash) + copy(dAtA[i:], m.BlockHash) + i = encodeVarintEvm(dAtA, i, uint64(len(m.BlockHash))) + i-- + dAtA[i] = 0x3a + } + if m.TxIndex != 0 { + i = encodeVarintEvm(dAtA, i, uint64(m.TxIndex)) + i-- + dAtA[i] = 0x30 + } + if len(m.TxHash) > 0 { + i -= len(m.TxHash) + copy(dAtA[i:], m.TxHash) + i = encodeVarintEvm(dAtA, i, uint64(len(m.TxHash))) + i-- + dAtA[i] = 0x2a + } + if m.BlockNumber != 0 { + i = encodeVarintEvm(dAtA, i, uint64(m.BlockNumber)) + i-- + dAtA[i] = 0x20 + } + if len(m.Data) > 0 { + i -= len(m.Data) + copy(dAtA[i:], m.Data) + i = encodeVarintEvm(dAtA, i, uint64(len(m.Data))) + i-- + dAtA[i] = 0x1a + } + if len(m.Topics) > 0 { + for iNdEx := len(m.Topics) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.Topics[iNdEx]) + copy(dAtA[i:], m.Topics[iNdEx]) + i = encodeVarintEvm(dAtA, i, uint64(len(m.Topics[iNdEx]))) + i-- + dAtA[i] = 0x12 + } + } + if len(m.Address) > 0 { + i -= len(m.Address) + copy(dAtA[i:], m.Address) + i = encodeVarintEvm(dAtA, i, uint64(len(m.Address))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *TxResult) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *TxResult) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *TxResult) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.GasUsed != 0 { + i = encodeVarintEvm(dAtA, i, uint64(m.GasUsed)) + i-- + dAtA[i] = 0x30 + } + if m.Reverted { + i-- + if m.Reverted { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x28 + } + if len(m.Ret) > 0 { + i -= len(m.Ret) + copy(dAtA[i:], m.Ret) + i = encodeVarintEvm(dAtA, i, uint64(len(m.Ret))) + i-- + dAtA[i] = 0x22 + } + { + size, err := m.TxLogs.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintEvm(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + if len(m.Bloom) > 0 { + i -= len(m.Bloom) + copy(dAtA[i:], m.Bloom) + i = encodeVarintEvm(dAtA, i, uint64(len(m.Bloom))) + i-- + dAtA[i] = 0x12 + } + if len(m.ContractAddress) > 0 { + i -= len(m.ContractAddress) + copy(dAtA[i:], m.ContractAddress) + i = encodeVarintEvm(dAtA, i, uint64(len(m.ContractAddress))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *AccessTuple) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *AccessTuple) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *AccessTuple) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.StorageKeys) > 0 { + for iNdEx := len(m.StorageKeys) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.StorageKeys[iNdEx]) + copy(dAtA[i:], m.StorageKeys[iNdEx]) + i = encodeVarintEvm(dAtA, i, uint64(len(m.StorageKeys[iNdEx]))) + i-- + dAtA[i] = 0x12 + } + } + if len(m.Address) > 0 { + i -= len(m.Address) + copy(dAtA[i:], m.Address) + i = encodeVarintEvm(dAtA, i, uint64(len(m.Address))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *TraceConfig) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *TraceConfig) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *TraceConfig) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.EnableReturnData { + i-- + if m.EnableReturnData { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x60 + } + if m.EnableMemory { + i-- + if m.EnableMemory { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x58 + } + if m.Overrides != nil { + { + size, err := m.Overrides.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintEvm(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x52 + } + if m.Limit != 0 { + i = encodeVarintEvm(dAtA, i, uint64(m.Limit)) + i-- + dAtA[i] = 0x48 + } + if m.Debug { + i-- + if m.Debug { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x40 + } + if m.DisableStorage { + i-- + if m.DisableStorage { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x30 + } + if m.DisableStack { + i-- + if m.DisableStack { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x28 + } + if m.Reexec != 0 { + i = encodeVarintEvm(dAtA, i, uint64(m.Reexec)) + i-- + dAtA[i] = 0x18 + } + if len(m.Timeout) > 0 { + i -= len(m.Timeout) + copy(dAtA[i:], m.Timeout) + i = encodeVarintEvm(dAtA, i, uint64(len(m.Timeout))) + i-- + dAtA[i] = 0x12 + } + if len(m.Tracer) > 0 { + i -= len(m.Tracer) + copy(dAtA[i:], m.Tracer) + i = encodeVarintEvm(dAtA, i, uint64(len(m.Tracer))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func encodeVarintEvm(dAtA []byte, offset int, v uint64) int { + offset -= sovEvm(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} +func (m *Params) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.EvmDenom) + if l > 0 { + n += 1 + l + sovEvm(uint64(l)) + } + if m.EnableCreate { + n += 2 + } + if m.EnableCall { + n += 2 + } + if len(m.ExtraEIPs) > 0 { + l = 0 + for _, e := range m.ExtraEIPs { + l += sovEvm(uint64(e)) + } + n += 1 + sovEvm(uint64(l)) + l + } + l = m.ChainConfig.Size() + n += 1 + l + sovEvm(uint64(l)) + return n +} + +func (m *ChainConfig) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.HomesteadBlock != nil { + l = m.HomesteadBlock.Size() + n += 1 + l + sovEvm(uint64(l)) + } + if m.DAOForkBlock != nil { + l = m.DAOForkBlock.Size() + n += 1 + l + sovEvm(uint64(l)) + } + if m.DAOForkSupport { + n += 2 + } + if m.EIP150Block != nil { + l = m.EIP150Block.Size() + n += 1 + l + sovEvm(uint64(l)) + } + l = len(m.EIP150Hash) + if l > 0 { + n += 1 + l + sovEvm(uint64(l)) + } + if m.EIP155Block != nil { + l = m.EIP155Block.Size() + n += 1 + l + sovEvm(uint64(l)) + } + if m.EIP158Block != nil { + l = m.EIP158Block.Size() + n += 1 + l + sovEvm(uint64(l)) + } + if m.ByzantiumBlock != nil { + l = m.ByzantiumBlock.Size() + n += 1 + l + sovEvm(uint64(l)) + } + if m.ConstantinopleBlock != nil { + l = m.ConstantinopleBlock.Size() + n += 1 + l + sovEvm(uint64(l)) + } + if m.PetersburgBlock != nil { + l = m.PetersburgBlock.Size() + n += 1 + l + sovEvm(uint64(l)) + } + if m.IstanbulBlock != nil { + l = m.IstanbulBlock.Size() + n += 1 + l + sovEvm(uint64(l)) + } + if m.MuirGlacierBlock != nil { + l = m.MuirGlacierBlock.Size() + n += 1 + l + sovEvm(uint64(l)) + } + if m.BerlinBlock != nil { + l = m.BerlinBlock.Size() + n += 1 + l + sovEvm(uint64(l)) + } + if m.LondonBlock != nil { + l = m.LondonBlock.Size() + n += 2 + l + sovEvm(uint64(l)) + } + if m.ArrowGlacierBlock != nil { + l = m.ArrowGlacierBlock.Size() + n += 2 + l + sovEvm(uint64(l)) + } + if m.MergeForkBlock != nil { + l = m.MergeForkBlock.Size() + n += 2 + l + sovEvm(uint64(l)) + } + return n +} + +func (m *State) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Key) + if l > 0 { + n += 1 + l + sovEvm(uint64(l)) + } + l = len(m.Value) + if l > 0 { + n += 1 + l + sovEvm(uint64(l)) + } + return n +} + +func (m *TransactionLogs) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Hash) + if l > 0 { + n += 1 + l + sovEvm(uint64(l)) + } + if len(m.Logs) > 0 { + for _, e := range m.Logs { + l = e.Size() + n += 1 + l + sovEvm(uint64(l)) + } + } + return n +} + +func (m *Log) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Address) + if l > 0 { + n += 1 + l + sovEvm(uint64(l)) + } + if len(m.Topics) > 0 { + for _, s := range m.Topics { + l = len(s) + n += 1 + l + sovEvm(uint64(l)) + } + } + l = len(m.Data) + if l > 0 { + n += 1 + l + sovEvm(uint64(l)) + } + if m.BlockNumber != 0 { + n += 1 + sovEvm(uint64(m.BlockNumber)) + } + l = len(m.TxHash) + if l > 0 { + n += 1 + l + sovEvm(uint64(l)) + } + if m.TxIndex != 0 { + n += 1 + sovEvm(uint64(m.TxIndex)) + } + l = len(m.BlockHash) + if l > 0 { + n += 1 + l + sovEvm(uint64(l)) + } + if m.Index != 0 { + n += 1 + sovEvm(uint64(m.Index)) + } + if m.Removed { + n += 2 + } + return n +} + +func (m *TxResult) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.ContractAddress) + if l > 0 { + n += 1 + l + sovEvm(uint64(l)) + } + l = len(m.Bloom) + if l > 0 { + n += 1 + l + sovEvm(uint64(l)) + } + l = m.TxLogs.Size() + n += 1 + l + sovEvm(uint64(l)) + l = len(m.Ret) + if l > 0 { + n += 1 + l + sovEvm(uint64(l)) + } + if m.Reverted { + n += 2 + } + if m.GasUsed != 0 { + n += 1 + sovEvm(uint64(m.GasUsed)) + } + return n +} + +func (m *AccessTuple) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Address) + if l > 0 { + n += 1 + l + sovEvm(uint64(l)) + } + if len(m.StorageKeys) > 0 { + for _, s := range m.StorageKeys { + l = len(s) + n += 1 + l + sovEvm(uint64(l)) + } + } + return n +} + +func (m *TraceConfig) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Tracer) + if l > 0 { + n += 1 + l + sovEvm(uint64(l)) + } + l = len(m.Timeout) + if l > 0 { + n += 1 + l + sovEvm(uint64(l)) + } + if m.Reexec != 0 { + n += 1 + sovEvm(uint64(m.Reexec)) + } + if m.DisableStack { + n += 2 + } + if m.DisableStorage { + n += 2 + } + if m.Debug { + n += 2 + } + if m.Limit != 0 { + n += 1 + sovEvm(uint64(m.Limit)) + } + if m.Overrides != nil { + l = m.Overrides.Size() + n += 1 + l + sovEvm(uint64(l)) + } + if m.EnableMemory { + n += 2 + } + if m.EnableReturnData { + n += 2 + } + return n +} + +func sovEvm(x uint64) (n int) { + return (math_bits.Len64(x|1) + 6) / 7 +} +func sozEvm(x uint64) (n int) { + return sovEvm(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *Params) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvm + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Params: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Params: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EvmDenom", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvm + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthEvm + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthEvm + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.EvmDenom = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field EnableCreate", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvm + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.EnableCreate = bool(v != 0) + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field EnableCall", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvm + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.EnableCall = bool(v != 0) + case 4: + if wireType == 0 { + var v int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvm + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int64(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.ExtraEIPs = append(m.ExtraEIPs, v) + } else if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvm + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + packedLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthEvm + } + postIndex := iNdEx + packedLen + if postIndex < 0 { + return ErrInvalidLengthEvm + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + var elementCount int + var count int + for _, integer := range dAtA[iNdEx:postIndex] { + if integer < 128 { + count++ + } + } + elementCount = count + if elementCount != 0 && len(m.ExtraEIPs) == 0 { + m.ExtraEIPs = make([]int64, 0, elementCount) + } + for iNdEx < postIndex { + var v int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvm + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int64(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.ExtraEIPs = append(m.ExtraEIPs, v) + } + } else { + return fmt.Errorf("proto: wrong wireType = %d for field ExtraEIPs", wireType) + } + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ChainConfig", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvm + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthEvm + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthEvm + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.ChainConfig.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipEvm(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthEvm + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ChainConfig) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvm + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ChainConfig: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ChainConfig: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field HomesteadBlock", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvm + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthEvm + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthEvm + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + var v github_com_cosmos_cosmos_sdk_types.Int + m.HomesteadBlock = &v + if err := m.HomesteadBlock.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DAOForkBlock", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvm + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthEvm + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthEvm + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + var v github_com_cosmos_cosmos_sdk_types.Int + m.DAOForkBlock = &v + if err := m.DAOForkBlock.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field DAOForkSupport", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvm + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.DAOForkSupport = bool(v != 0) + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EIP150Block", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvm + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthEvm + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthEvm + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + var v github_com_cosmos_cosmos_sdk_types.Int + m.EIP150Block = &v + if err := m.EIP150Block.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EIP150Hash", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvm + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthEvm + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthEvm + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.EIP150Hash = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EIP155Block", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvm + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthEvm + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthEvm + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + var v github_com_cosmos_cosmos_sdk_types.Int + m.EIP155Block = &v + if err := m.EIP155Block.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field EIP158Block", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvm + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthEvm + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthEvm + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + var v github_com_cosmos_cosmos_sdk_types.Int + m.EIP158Block = &v + if err := m.EIP158Block.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ByzantiumBlock", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvm + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthEvm + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthEvm + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + var v github_com_cosmos_cosmos_sdk_types.Int + m.ByzantiumBlock = &v + if err := m.ByzantiumBlock.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 9: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ConstantinopleBlock", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvm + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthEvm + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthEvm + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + var v github_com_cosmos_cosmos_sdk_types.Int + m.ConstantinopleBlock = &v + if err := m.ConstantinopleBlock.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 10: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PetersburgBlock", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvm + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthEvm + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthEvm + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + var v github_com_cosmos_cosmos_sdk_types.Int + m.PetersburgBlock = &v + if err := m.PetersburgBlock.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 11: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field IstanbulBlock", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvm + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthEvm + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthEvm + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + var v github_com_cosmos_cosmos_sdk_types.Int + m.IstanbulBlock = &v + if err := m.IstanbulBlock.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 12: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field MuirGlacierBlock", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvm + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthEvm + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthEvm + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + var v github_com_cosmos_cosmos_sdk_types.Int + m.MuirGlacierBlock = &v + if err := m.MuirGlacierBlock.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 13: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BerlinBlock", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvm + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthEvm + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthEvm + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + var v github_com_cosmos_cosmos_sdk_types.Int + m.BerlinBlock = &v + if err := m.BerlinBlock.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 17: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field LondonBlock", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvm + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthEvm + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthEvm + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + var v github_com_cosmos_cosmos_sdk_types.Int + m.LondonBlock = &v + if err := m.LondonBlock.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 18: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ArrowGlacierBlock", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvm + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthEvm + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthEvm + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + var v github_com_cosmos_cosmos_sdk_types.Int + m.ArrowGlacierBlock = &v + if err := m.ArrowGlacierBlock.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 19: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field MergeForkBlock", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvm + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthEvm + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthEvm + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + var v github_com_cosmos_cosmos_sdk_types.Int + m.MergeForkBlock = &v + if err := m.MergeForkBlock.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipEvm(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthEvm + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *State) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvm + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: State: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: State: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvm + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthEvm + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthEvm + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Key = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvm + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthEvm + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthEvm + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Value = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipEvm(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthEvm + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *TransactionLogs) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvm + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: TransactionLogs: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: TransactionLogs: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Hash", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvm + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthEvm + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthEvm + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Hash = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Logs", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvm + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthEvm + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthEvm + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Logs = append(m.Logs, &Log{}) + if err := m.Logs[len(m.Logs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipEvm(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthEvm + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *Log) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvm + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: Log: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Log: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvm + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthEvm + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthEvm + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Address = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Topics", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvm + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthEvm + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthEvm + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Topics = append(m.Topics, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvm + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthEvm + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthEvm + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Data = append(m.Data[:0], dAtA[iNdEx:postIndex]...) + if m.Data == nil { + m.Data = []byte{} + } + iNdEx = postIndex + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field BlockNumber", wireType) + } + m.BlockNumber = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvm + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.BlockNumber |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field TxHash", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvm + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthEvm + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthEvm + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.TxHash = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field TxIndex", wireType) + } + m.TxIndex = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvm + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.TxIndex |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BlockHash", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvm + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthEvm + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthEvm + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.BlockHash = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 8: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType) + } + m.Index = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvm + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Index |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 9: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Removed", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvm + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.Removed = bool(v != 0) + default: + iNdEx = preIndex + skippy, err := skipEvm(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthEvm + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *TxResult) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvm + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: TxResult: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: TxResult: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ContractAddress", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvm + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthEvm + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthEvm + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ContractAddress = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Bloom", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvm + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthEvm + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthEvm + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Bloom = append(m.Bloom[:0], dAtA[iNdEx:postIndex]...) + if m.Bloom == nil { + m.Bloom = []byte{} + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field TxLogs", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvm + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthEvm + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthEvm + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.TxLogs.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Ret", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvm + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthEvm + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthEvm + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Ret = append(m.Ret[:0], dAtA[iNdEx:postIndex]...) + if m.Ret == nil { + m.Ret = []byte{} + } + iNdEx = postIndex + case 5: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Reverted", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvm + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.Reverted = bool(v != 0) + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field GasUsed", wireType) + } + m.GasUsed = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvm + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.GasUsed |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipEvm(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthEvm + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *AccessTuple) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvm + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: AccessTuple: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: AccessTuple: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvm + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthEvm + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthEvm + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Address = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StorageKeys", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvm + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthEvm + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthEvm + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.StorageKeys = append(m.StorageKeys, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipEvm(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthEvm + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *TraceConfig) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvm + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: TraceConfig: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: TraceConfig: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Tracer", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvm + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthEvm + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthEvm + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Tracer = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Timeout", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvm + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthEvm + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthEvm + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Timeout = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Reexec", wireType) + } + m.Reexec = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvm + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Reexec |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 5: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field DisableStack", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvm + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.DisableStack = bool(v != 0) + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field DisableStorage", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvm + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.DisableStorage = bool(v != 0) + case 8: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Debug", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvm + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.Debug = bool(v != 0) + case 9: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Limit", wireType) + } + m.Limit = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvm + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Limit |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 10: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Overrides", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvm + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthEvm + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthEvm + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Overrides == nil { + m.Overrides = &ChainConfig{} + } + if err := m.Overrides.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 11: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field EnableMemory", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvm + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.EnableMemory = bool(v != 0) + case 12: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field EnableReturnData", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowEvm + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.EnableReturnData = bool(v != 0) + default: + iNdEx = preIndex + skippy, err := skipEvm(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthEvm + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipEvm(dAtA []byte) (n int, err error) { + l := len(dAtA) + iNdEx := 0 + depth := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowEvm + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowEvm + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if dAtA[iNdEx-1] < 0x80 { + break + } + } + case 1: + iNdEx += 8 + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowEvm + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if length < 0 { + return 0, ErrInvalidLengthEvm + } + iNdEx += length + case 3: + depth++ + case 4: + if depth == 0 { + return 0, ErrUnexpectedEndOfGroupEvm + } + depth-- + case 5: + iNdEx += 4 + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + if iNdEx < 0 { + return 0, ErrInvalidLengthEvm + } + if depth == 0 { + return iNdEx, nil + } + } + return 0, io.ErrUnexpectedEOF +} + +var ( + ErrInvalidLengthEvm = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowEvm = fmt.Errorf("proto: integer overflow") + ErrUnexpectedEndOfGroupEvm = fmt.Errorf("proto: unexpected end of group") +) diff --git a/ethermint/x/evm/types/key.go b/ethermint/x/evm/types/key.go new file mode 100644 index 0000000..ade14eb --- /dev/null +++ b/ethermint/x/evm/types/key.go @@ -0,0 +1,60 @@ +package types + +import ( + "github.com/ethereum/go-ethereum/common" +) + +const ( + // ModuleName string name of module + ModuleName = "evm" + + // StoreKey key for ethereum storage data, account code (StateDB) or block + // related data for Web3. + // The EVM module should use a prefix store. + StoreKey = ModuleName + + // TransientKey is the key to access the EVM transient store, that is reset + // during the Commit phase. + TransientKey = "transient_" + ModuleName + + // RouterKey uses module name for routing + RouterKey = ModuleName +) + +// prefix bytes for the EVM persistent store +const ( + prefixCode = iota + 1 + prefixStorage +) + +// prefix bytes for the EVM transient store +const ( + prefixTransientBloom = iota + 1 + prefixTransientTxIndex + prefixTransientLogSize + prefixTransientGasUsed +) + +// KVStore key prefixes +var ( + KeyPrefixCode = []byte{prefixCode} + KeyPrefixStorage = []byte{prefixStorage} +) + +// Transient Store key prefixes +var ( + KeyPrefixTransientBloom = []byte{prefixTransientBloom} + KeyPrefixTransientTxIndex = []byte{prefixTransientTxIndex} + KeyPrefixTransientLogSize = []byte{prefixTransientLogSize} + KeyPrefixTransientGasUsed = []byte{prefixTransientGasUsed} +) + +// AddressStoragePrefix returns a prefix to iterate over a given account storage. +func AddressStoragePrefix(address common.Address) []byte { + return append(KeyPrefixStorage, address.Bytes()...) +} + +// StateKey defines the full key under which an account state is stored. +func StateKey(address common.Address, key []byte) []byte { + return append(AddressStoragePrefix(address), key...) +} diff --git a/ethermint/x/evm/types/legacy_tx.go b/ethermint/x/evm/types/legacy_tx.go new file mode 100644 index 0000000..8946613 --- /dev/null +++ b/ethermint/x/evm/types/legacy_tx.go @@ -0,0 +1,212 @@ +package types + +import ( + "math/big" + + sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" + "github.com/ethereum/go-ethereum/common" + ethtypes "github.com/ethereum/go-ethereum/core/types" + "github.com/irisnet/core-sdk-go/ethermint/types" +) + +func newLegacyTx(tx *ethtypes.Transaction) (*LegacyTx, error) { + txData := &LegacyTx{ + Nonce: tx.Nonce(), + Data: tx.Data(), + GasLimit: tx.Gas(), + } + + v, r, s := tx.RawSignatureValues() + if to := tx.To(); to != nil { + txData.To = to.Hex() + } + + if tx.Value() != nil { + amountInt, err := SafeNewIntFromBigInt(tx.Value()) + if err != nil { + return nil, err + } + txData.Amount = &amountInt + } + + if tx.GasPrice() != nil { + gasPriceInt, err := SafeNewIntFromBigInt(tx.GasPrice()) + if err != nil { + return nil, err + } + txData.GasPrice = &gasPriceInt + } + + txData.SetSignatureValues(tx.ChainId(), v, r, s) + return txData, nil +} + +// TxType returns the tx type +func (tx *LegacyTx) TxType() uint8 { + return ethtypes.LegacyTxType +} + +// Copy returns an instance with the same field values +func (tx *LegacyTx) Copy() TxData { + return &LegacyTx{ + Nonce: tx.Nonce, + GasPrice: tx.GasPrice, + GasLimit: tx.GasLimit, + To: tx.To, + Amount: tx.Amount, + Data: common.CopyBytes(tx.Data), + V: common.CopyBytes(tx.V), + R: common.CopyBytes(tx.R), + S: common.CopyBytes(tx.S), + } +} + +// GetChainID returns the chain id field from the derived signature values +func (tx *LegacyTx) GetChainID() *big.Int { + v, _, _ := tx.GetRawSignatureValues() + return DeriveChainID(v) +} + +// GetAccessList returns nil +func (tx *LegacyTx) GetAccessList() ethtypes.AccessList { + return nil +} + +// GetData returns the a copy of the input data bytes. +func (tx *LegacyTx) GetData() []byte { + return common.CopyBytes(tx.Data) +} + +// GetGas returns the gas limit. +func (tx *LegacyTx) GetGas() uint64 { + return tx.GasLimit +} + +// GetGasPrice returns the gas price field. +func (tx *LegacyTx) GetGasPrice() *big.Int { + if tx.GasPrice == nil { + return nil + } + return tx.GasPrice.BigInt() +} + +// GetGasTipCap returns the gas price field. +func (tx *LegacyTx) GetGasTipCap() *big.Int { + return tx.GetGasPrice() +} + +// GetGasFeeCap returns the gas price field. +func (tx *LegacyTx) GetGasFeeCap() *big.Int { + return tx.GetGasPrice() +} + +// GetValue returns the tx amount. +func (tx *LegacyTx) GetValue() *big.Int { + if tx.Amount == nil { + return nil + } + return tx.Amount.BigInt() +} + +// GetNonce returns the account sequence for the transaction. +func (tx *LegacyTx) GetNonce() uint64 { return tx.Nonce } + +// GetTo returns the pointer to the recipient address. +func (tx *LegacyTx) GetTo() *common.Address { + if tx.To == "" { + return nil + } + to := common.HexToAddress(tx.To) + return &to +} + +// AsEthereumData returns an AccessListTx transaction tx from the proto-formatted +// TxData defined on the Cosmos EVM. +func (tx *LegacyTx) AsEthereumData() ethtypes.TxData { + v, r, s := tx.GetRawSignatureValues() + return ðtypes.LegacyTx{ + Nonce: tx.GetNonce(), + GasPrice: tx.GetGasPrice(), + Gas: tx.GetGas(), + To: tx.GetTo(), + Value: tx.GetValue(), + Data: tx.GetData(), + V: v, + R: r, + S: s, + } +} + +// GetRawSignatureValues returns the V, R, S signature values of the transaction. +// The return values should not be modified by the caller. +func (tx *LegacyTx) GetRawSignatureValues() (v, r, s *big.Int) { + return rawSignatureValues(tx.V, tx.R, tx.S) +} + +// SetSignatureValues sets the signature values to the transaction. +func (tx *LegacyTx) SetSignatureValues(_, v, r, s *big.Int) { + if v != nil { + tx.V = v.Bytes() + } + if r != nil { + tx.R = r.Bytes() + } + if s != nil { + tx.S = s.Bytes() + } +} + +// Validate performs a stateless validation of the tx fields. +func (tx LegacyTx) Validate() error { + gasPrice := tx.GetGasPrice() + if gasPrice == nil { + return sdkerrors.Wrap(ErrInvalidGasPrice, "gas price cannot be nil") + } + + if gasPrice.Sign() == -1 { + return sdkerrors.Wrapf(ErrInvalidGasPrice, "gas price cannot be negative %s", gasPrice) + } + if !IsValidInt256(gasPrice) { + return sdkerrors.Wrap(ErrInvalidGasPrice, "out of bound") + } + if !IsValidInt256(tx.Fee()) { + return sdkerrors.Wrap(ErrInvalidGasFee, "out of bound") + } + + amount := tx.GetValue() + // Amount can be 0 + if amount != nil && amount.Sign() == -1 { + return sdkerrors.Wrapf(ErrInvalidAmount, "amount cannot be negative %s", amount) + } + if !IsValidInt256(amount) { + return sdkerrors.Wrap(ErrInvalidAmount, "out of bound") + } + + if tx.To != "" { + if err := types.ValidateAddress(tx.To); err != nil { + return sdkerrors.Wrap(err, "invalid to address") + } + } + + return nil +} + +// Fee returns gasprice * gaslimit. +func (tx LegacyTx) Fee() *big.Int { + return fee(tx.GetGasPrice(), tx.GetGas()) +} + +// Cost returns amount + gasprice * gaslimit. +func (tx LegacyTx) Cost() *big.Int { + return cost(tx.Fee(), tx.GetValue()) +} + +// EffectiveFee is the same as Fee for LegacyTx +func (tx LegacyTx) EffectiveFee(baseFee *big.Int) *big.Int { + return tx.Fee() +} + +// EffectiveCost is the same as Cost for LegacyTx +func (tx LegacyTx) EffectiveCost(baseFee *big.Int) *big.Int { + return tx.Cost() +} diff --git a/ethermint/x/evm/types/msg.go b/ethermint/x/evm/types/msg.go new file mode 100644 index 0000000..9ebc898 --- /dev/null +++ b/ethermint/x/evm/types/msg.go @@ -0,0 +1,315 @@ +package types + +import ( + "errors" + "math/big" + + sdkcodectypes "github.com/irisnet/core-sdk-go/common/codec/types" + sdktypes "github.com/irisnet/core-sdk-go/types" + sdktxtypes "github.com/irisnet/core-sdk-go/types/tx" + + sdk "github.com/cosmos/cosmos-sdk/types" + sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" + "github.com/irisnet/core-sdk-go/ethermint/types" + + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core" + ethtypes "github.com/ethereum/go-ethereum/core/types" +) + +var ( + _ sdktypes.Msg = &MsgEthereumTx{} + _ sdktypes.Tx = &MsgEthereumTx{} + //_ ante.GasTx = &MsgEthereumTx{} + + //_ codectypes.UnpackInterfacesMessage = MsgEthereumTx{} +) + +// message type and route constants +const ( + // TypeMsgEthereumTx defines the type string of an Ethereum transaction + TypeMsgEthereumTx = "ethereum_tx" +) + +// NewTx returns a reference to a new Ethereum transaction message. +func NewTx( + chainID *big.Int, nonce uint64, to *common.Address, amount *big.Int, + gasLimit uint64, gasPrice, gasFeeCap, gasTipCap *big.Int, input []byte, accesses *ethtypes.AccessList, +) *MsgEthereumTx { + return newMsgEthereumTx(chainID, nonce, to, amount, gasLimit, gasPrice, gasFeeCap, gasTipCap, input, accesses) +} + +func newMsgEthereumTx( + chainID *big.Int, nonce uint64, to *common.Address, amount *big.Int, + gasLimit uint64, gasPrice, gasFeeCap, gasTipCap *big.Int, input []byte, accesses *ethtypes.AccessList, +) *MsgEthereumTx { + var ( + cid, amt, gp *sdk.Int + toAddr string + txData TxData + ) + + if to != nil { + toAddr = to.Hex() + } + + if amount != nil { + amountInt := sdk.NewIntFromBigInt(amount) + amt = &amountInt + } + + if chainID != nil { + chainIDInt := sdk.NewIntFromBigInt(chainID) + cid = &chainIDInt + } + + if gasPrice != nil { + gasPriceInt := sdk.NewIntFromBigInt(gasPrice) + gp = &gasPriceInt + } + + switch { + case accesses == nil: + txData = &LegacyTx{ + Nonce: nonce, + To: toAddr, + Amount: amt, + GasLimit: gasLimit, + GasPrice: gp, + Data: input, + } + case accesses != nil && gasFeeCap != nil && gasTipCap != nil: + gtc := sdk.NewIntFromBigInt(gasTipCap) + gfc := sdk.NewIntFromBigInt(gasFeeCap) + + txData = &DynamicFeeTx{ + ChainID: cid, + Nonce: nonce, + To: toAddr, + Amount: amt, + GasLimit: gasLimit, + GasTipCap: >c, + GasFeeCap: &gfc, + Data: input, + Accesses: NewAccessList(accesses), + } + case accesses != nil: + txData = &AccessListTx{ + ChainID: cid, + Nonce: nonce, + To: toAddr, + Amount: amt, + GasLimit: gasLimit, + GasPrice: gp, + Data: input, + Accesses: NewAccessList(accesses), + } + default: + } + + dataAny, err := PackTxData(txData) + if err != nil { + panic(err) + } + + return &MsgEthereumTx{Data: dataAny} +} + +// fromEthereumTx populates the message fields from the given ethereum transaction +func (msg *MsgEthereumTx) FromEthereumTx(tx *ethtypes.Transaction) error { + txData, err := NewTxDataFromTx(tx) + if err != nil { + return err + } + + anyTxData, err := PackTxData(txData) + if err != nil { + return err + } + + msg.Data = anyTxData + msg.Size_ = float64(tx.Size()) + msg.Hash = tx.Hash().Hex() + return nil +} + +// Route returns the route value of an MsgEthereumTx. +func (msg MsgEthereumTx) Route() string { return RouterKey } + +// Type returns the type value of an MsgEthereumTx. +func (msg MsgEthereumTx) Type() string { return TypeMsgEthereumTx } + +// ValidateBasic implements the sdktypes.Msg interface. It performs basic validation +// checks of a Transaction. If returns an error if validation fails. +func (msg MsgEthereumTx) ValidateBasic() error { + if msg.From != "" { + if err := types.ValidateAddress(msg.From); err != nil { + return sdkerrors.Wrap(err, "invalid from address") + } + } + + txData, err := UnpackTxData(msg.Data) + if err != nil { + return sdkerrors.Wrap(err, "failed to unpack tx data") + } + + return txData.Validate() +} + +// GetMsgs returns a single MsgEthereumTx as an sdktypes.Msg. +func (msg *MsgEthereumTx) GetMsgs() []sdktypes.Msg { + return []sdktypes.Msg{msg} +} + +// GetSigners returns the expected signers for an Ethereum transaction message. +// For such a message, there should exist only a single 'signer'. +// +// NOTE: This method panics if 'Sign' hasn't been called first. +func (msg *MsgEthereumTx) GetSigners() []sdktypes.AccAddress { + data, err := UnpackTxData(msg.Data) + if err != nil { + panic(err) + } + + sender, err := msg.GetSender(data.GetChainID()) + if err != nil { + panic(err) + } + + signer := sdktypes.AccAddress(sender.Bytes()) + return []sdktypes.AccAddress{signer} +} + +// GetSignBytes returns the Amino bytes of an Ethereum transaction message used +// for signing. +// +// NOTE: This method cannot be used as a chain ID is needed to create valid bytes +// to sign over. Use 'RLPSignBytes' instead. +func (msg MsgEthereumTx) GetSignBytes() []byte { + panic("must use 'RLPSignBytes' with a chain ID to get the valid bytes to sign") +} + +// GetGas implements the GasTx interface. It returns the GasLimit of the transaction. +func (msg MsgEthereumTx) GetGas() uint64 { + txData, err := UnpackTxData(msg.Data) + if err != nil { + return 0 + } + return txData.GetGas() +} + +// GetFee returns the fee for non dynamic fee tx +func (msg MsgEthereumTx) GetFee() *big.Int { + txData, err := UnpackTxData(msg.Data) + if err != nil { + return nil + } + return txData.Fee() +} + +// GetEffectiveFee returns the fee for dynamic fee tx +func (msg MsgEthereumTx) GetEffectiveFee(baseFee *big.Int) *big.Int { + txData, err := UnpackTxData(msg.Data) + if err != nil { + return nil + } + return txData.EffectiveFee(baseFee) +} + +// GetFrom loads the ethereum sender address from the sigcache and returns an +// sdktypes.AccAddress from its bytes +func (msg *MsgEthereumTx) GetFrom() sdktypes.AccAddress { + if msg.From == "" { + return nil + } + + return common.HexToAddress(msg.From).Bytes() +} + +// GetFeePayer loads the ethereum sender address from the sigcache and returns an +// sdktypes.AccAddress from its bytes +func (msg *MsgEthereumTx) GetFeePayer() sdktypes.AccAddress { + if msg.FeePayer == "" { + return nil + } + + return common.HexToAddress(msg.FeePayer).Bytes() +} + +func (msg *MsgEthereumTx) SetFeePayer(feePayer string) { + msg.FeePayer = feePayer +} + +// AsTransaction creates an Ethereum Transaction type from the msg fields +func (msg MsgEthereumTx) AsTransaction() *ethtypes.Transaction { + txData, err := UnpackTxData(msg.Data) + if err != nil { + return nil + } + + return ethtypes.NewTx(txData.AsEthereumData()) +} + +// AsMessage creates an Ethereum core.Message from the msg fields +func (msg MsgEthereumTx) AsMessage(signer ethtypes.Signer, baseFee *big.Int) (core.Message, error) { + return msg.AsTransaction().AsMessage(signer, baseFee) +} + +// GetSender extracts the sender address from the signature values using the latest signer for the given chainID. +func (msg *MsgEthereumTx) GetSender(chainID *big.Int) (common.Address, error) { + + signer := ethtypes.LatestSignerForChainID(chainID) + from, err := signer.Sender(msg.AsTransaction()) + if err != nil { + return common.Address{}, err + } + + msg.From = from.Hex() + return from, nil +} + +//// UnpackInterfaces implements UnpackInterfacesMesssage.UnpackInterfaces +//func (msg MsgEthereumTx) UnpackInterfaces(unpacker codectypes.AnyUnpacker) error { +// return unpacker.UnpackAny(msg.Data, new(TxData)) +//} + +// UnmarshalBinary decodes the canonical encoding of transactions. +func (msg *MsgEthereumTx) UnmarshalBinary(b []byte) error { + tx := ðtypes.Transaction{} + if err := tx.UnmarshalBinary(b); err != nil { + return err + } + return msg.FromEthereumTx(tx) +} + +// BuildTx builds the canonical cosmos tx from ethereum msg +func (msg *MsgEthereumTx) BuildTx(b sdktypes.TxBuilder, evmDenom string) (sdktypes.Tx, error) { + builder, ok := b.(sdktxtypes.ExtensionOptionsTxBuilder) + if !ok { + return nil, errors.New("unsupported builder") + } + option, err := sdkcodectypes.NewAnyWithValue(&ExtensionOptionsEthereumTx{}) + if err != nil { + return nil, err + } + + txData, err := UnpackTxData(msg.Data) + if err != nil { + return nil, err + } + fees := make(sdktypes.Coins, 0) + feeAmt := sdktypes.NewIntFromBigInt(txData.Fee()) + if feeAmt.Sign() > 0 { + fees = append(fees, sdktypes.NewCoin(evmDenom, feeAmt)) + } + + builder.SetExtensionOptions(option) + err = builder.SetMsgs(msg) + if err != nil { + return nil, err + } + builder.SetFeeAmount(fees) + builder.SetGasLimit(msg.GetGas()) + tx := builder.GetTx() + return tx, nil +} diff --git a/ethermint/x/evm/types/query.pb.go b/ethermint/x/evm/types/query.pb.go new file mode 100644 index 0000000..3f92bb1 --- /dev/null +++ b/ethermint/x/evm/types/query.pb.go @@ -0,0 +1,5337 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: ethermint/evm/v1/query.proto + +package types + +import ( + context "context" + fmt "fmt" + grpc1 "github.com/cosmos/gogoproto/grpc" + proto "github.com/cosmos/gogoproto/proto" + github_com_cosmos_gogoproto_types "github.com/cosmos/gogoproto/types" + _ "github.com/gogo/protobuf/gogoproto" + query "github.com/irisnet/core-sdk-go/types/query" + _ "google.golang.org/genproto/googleapis/api/annotations" + grpc "google.golang.org/grpc" + codes "google.golang.org/grpc/codes" + status "google.golang.org/grpc/status" + _ "google.golang.org/protobuf/types/known/timestamppb" + io "io" + math "math" + math_bits "math/bits" + time "time" +) + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf +var _ = time.Kitchen + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the proto package it is being compiled against. +// A compilation error at this line likely means your copy of the +// proto package needs to be updated. +const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package + +// QueryAccountRequest is the request type for the Query/Account RPC method. +type QueryAccountRequest struct { + // address is the ethereum hex address to query the account for. + Address string `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"` +} + +func (m *QueryAccountRequest) Reset() { *m = QueryAccountRequest{} } +func (m *QueryAccountRequest) String() string { return proto.CompactTextString(m) } +func (*QueryAccountRequest) ProtoMessage() {} +func (*QueryAccountRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_e15a877459347994, []int{0} +} +func (m *QueryAccountRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryAccountRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryAccountRequest.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *QueryAccountRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryAccountRequest.Merge(m, src) +} +func (m *QueryAccountRequest) XXX_Size() int { + return m.Size() +} +func (m *QueryAccountRequest) XXX_DiscardUnknown() { + xxx_messageInfo_QueryAccountRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryAccountRequest proto.InternalMessageInfo + +// QueryAccountResponse is the response type for the Query/Account RPC method. +type QueryAccountResponse struct { + // balance is the balance of the EVM denomination. + Balance string `protobuf:"bytes,1,opt,name=balance,proto3" json:"balance,omitempty"` + // code hash is the hex-formatted code bytes from the EOA. + CodeHash string `protobuf:"bytes,2,opt,name=code_hash,json=codeHash,proto3" json:"code_hash,omitempty"` + // nonce is the account's sequence number. + Nonce uint64 `protobuf:"varint,3,opt,name=nonce,proto3" json:"nonce,omitempty"` +} + +func (m *QueryAccountResponse) Reset() { *m = QueryAccountResponse{} } +func (m *QueryAccountResponse) String() string { return proto.CompactTextString(m) } +func (*QueryAccountResponse) ProtoMessage() {} +func (*QueryAccountResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_e15a877459347994, []int{1} +} +func (m *QueryAccountResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryAccountResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryAccountResponse.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *QueryAccountResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryAccountResponse.Merge(m, src) +} +func (m *QueryAccountResponse) XXX_Size() int { + return m.Size() +} +func (m *QueryAccountResponse) XXX_DiscardUnknown() { + xxx_messageInfo_QueryAccountResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryAccountResponse proto.InternalMessageInfo + +func (m *QueryAccountResponse) GetBalance() string { + if m != nil { + return m.Balance + } + return "" +} + +func (m *QueryAccountResponse) GetCodeHash() string { + if m != nil { + return m.CodeHash + } + return "" +} + +func (m *QueryAccountResponse) GetNonce() uint64 { + if m != nil { + return m.Nonce + } + return 0 +} + +// QueryCosmosAccountRequest is the request type for the Query/CosmosAccount RPC +// method. +type QueryCosmosAccountRequest struct { + // address is the ethereum hex address to query the account for. + Address string `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"` +} + +func (m *QueryCosmosAccountRequest) Reset() { *m = QueryCosmosAccountRequest{} } +func (m *QueryCosmosAccountRequest) String() string { return proto.CompactTextString(m) } +func (*QueryCosmosAccountRequest) ProtoMessage() {} +func (*QueryCosmosAccountRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_e15a877459347994, []int{2} +} +func (m *QueryCosmosAccountRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryCosmosAccountRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryCosmosAccountRequest.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *QueryCosmosAccountRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryCosmosAccountRequest.Merge(m, src) +} +func (m *QueryCosmosAccountRequest) XXX_Size() int { + return m.Size() +} +func (m *QueryCosmosAccountRequest) XXX_DiscardUnknown() { + xxx_messageInfo_QueryCosmosAccountRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryCosmosAccountRequest proto.InternalMessageInfo + +// QueryCosmosAccountResponse is the response type for the Query/CosmosAccount +// RPC method. +type QueryCosmosAccountResponse struct { + // cosmos_address is the cosmos address of the account. + CosmosAddress string `protobuf:"bytes,1,opt,name=cosmos_address,json=cosmosAddress,proto3" json:"cosmos_address,omitempty"` + // sequence is the account's sequence number. + Sequence uint64 `protobuf:"varint,2,opt,name=sequence,proto3" json:"sequence,omitempty"` + // account_number is the account numbert + AccountNumber uint64 `protobuf:"varint,3,opt,name=account_number,json=accountNumber,proto3" json:"account_number,omitempty"` +} + +func (m *QueryCosmosAccountResponse) Reset() { *m = QueryCosmosAccountResponse{} } +func (m *QueryCosmosAccountResponse) String() string { return proto.CompactTextString(m) } +func (*QueryCosmosAccountResponse) ProtoMessage() {} +func (*QueryCosmosAccountResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_e15a877459347994, []int{3} +} +func (m *QueryCosmosAccountResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryCosmosAccountResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryCosmosAccountResponse.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *QueryCosmosAccountResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryCosmosAccountResponse.Merge(m, src) +} +func (m *QueryCosmosAccountResponse) XXX_Size() int { + return m.Size() +} +func (m *QueryCosmosAccountResponse) XXX_DiscardUnknown() { + xxx_messageInfo_QueryCosmosAccountResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryCosmosAccountResponse proto.InternalMessageInfo + +func (m *QueryCosmosAccountResponse) GetCosmosAddress() string { + if m != nil { + return m.CosmosAddress + } + return "" +} + +func (m *QueryCosmosAccountResponse) GetSequence() uint64 { + if m != nil { + return m.Sequence + } + return 0 +} + +func (m *QueryCosmosAccountResponse) GetAccountNumber() uint64 { + if m != nil { + return m.AccountNumber + } + return 0 +} + +// QueryValidatorAccountRequest is the request type for the +// Query/ValidatorAccount RPC method. +type QueryValidatorAccountRequest struct { + // cons_address is the validator cons address to query the account for. + ConsAddress string `protobuf:"bytes,1,opt,name=cons_address,json=consAddress,proto3" json:"cons_address,omitempty"` +} + +func (m *QueryValidatorAccountRequest) Reset() { *m = QueryValidatorAccountRequest{} } +func (m *QueryValidatorAccountRequest) String() string { return proto.CompactTextString(m) } +func (*QueryValidatorAccountRequest) ProtoMessage() {} +func (*QueryValidatorAccountRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_e15a877459347994, []int{4} +} +func (m *QueryValidatorAccountRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryValidatorAccountRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryValidatorAccountRequest.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *QueryValidatorAccountRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryValidatorAccountRequest.Merge(m, src) +} +func (m *QueryValidatorAccountRequest) XXX_Size() int { + return m.Size() +} +func (m *QueryValidatorAccountRequest) XXX_DiscardUnknown() { + xxx_messageInfo_QueryValidatorAccountRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryValidatorAccountRequest proto.InternalMessageInfo + +// QueryValidatorAccountResponse is the response type for the +// Query/ValidatorAccount RPC method. +type QueryValidatorAccountResponse struct { + // account_address is the cosmos address of the account in bech32 format. + AccountAddress string `protobuf:"bytes,1,opt,name=account_address,json=accountAddress,proto3" json:"account_address,omitempty"` + // sequence is the account's sequence number. + Sequence uint64 `protobuf:"varint,2,opt,name=sequence,proto3" json:"sequence,omitempty"` + // account_number is the account number + AccountNumber uint64 `protobuf:"varint,3,opt,name=account_number,json=accountNumber,proto3" json:"account_number,omitempty"` +} + +func (m *QueryValidatorAccountResponse) Reset() { *m = QueryValidatorAccountResponse{} } +func (m *QueryValidatorAccountResponse) String() string { return proto.CompactTextString(m) } +func (*QueryValidatorAccountResponse) ProtoMessage() {} +func (*QueryValidatorAccountResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_e15a877459347994, []int{5} +} +func (m *QueryValidatorAccountResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryValidatorAccountResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryValidatorAccountResponse.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *QueryValidatorAccountResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryValidatorAccountResponse.Merge(m, src) +} +func (m *QueryValidatorAccountResponse) XXX_Size() int { + return m.Size() +} +func (m *QueryValidatorAccountResponse) XXX_DiscardUnknown() { + xxx_messageInfo_QueryValidatorAccountResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryValidatorAccountResponse proto.InternalMessageInfo + +func (m *QueryValidatorAccountResponse) GetAccountAddress() string { + if m != nil { + return m.AccountAddress + } + return "" +} + +func (m *QueryValidatorAccountResponse) GetSequence() uint64 { + if m != nil { + return m.Sequence + } + return 0 +} + +func (m *QueryValidatorAccountResponse) GetAccountNumber() uint64 { + if m != nil { + return m.AccountNumber + } + return 0 +} + +// QueryBalanceRequest is the request type for the Query/Balance RPC method. +type QueryBalanceRequest struct { + // address is the ethereum hex address to query the balance for. + Address string `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"` +} + +func (m *QueryBalanceRequest) Reset() { *m = QueryBalanceRequest{} } +func (m *QueryBalanceRequest) String() string { return proto.CompactTextString(m) } +func (*QueryBalanceRequest) ProtoMessage() {} +func (*QueryBalanceRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_e15a877459347994, []int{6} +} +func (m *QueryBalanceRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryBalanceRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryBalanceRequest.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *QueryBalanceRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryBalanceRequest.Merge(m, src) +} +func (m *QueryBalanceRequest) XXX_Size() int { + return m.Size() +} +func (m *QueryBalanceRequest) XXX_DiscardUnknown() { + xxx_messageInfo_QueryBalanceRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryBalanceRequest proto.InternalMessageInfo + +// QueryBalanceResponse is the response type for the Query/Balance RPC method. +type QueryBalanceResponse struct { + // balance is the balance of the EVM denomination. + Balance string `protobuf:"bytes,1,opt,name=balance,proto3" json:"balance,omitempty"` +} + +func (m *QueryBalanceResponse) Reset() { *m = QueryBalanceResponse{} } +func (m *QueryBalanceResponse) String() string { return proto.CompactTextString(m) } +func (*QueryBalanceResponse) ProtoMessage() {} +func (*QueryBalanceResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_e15a877459347994, []int{7} +} +func (m *QueryBalanceResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryBalanceResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryBalanceResponse.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *QueryBalanceResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryBalanceResponse.Merge(m, src) +} +func (m *QueryBalanceResponse) XXX_Size() int { + return m.Size() +} +func (m *QueryBalanceResponse) XXX_DiscardUnknown() { + xxx_messageInfo_QueryBalanceResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryBalanceResponse proto.InternalMessageInfo + +func (m *QueryBalanceResponse) GetBalance() string { + if m != nil { + return m.Balance + } + return "" +} + +// QueryStorageRequest is the request type for the Query/Storage RPC method. +type QueryStorageRequest struct { + /// address is the ethereum hex address to query the storage state for. + Address string `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"` + // key defines the key of the storage state + Key string `protobuf:"bytes,2,opt,name=key,proto3" json:"key,omitempty"` +} + +func (m *QueryStorageRequest) Reset() { *m = QueryStorageRequest{} } +func (m *QueryStorageRequest) String() string { return proto.CompactTextString(m) } +func (*QueryStorageRequest) ProtoMessage() {} +func (*QueryStorageRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_e15a877459347994, []int{8} +} +func (m *QueryStorageRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryStorageRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryStorageRequest.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *QueryStorageRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryStorageRequest.Merge(m, src) +} +func (m *QueryStorageRequest) XXX_Size() int { + return m.Size() +} +func (m *QueryStorageRequest) XXX_DiscardUnknown() { + xxx_messageInfo_QueryStorageRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryStorageRequest proto.InternalMessageInfo + +// QueryStorageResponse is the response type for the Query/Storage RPC +// method. +type QueryStorageResponse struct { + // key defines the storage state value hash associated with the given key. + Value string `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"` +} + +func (m *QueryStorageResponse) Reset() { *m = QueryStorageResponse{} } +func (m *QueryStorageResponse) String() string { return proto.CompactTextString(m) } +func (*QueryStorageResponse) ProtoMessage() {} +func (*QueryStorageResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_e15a877459347994, []int{9} +} +func (m *QueryStorageResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryStorageResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryStorageResponse.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *QueryStorageResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryStorageResponse.Merge(m, src) +} +func (m *QueryStorageResponse) XXX_Size() int { + return m.Size() +} +func (m *QueryStorageResponse) XXX_DiscardUnknown() { + xxx_messageInfo_QueryStorageResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryStorageResponse proto.InternalMessageInfo + +func (m *QueryStorageResponse) GetValue() string { + if m != nil { + return m.Value + } + return "" +} + +// QueryCodeRequest is the request type for the Query/Code RPC method. +type QueryCodeRequest struct { + // address is the ethereum hex address to query the code for. + Address string `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"` +} + +func (m *QueryCodeRequest) Reset() { *m = QueryCodeRequest{} } +func (m *QueryCodeRequest) String() string { return proto.CompactTextString(m) } +func (*QueryCodeRequest) ProtoMessage() {} +func (*QueryCodeRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_e15a877459347994, []int{10} +} +func (m *QueryCodeRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryCodeRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryCodeRequest.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *QueryCodeRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryCodeRequest.Merge(m, src) +} +func (m *QueryCodeRequest) XXX_Size() int { + return m.Size() +} +func (m *QueryCodeRequest) XXX_DiscardUnknown() { + xxx_messageInfo_QueryCodeRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryCodeRequest proto.InternalMessageInfo + +// QueryCodeResponse is the response type for the Query/Code RPC +// method. +type QueryCodeResponse struct { + // code represents the code bytes from an ethereum address. + Code []byte `protobuf:"bytes,1,opt,name=code,proto3" json:"code,omitempty"` +} + +func (m *QueryCodeResponse) Reset() { *m = QueryCodeResponse{} } +func (m *QueryCodeResponse) String() string { return proto.CompactTextString(m) } +func (*QueryCodeResponse) ProtoMessage() {} +func (*QueryCodeResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_e15a877459347994, []int{11} +} +func (m *QueryCodeResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryCodeResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryCodeResponse.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *QueryCodeResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryCodeResponse.Merge(m, src) +} +func (m *QueryCodeResponse) XXX_Size() int { + return m.Size() +} +func (m *QueryCodeResponse) XXX_DiscardUnknown() { + xxx_messageInfo_QueryCodeResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryCodeResponse proto.InternalMessageInfo + +func (m *QueryCodeResponse) GetCode() []byte { + if m != nil { + return m.Code + } + return nil +} + +// QueryTxLogsRequest is the request type for the Query/TxLogs RPC method. +type QueryTxLogsRequest struct { + // hash is the ethereum transaction hex hash to query the logs for. + Hash string `protobuf:"bytes,1,opt,name=hash,proto3" json:"hash,omitempty"` + // pagination defines an optional pagination for the request. + Pagination *query.PageRequest `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"` +} + +func (m *QueryTxLogsRequest) Reset() { *m = QueryTxLogsRequest{} } +func (m *QueryTxLogsRequest) String() string { return proto.CompactTextString(m) } +func (*QueryTxLogsRequest) ProtoMessage() {} +func (*QueryTxLogsRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_e15a877459347994, []int{12} +} +func (m *QueryTxLogsRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryTxLogsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryTxLogsRequest.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *QueryTxLogsRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryTxLogsRequest.Merge(m, src) +} +func (m *QueryTxLogsRequest) XXX_Size() int { + return m.Size() +} +func (m *QueryTxLogsRequest) XXX_DiscardUnknown() { + xxx_messageInfo_QueryTxLogsRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryTxLogsRequest proto.InternalMessageInfo + +// QueryTxLogs is the response type for the Query/TxLogs RPC method. +type QueryTxLogsResponse struct { + // logs represents the ethereum logs generated from the given transaction. + Logs []*Log `protobuf:"bytes,1,rep,name=logs,proto3" json:"logs,omitempty"` + // pagination defines the pagination in the response. + Pagination *query.PageResponse `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"` +} + +func (m *QueryTxLogsResponse) Reset() { *m = QueryTxLogsResponse{} } +func (m *QueryTxLogsResponse) String() string { return proto.CompactTextString(m) } +func (*QueryTxLogsResponse) ProtoMessage() {} +func (*QueryTxLogsResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_e15a877459347994, []int{13} +} +func (m *QueryTxLogsResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryTxLogsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryTxLogsResponse.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *QueryTxLogsResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryTxLogsResponse.Merge(m, src) +} +func (m *QueryTxLogsResponse) XXX_Size() int { + return m.Size() +} +func (m *QueryTxLogsResponse) XXX_DiscardUnknown() { + xxx_messageInfo_QueryTxLogsResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryTxLogsResponse proto.InternalMessageInfo + +func (m *QueryTxLogsResponse) GetLogs() []*Log { + if m != nil { + return m.Logs + } + return nil +} + +func (m *QueryTxLogsResponse) GetPagination() *query.PageResponse { + if m != nil { + return m.Pagination + } + return nil +} + +// QueryParamsRequest defines the request type for querying x/evm parameters. +type QueryParamsRequest struct { +} + +func (m *QueryParamsRequest) Reset() { *m = QueryParamsRequest{} } +func (m *QueryParamsRequest) String() string { return proto.CompactTextString(m) } +func (*QueryParamsRequest) ProtoMessage() {} +func (*QueryParamsRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_e15a877459347994, []int{14} +} +func (m *QueryParamsRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryParamsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryParamsRequest.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *QueryParamsRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryParamsRequest.Merge(m, src) +} +func (m *QueryParamsRequest) XXX_Size() int { + return m.Size() +} +func (m *QueryParamsRequest) XXX_DiscardUnknown() { + xxx_messageInfo_QueryParamsRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryParamsRequest proto.InternalMessageInfo + +// QueryParamsResponse defines the response type for querying x/evm parameters. +type QueryParamsResponse struct { + // params define the evm module parameters. + Params Params `protobuf:"bytes,1,opt,name=params,proto3" json:"params"` +} + +func (m *QueryParamsResponse) Reset() { *m = QueryParamsResponse{} } +func (m *QueryParamsResponse) String() string { return proto.CompactTextString(m) } +func (*QueryParamsResponse) ProtoMessage() {} +func (*QueryParamsResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_e15a877459347994, []int{15} +} +func (m *QueryParamsResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryParamsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryParamsResponse.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *QueryParamsResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryParamsResponse.Merge(m, src) +} +func (m *QueryParamsResponse) XXX_Size() int { + return m.Size() +} +func (m *QueryParamsResponse) XXX_DiscardUnknown() { + xxx_messageInfo_QueryParamsResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryParamsResponse proto.InternalMessageInfo + +func (m *QueryParamsResponse) GetParams() Params { + if m != nil { + return m.Params + } + return Params{} +} + +// EthCallRequest defines EthCall request +type EthCallRequest struct { + // same json format as the json rpc api. + Args []byte `protobuf:"bytes,1,opt,name=args,proto3" json:"args,omitempty"` + // the default gas cap to be used + GasCap uint64 `protobuf:"varint,2,opt,name=gas_cap,json=gasCap,proto3" json:"gas_cap,omitempty"` +} + +func (m *EthCallRequest) Reset() { *m = EthCallRequest{} } +func (m *EthCallRequest) String() string { return proto.CompactTextString(m) } +func (*EthCallRequest) ProtoMessage() {} +func (*EthCallRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_e15a877459347994, []int{16} +} +func (m *EthCallRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *EthCallRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_EthCallRequest.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *EthCallRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_EthCallRequest.Merge(m, src) +} +func (m *EthCallRequest) XXX_Size() int { + return m.Size() +} +func (m *EthCallRequest) XXX_DiscardUnknown() { + xxx_messageInfo_EthCallRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_EthCallRequest proto.InternalMessageInfo + +func (m *EthCallRequest) GetArgs() []byte { + if m != nil { + return m.Args + } + return nil +} + +func (m *EthCallRequest) GetGasCap() uint64 { + if m != nil { + return m.GasCap + } + return 0 +} + +// EstimateGasResponse defines EstimateGas response +type EstimateGasResponse struct { + // the estimated gas + Gas uint64 `protobuf:"varint,1,opt,name=gas,proto3" json:"gas,omitempty"` +} + +func (m *EstimateGasResponse) Reset() { *m = EstimateGasResponse{} } +func (m *EstimateGasResponse) String() string { return proto.CompactTextString(m) } +func (*EstimateGasResponse) ProtoMessage() {} +func (*EstimateGasResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_e15a877459347994, []int{17} +} +func (m *EstimateGasResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *EstimateGasResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_EstimateGasResponse.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *EstimateGasResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_EstimateGasResponse.Merge(m, src) +} +func (m *EstimateGasResponse) XXX_Size() int { + return m.Size() +} +func (m *EstimateGasResponse) XXX_DiscardUnknown() { + xxx_messageInfo_EstimateGasResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_EstimateGasResponse proto.InternalMessageInfo + +func (m *EstimateGasResponse) GetGas() uint64 { + if m != nil { + return m.Gas + } + return 0 +} + +// QueryTraceTxRequest defines TraceTx request +type QueryTraceTxRequest struct { + // msgEthereumTx for the requested transaction + Msg *MsgEthereumTx `protobuf:"bytes,1,opt,name=msg,proto3" json:"msg,omitempty"` + // transaction index + TxIndex uint64 `protobuf:"varint,2,opt,name=tx_index,json=txIndex,proto3" json:"tx_index,omitempty"` + // TraceConfig holds extra parameters to trace functions. + TraceConfig *TraceConfig `protobuf:"bytes,3,opt,name=trace_config,json=traceConfig,proto3" json:"trace_config,omitempty"` + // the predecessor transactions included in the same block + // need to be replayed first to get correct context for tracing. + Predecessors []*MsgEthereumTx `protobuf:"bytes,4,rep,name=predecessors,proto3" json:"predecessors,omitempty"` + // block number of requested transaction + BlockNumber int64 `protobuf:"varint,5,opt,name=block_number,json=blockNumber,proto3" json:"block_number,omitempty"` + // block hex hash of requested transaction + BlockHash string `protobuf:"bytes,6,opt,name=block_hash,json=blockHash,proto3" json:"block_hash,omitempty"` + // block time of requested transaction + BlockTime time.Time `protobuf:"bytes,7,opt,name=block_time,json=blockTime,proto3,stdtime" json:"block_time"` +} + +func (m *QueryTraceTxRequest) Reset() { *m = QueryTraceTxRequest{} } +func (m *QueryTraceTxRequest) String() string { return proto.CompactTextString(m) } +func (*QueryTraceTxRequest) ProtoMessage() {} +func (*QueryTraceTxRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_e15a877459347994, []int{18} +} +func (m *QueryTraceTxRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryTraceTxRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryTraceTxRequest.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *QueryTraceTxRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryTraceTxRequest.Merge(m, src) +} +func (m *QueryTraceTxRequest) XXX_Size() int { + return m.Size() +} +func (m *QueryTraceTxRequest) XXX_DiscardUnknown() { + xxx_messageInfo_QueryTraceTxRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryTraceTxRequest proto.InternalMessageInfo + +func (m *QueryTraceTxRequest) GetMsg() *MsgEthereumTx { + if m != nil { + return m.Msg + } + return nil +} + +func (m *QueryTraceTxRequest) GetTxIndex() uint64 { + if m != nil { + return m.TxIndex + } + return 0 +} + +func (m *QueryTraceTxRequest) GetTraceConfig() *TraceConfig { + if m != nil { + return m.TraceConfig + } + return nil +} + +func (m *QueryTraceTxRequest) GetPredecessors() []*MsgEthereumTx { + if m != nil { + return m.Predecessors + } + return nil +} + +func (m *QueryTraceTxRequest) GetBlockNumber() int64 { + if m != nil { + return m.BlockNumber + } + return 0 +} + +func (m *QueryTraceTxRequest) GetBlockHash() string { + if m != nil { + return m.BlockHash + } + return "" +} + +func (m *QueryTraceTxRequest) GetBlockTime() time.Time { + if m != nil { + return m.BlockTime + } + return time.Time{} +} + +// QueryTraceTxResponse defines TraceTx response +type QueryTraceTxResponse struct { + // response serialized in bytes + Data []byte `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"` +} + +func (m *QueryTraceTxResponse) Reset() { *m = QueryTraceTxResponse{} } +func (m *QueryTraceTxResponse) String() string { return proto.CompactTextString(m) } +func (*QueryTraceTxResponse) ProtoMessage() {} +func (*QueryTraceTxResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_e15a877459347994, []int{19} +} +func (m *QueryTraceTxResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryTraceTxResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryTraceTxResponse.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *QueryTraceTxResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryTraceTxResponse.Merge(m, src) +} +func (m *QueryTraceTxResponse) XXX_Size() int { + return m.Size() +} +func (m *QueryTraceTxResponse) XXX_DiscardUnknown() { + xxx_messageInfo_QueryTraceTxResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryTraceTxResponse proto.InternalMessageInfo + +func (m *QueryTraceTxResponse) GetData() []byte { + if m != nil { + return m.Data + } + return nil +} + +// QueryTraceBlockRequest defines TraceTx request +type QueryTraceBlockRequest struct { + // txs messages in the block + Txs []*MsgEthereumTx `protobuf:"bytes,1,rep,name=txs,proto3" json:"txs,omitempty"` + // TraceConfig holds extra parameters to trace functions. + TraceConfig *TraceConfig `protobuf:"bytes,3,opt,name=trace_config,json=traceConfig,proto3" json:"trace_config,omitempty"` + // block number + BlockNumber int64 `protobuf:"varint,5,opt,name=block_number,json=blockNumber,proto3" json:"block_number,omitempty"` + // block hex hash + BlockHash string `protobuf:"bytes,6,opt,name=block_hash,json=blockHash,proto3" json:"block_hash,omitempty"` + // block time + BlockTime time.Time `protobuf:"bytes,7,opt,name=block_time,json=blockTime,proto3,stdtime" json:"block_time"` +} + +func (m *QueryTraceBlockRequest) Reset() { *m = QueryTraceBlockRequest{} } +func (m *QueryTraceBlockRequest) String() string { return proto.CompactTextString(m) } +func (*QueryTraceBlockRequest) ProtoMessage() {} +func (*QueryTraceBlockRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_e15a877459347994, []int{20} +} +func (m *QueryTraceBlockRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryTraceBlockRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryTraceBlockRequest.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *QueryTraceBlockRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryTraceBlockRequest.Merge(m, src) +} +func (m *QueryTraceBlockRequest) XXX_Size() int { + return m.Size() +} +func (m *QueryTraceBlockRequest) XXX_DiscardUnknown() { + xxx_messageInfo_QueryTraceBlockRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryTraceBlockRequest proto.InternalMessageInfo + +func (m *QueryTraceBlockRequest) GetTxs() []*MsgEthereumTx { + if m != nil { + return m.Txs + } + return nil +} + +func (m *QueryTraceBlockRequest) GetTraceConfig() *TraceConfig { + if m != nil { + return m.TraceConfig + } + return nil +} + +func (m *QueryTraceBlockRequest) GetBlockNumber() int64 { + if m != nil { + return m.BlockNumber + } + return 0 +} + +func (m *QueryTraceBlockRequest) GetBlockHash() string { + if m != nil { + return m.BlockHash + } + return "" +} + +func (m *QueryTraceBlockRequest) GetBlockTime() time.Time { + if m != nil { + return m.BlockTime + } + return time.Time{} +} + +// QueryTraceBlockResponse defines TraceBlock response +type QueryTraceBlockResponse struct { + Data []byte `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"` +} + +func (m *QueryTraceBlockResponse) Reset() { *m = QueryTraceBlockResponse{} } +func (m *QueryTraceBlockResponse) String() string { return proto.CompactTextString(m) } +func (*QueryTraceBlockResponse) ProtoMessage() {} +func (*QueryTraceBlockResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_e15a877459347994, []int{21} +} +func (m *QueryTraceBlockResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryTraceBlockResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryTraceBlockResponse.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *QueryTraceBlockResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryTraceBlockResponse.Merge(m, src) +} +func (m *QueryTraceBlockResponse) XXX_Size() int { + return m.Size() +} +func (m *QueryTraceBlockResponse) XXX_DiscardUnknown() { + xxx_messageInfo_QueryTraceBlockResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryTraceBlockResponse proto.InternalMessageInfo + +func (m *QueryTraceBlockResponse) GetData() []byte { + if m != nil { + return m.Data + } + return nil +} + +func init() { + proto.RegisterType((*QueryAccountRequest)(nil), "ethermint.evm.v1.QueryAccountRequest") + proto.RegisterType((*QueryAccountResponse)(nil), "ethermint.evm.v1.QueryAccountResponse") + proto.RegisterType((*QueryCosmosAccountRequest)(nil), "ethermint.evm.v1.QueryCosmosAccountRequest") + proto.RegisterType((*QueryCosmosAccountResponse)(nil), "ethermint.evm.v1.QueryCosmosAccountResponse") + proto.RegisterType((*QueryValidatorAccountRequest)(nil), "ethermint.evm.v1.QueryValidatorAccountRequest") + proto.RegisterType((*QueryValidatorAccountResponse)(nil), "ethermint.evm.v1.QueryValidatorAccountResponse") + proto.RegisterType((*QueryBalanceRequest)(nil), "ethermint.evm.v1.QueryBalanceRequest") + proto.RegisterType((*QueryBalanceResponse)(nil), "ethermint.evm.v1.QueryBalanceResponse") + proto.RegisterType((*QueryStorageRequest)(nil), "ethermint.evm.v1.QueryStorageRequest") + proto.RegisterType((*QueryStorageResponse)(nil), "ethermint.evm.v1.QueryStorageResponse") + proto.RegisterType((*QueryCodeRequest)(nil), "ethermint.evm.v1.QueryCodeRequest") + proto.RegisterType((*QueryCodeResponse)(nil), "ethermint.evm.v1.QueryCodeResponse") + proto.RegisterType((*QueryTxLogsRequest)(nil), "ethermint.evm.v1.QueryTxLogsRequest") + proto.RegisterType((*QueryTxLogsResponse)(nil), "ethermint.evm.v1.QueryTxLogsResponse") + proto.RegisterType((*QueryParamsRequest)(nil), "ethermint.evm.v1.QueryParamsRequest") + proto.RegisterType((*QueryParamsResponse)(nil), "ethermint.evm.v1.QueryParamsResponse") + proto.RegisterType((*EthCallRequest)(nil), "ethermint.evm.v1.EthCallRequest") + proto.RegisterType((*EstimateGasResponse)(nil), "ethermint.evm.v1.EstimateGasResponse") + proto.RegisterType((*QueryTraceTxRequest)(nil), "ethermint.evm.v1.QueryTraceTxRequest") + proto.RegisterType((*QueryTraceTxResponse)(nil), "ethermint.evm.v1.QueryTraceTxResponse") + proto.RegisterType((*QueryTraceBlockRequest)(nil), "ethermint.evm.v1.QueryTraceBlockRequest") + proto.RegisterType((*QueryTraceBlockResponse)(nil), "ethermint.evm.v1.QueryTraceBlockResponse") +} + +func init() { proto.RegisterFile("ethermint/evm/v1/query.proto", fileDescriptor_e15a877459347994) } + +var fileDescriptor_e15a877459347994 = []byte{ + // 1304 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x56, 0x4d, 0x6f, 0x1b, 0x45, + 0x18, 0xce, 0x26, 0x4e, 0x9c, 0xbe, 0x4e, 0x4b, 0x98, 0x06, 0xea, 0x2e, 0x89, 0x9d, 0x6e, 0x9b, + 0xaf, 0x36, 0xdd, 0x25, 0xa6, 0xaa, 0x44, 0x25, 0x04, 0x4d, 0x54, 0x0a, 0xea, 0x87, 0x8a, 0x89, + 0x38, 0x70, 0xb1, 0xc6, 0xeb, 0xe9, 0xda, 0x8a, 0x77, 0xc7, 0xdd, 0x19, 0x9b, 0x4d, 0x4b, 0x39, + 0x20, 0x51, 0x15, 0xf5, 0x52, 0x09, 0xce, 0xa8, 0xff, 0x80, 0xbf, 0xd1, 0x63, 0x25, 0x2e, 0x9c, + 0x00, 0xb5, 0x1c, 0xb8, 0xf6, 0x1f, 0xa0, 0xf9, 0xd8, 0x78, 0xed, 0xf5, 0xd6, 0x29, 0xea, 0x81, + 0xdb, 0x7c, 0xbc, 0xf3, 0x3e, 0xcf, 0xfb, 0x31, 0xf3, 0x0c, 0x2c, 0x12, 0xde, 0x24, 0xa1, 0xdf, + 0x0a, 0xb8, 0x43, 0x7a, 0xbe, 0xd3, 0xdb, 0x72, 0xee, 0x74, 0x49, 0xb8, 0x6f, 0x77, 0x42, 0xca, + 0x29, 0x9a, 0x3f, 0xd8, 0xb5, 0x49, 0xcf, 0xb7, 0x7b, 0x5b, 0xe6, 0x82, 0x47, 0x3d, 0x2a, 0x37, + 0x1d, 0x31, 0x52, 0x76, 0xe6, 0x59, 0x97, 0x32, 0x9f, 0x32, 0xa7, 0x8e, 0x19, 0x51, 0x0e, 0x9c, + 0xde, 0x56, 0x9d, 0x70, 0xbc, 0xe5, 0x74, 0xb0, 0xd7, 0x0a, 0x30, 0x6f, 0xd1, 0x40, 0xdb, 0x2e, + 0x7a, 0x94, 0x7a, 0x6d, 0xe2, 0xe0, 0x4e, 0xcb, 0xc1, 0x41, 0x40, 0xb9, 0xdc, 0x64, 0x7a, 0xd7, + 0x4c, 0xf1, 0x11, 0xc0, 0x6a, 0xef, 0x64, 0x6a, 0x8f, 0x47, 0x7a, 0xab, 0xac, 0x9d, 0xca, 0x59, + 0xbd, 0x7b, 0xdb, 0xe1, 0x2d, 0x9f, 0x30, 0x8e, 0xfd, 0x8e, 0x32, 0xb0, 0x3e, 0x84, 0xe3, 0x5f, + 0x08, 0x5e, 0x97, 0x5d, 0x97, 0x76, 0x03, 0x5e, 0x25, 0x77, 0xba, 0x84, 0x71, 0x54, 0x84, 0x3c, + 0x6e, 0x34, 0x42, 0xc2, 0x58, 0xd1, 0x58, 0x36, 0xd6, 0x8f, 0x54, 0xe3, 0xe9, 0xa5, 0xd9, 0x87, + 0x4f, 0xca, 0x13, 0xff, 0x3c, 0x29, 0x4f, 0x58, 0x2e, 0x2c, 0x0c, 0x1e, 0x65, 0x1d, 0x1a, 0x30, + 0x22, 0xce, 0xd6, 0x71, 0x1b, 0x07, 0x2e, 0x89, 0xcf, 0xea, 0x29, 0x7a, 0x0f, 0x8e, 0xb8, 0xb4, + 0x41, 0x6a, 0x4d, 0xcc, 0x9a, 0xc5, 0x49, 0xb9, 0x37, 0x2b, 0x16, 0x3e, 0xc3, 0xac, 0x89, 0x16, + 0x60, 0x3a, 0xa0, 0xe2, 0xd0, 0xd4, 0xb2, 0xb1, 0x9e, 0xab, 0xaa, 0x89, 0xf5, 0x31, 0x9c, 0x94, + 0x20, 0x3b, 0x32, 0x91, 0xff, 0x81, 0xe5, 0x03, 0x03, 0xcc, 0x51, 0x1e, 0x34, 0xd9, 0x15, 0x38, + 0xa6, 0x6a, 0x54, 0x1b, 0xf4, 0x74, 0x54, 0xad, 0x5e, 0x56, 0x8b, 0xc8, 0x84, 0x59, 0x26, 0x40, + 0x05, 0xbf, 0x49, 0xc9, 0xef, 0x60, 0x2e, 0x5c, 0x60, 0xe5, 0xb5, 0x16, 0x74, 0xfd, 0x3a, 0x09, + 0x75, 0x04, 0x47, 0xf5, 0xea, 0x4d, 0xb9, 0x68, 0x5d, 0x83, 0x45, 0xc9, 0xe3, 0x2b, 0xdc, 0x6e, + 0x35, 0x30, 0xa7, 0xe1, 0x50, 0x30, 0xa7, 0x60, 0xce, 0xa5, 0xc1, 0x30, 0x8f, 0x82, 0x58, 0xbb, + 0x9c, 0x8a, 0xea, 0x91, 0x01, 0x4b, 0x19, 0xde, 0x74, 0x60, 0x6b, 0xf0, 0x56, 0xcc, 0x6a, 0xd0, + 0x63, 0x4c, 0xf6, 0x0d, 0x86, 0x16, 0x37, 0xd1, 0xb6, 0xaa, 0xf3, 0xeb, 0x94, 0xe7, 0x7d, 0xdd, + 0x44, 0x07, 0x47, 0xc7, 0x35, 0x91, 0x75, 0x4d, 0x83, 0x7d, 0xc9, 0x69, 0x88, 0xbd, 0xf1, 0x60, + 0x68, 0x1e, 0xa6, 0xf6, 0xc8, 0xbe, 0xee, 0x37, 0x31, 0x4c, 0xc0, 0x6f, 0x6a, 0xf8, 0x03, 0x67, + 0x1a, 0x7e, 0x01, 0xa6, 0x7b, 0xb8, 0xdd, 0x8d, 0xc1, 0xd5, 0xc4, 0xba, 0x08, 0xf3, 0xba, 0x95, + 0x1a, 0xaf, 0x15, 0xe4, 0x1a, 0xbc, 0x9d, 0x38, 0xa7, 0x21, 0x10, 0xe4, 0x44, 0xef, 0xcb, 0x53, + 0x73, 0x55, 0x39, 0xb6, 0xee, 0x02, 0x92, 0x86, 0xbb, 0xd1, 0x75, 0xea, 0xb1, 0x18, 0x02, 0x41, + 0x4e, 0xde, 0x18, 0xe5, 0x5f, 0x8e, 0xd1, 0xa7, 0x00, 0xfd, 0x17, 0x44, 0xc6, 0x56, 0xa8, 0xac, + 0xda, 0xaa, 0x69, 0x6d, 0xf1, 0xdc, 0xd8, 0xea, 0xbd, 0xd2, 0xcf, 0x8d, 0x7d, 0xab, 0x9f, 0xaa, + 0x6a, 0xe2, 0x64, 0x82, 0xe4, 0x8f, 0x86, 0x4e, 0x6c, 0x0c, 0xae, 0x79, 0x6e, 0x40, 0xae, 0x4d, + 0x3d, 0x11, 0xdd, 0xd4, 0x7a, 0xa1, 0xf2, 0x8e, 0x3d, 0xfc, 0xf4, 0xd9, 0xd7, 0xa9, 0x57, 0x95, + 0x26, 0xe8, 0xea, 0x08, 0x52, 0x6b, 0x63, 0x49, 0x29, 0x9c, 0x24, 0x2b, 0x6b, 0x41, 0xe7, 0xe1, + 0x16, 0x0e, 0xb1, 0x1f, 0xe7, 0xc1, 0xba, 0xa1, 0x09, 0xc6, 0xab, 0x9a, 0xe0, 0x45, 0x98, 0xe9, + 0xc8, 0x15, 0x99, 0xa0, 0x42, 0xa5, 0x98, 0xa6, 0xa8, 0x4e, 0x6c, 0xe7, 0x9e, 0xfe, 0x51, 0x9e, + 0xa8, 0x6a, 0x6b, 0xeb, 0x23, 0x38, 0x76, 0x85, 0x37, 0x77, 0x70, 0xbb, 0x9d, 0x48, 0x34, 0x0e, + 0x3d, 0x16, 0x97, 0x44, 0x8c, 0xd1, 0x09, 0xc8, 0x7b, 0x98, 0xd5, 0x5c, 0xdc, 0xd1, 0xb7, 0x63, + 0xc6, 0xc3, 0x6c, 0x07, 0x77, 0xac, 0x35, 0x38, 0x7e, 0x85, 0xf1, 0x96, 0x8f, 0x39, 0xb9, 0x8a, + 0xfb, 0x6c, 0xe6, 0x61, 0xca, 0xc3, 0xca, 0x45, 0xae, 0x2a, 0x86, 0xd6, 0xcb, 0xc9, 0x38, 0xb1, + 0x21, 0x76, 0xc9, 0x6e, 0x14, 0xa3, 0x6d, 0xc1, 0x94, 0xcf, 0x3c, 0x4d, 0xba, 0x9c, 0x26, 0x7d, + 0x83, 0x79, 0x57, 0xc4, 0x1a, 0xe9, 0xfa, 0xbb, 0x51, 0x55, 0xd8, 0xa2, 0x93, 0x30, 0xcb, 0xa3, + 0x5a, 0x2b, 0x68, 0x90, 0x48, 0xb3, 0xc9, 0xf3, 0xe8, 0x73, 0x31, 0x45, 0x9f, 0xc0, 0x1c, 0x17, + 0xfe, 0x6b, 0x2e, 0x0d, 0x6e, 0xb7, 0x3c, 0x79, 0x51, 0x0b, 0x95, 0xa5, 0xb4, 0x5b, 0xc9, 0x62, + 0x47, 0x1a, 0x55, 0x0b, 0xbc, 0x3f, 0x41, 0x3b, 0x30, 0xd7, 0x09, 0x49, 0x83, 0xb8, 0x84, 0x31, + 0x1a, 0xb2, 0x62, 0x4e, 0x16, 0x7c, 0x2c, 0xb1, 0x81, 0x43, 0xe2, 0x15, 0xab, 0xb7, 0xa9, 0xbb, + 0x17, 0xbf, 0x17, 0xd3, 0xcb, 0xc6, 0xfa, 0x54, 0xb5, 0x20, 0xd7, 0xd4, 0x6b, 0x81, 0x96, 0x00, + 0x94, 0x89, 0x6c, 0xea, 0x19, 0xd9, 0xd4, 0x47, 0xe4, 0x8a, 0xd4, 0x81, 0x9d, 0x78, 0x5b, 0x48, + 0x55, 0x31, 0x2f, 0xc3, 0x30, 0x6d, 0xa5, 0x63, 0x76, 0xac, 0x63, 0xf6, 0x6e, 0xac, 0x63, 0xdb, + 0xb3, 0xa2, 0xa8, 0x8f, 0xff, 0x2c, 0x1b, 0xda, 0x89, 0xd8, 0xb1, 0xce, 0xea, 0x7b, 0x7d, 0x90, + 0xf2, 0xfe, 0xa5, 0x6b, 0x60, 0x8e, 0xe3, 0x0a, 0x8b, 0xb1, 0xf5, 0xf3, 0x24, 0xbc, 0xdb, 0x37, + 0xde, 0x16, 0x3e, 0x12, 0x25, 0xe2, 0x51, 0xdc, 0xfa, 0xe3, 0x4b, 0xc4, 0x23, 0xf6, 0x06, 0xea, + 0xf0, 0x3f, 0x49, 0xe1, 0x79, 0x38, 0x91, 0xca, 0x4a, 0x76, 0x16, 0x2b, 0x2f, 0x0b, 0x30, 0x2d, + 0xed, 0xd1, 0x0f, 0x06, 0xe4, 0xb5, 0x1a, 0xa1, 0x95, 0x74, 0xdc, 0x23, 0xbe, 0x1b, 0xe6, 0xea, + 0x38, 0x33, 0x05, 0x6c, 0x9d, 0xfb, 0xfe, 0xb7, 0xbf, 0x7f, 0x9a, 0x5c, 0x41, 0xa7, 0x9d, 0xd4, + 0x97, 0x47, 0x2b, 0x92, 0x73, 0x4f, 0x3f, 0xbf, 0xf7, 0xd1, 0x2f, 0x06, 0x1c, 0x1d, 0x10, 0x7d, + 0x74, 0x2e, 0x03, 0x66, 0xd4, 0xe7, 0xc2, 0xdc, 0x3c, 0x9c, 0xb1, 0x66, 0x56, 0x91, 0xcc, 0x36, + 0xd1, 0xd9, 0x34, 0xb3, 0xf8, 0x7f, 0x91, 0x22, 0xf8, 0xab, 0x01, 0xf3, 0xc3, 0xfa, 0x8d, 0xec, + 0x0c, 0xd8, 0x8c, 0x6f, 0x83, 0xe9, 0x1c, 0xda, 0x5e, 0x33, 0xbd, 0x24, 0x99, 0x5e, 0x40, 0x95, + 0x34, 0xd3, 0x5e, 0x7c, 0xa6, 0x4f, 0x36, 0xf9, 0x25, 0xb9, 0x8f, 0x1e, 0x18, 0x90, 0xd7, 0x4a, + 0x9d, 0x59, 0xda, 0xc1, 0x4f, 0x40, 0x66, 0x69, 0x87, 0x04, 0xdf, 0xda, 0x94, 0xb4, 0x56, 0xd1, + 0x99, 0x34, 0x2d, 0xad, 0xfc, 0x2c, 0x91, 0xba, 0x47, 0x06, 0xe4, 0xb5, 0x66, 0x67, 0x12, 0x19, + 0xfc, 0x20, 0x64, 0x12, 0x19, 0x92, 0x7e, 0x6b, 0x4b, 0x12, 0x39, 0x87, 0x36, 0xd2, 0x44, 0x98, + 0x32, 0xed, 0xf3, 0x70, 0xee, 0xed, 0x91, 0xfd, 0xfb, 0xe8, 0x2e, 0xe4, 0x84, 0xb4, 0x23, 0x2b, + 0xb3, 0x65, 0x0e, 0xfe, 0x0b, 0xe6, 0xe9, 0x57, 0xda, 0x68, 0x0e, 0x1b, 0x92, 0xc3, 0x69, 0x74, + 0x6a, 0x54, 0x37, 0x35, 0x06, 0x32, 0xf1, 0x0d, 0xcc, 0x28, 0x75, 0x43, 0x67, 0x32, 0x3c, 0x0f, + 0x88, 0xa8, 0xb9, 0x32, 0xc6, 0x4a, 0x33, 0x58, 0x96, 0x0c, 0x4c, 0x54, 0x4c, 0x33, 0x50, 0xf2, + 0x89, 0x22, 0xc8, 0x6b, 0xf9, 0x44, 0xcb, 0x69, 0x9f, 0x83, 0xca, 0x6a, 0xae, 0x8d, 0x7b, 0x3b, + 0x63, 0x5c, 0x4b, 0xe2, 0x2e, 0x22, 0x33, 0x8d, 0x4b, 0x78, 0xb3, 0xe6, 0x0a, 0xb8, 0xef, 0xa0, + 0x90, 0x50, 0xde, 0x43, 0xa0, 0x8f, 0x88, 0x79, 0x84, 0x74, 0x5b, 0xab, 0x12, 0x7b, 0x19, 0x95, + 0x46, 0x60, 0x6b, 0xf3, 0x9a, 0x87, 0x19, 0xfa, 0x16, 0xf2, 0x5a, 0x57, 0x32, 0x7b, 0x6f, 0x50, + 0xea, 0x33, 0x7b, 0x6f, 0x48, 0x9e, 0x5e, 0x15, 0xbd, 0x12, 0x15, 0x1e, 0xa1, 0x87, 0x06, 0x40, + 0xff, 0x4d, 0x46, 0xeb, 0xaf, 0x72, 0x9d, 0x14, 0x33, 0x73, 0xe3, 0x10, 0x96, 0x9a, 0xc7, 0x8a, + 0xe4, 0x51, 0x46, 0x4b, 0x59, 0x3c, 0xa4, 0x4c, 0x6c, 0xdf, 0x7c, 0xfa, 0xbc, 0x64, 0x3c, 0x7b, + 0x5e, 0x32, 0xfe, 0x7a, 0x5e, 0x32, 0x1e, 0xbf, 0x28, 0x4d, 0x3c, 0x7b, 0x51, 0x9a, 0xf8, 0xfd, + 0x45, 0x69, 0xe2, 0xeb, 0x0b, 0x5e, 0x8b, 0x37, 0xbb, 0x75, 0xdb, 0xa5, 0xbe, 0xd3, 0x0a, 0x5b, + 0x2c, 0x20, 0xdc, 0x71, 0x69, 0x48, 0xce, 0xb3, 0xc6, 0xde, 0x79, 0x8f, 0x26, 0xdc, 0x46, 0xd2, + 0x31, 0xdf, 0xef, 0x10, 0x56, 0x9f, 0x91, 0xda, 0xf4, 0xc1, 0xbf, 0x01, 0x00, 0x00, 0xff, 0xff, + 0x68, 0xfb, 0xa7, 0x40, 0x7d, 0x0f, 0x00, 0x00, +} + +// Reference imports to suppress errors if they are not otherwise used. +var _ context.Context +var _ grpc.ClientConn + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the grpc package it is being compiled against. +const _ = grpc.SupportPackageIsVersion4 + +// QueryClient is the client API for Query service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. +type QueryClient interface { + // Account queries an Ethereum account. + Account(ctx context.Context, in *QueryAccountRequest, opts ...grpc.CallOption) (*QueryAccountResponse, error) + // CosmosAccount queries an Ethereum account's Cosmos Address. + CosmosAccount(ctx context.Context, in *QueryCosmosAccountRequest, opts ...grpc.CallOption) (*QueryCosmosAccountResponse, error) + // ValidatorAccount queries an Ethereum account's from a validator consensus + // Address. + ValidatorAccount(ctx context.Context, in *QueryValidatorAccountRequest, opts ...grpc.CallOption) (*QueryValidatorAccountResponse, error) + // Balance queries the balance of a the EVM denomination for a single + // EthAccount. + Balance(ctx context.Context, in *QueryBalanceRequest, opts ...grpc.CallOption) (*QueryBalanceResponse, error) + // Storage queries the balance of all coins for a single account. + Storage(ctx context.Context, in *QueryStorageRequest, opts ...grpc.CallOption) (*QueryStorageResponse, error) + // Code queries the balance of all coins for a single account. + Code(ctx context.Context, in *QueryCodeRequest, opts ...grpc.CallOption) (*QueryCodeResponse, error) + // Params queries the parameters of x/evm module. + Params(ctx context.Context, in *QueryParamsRequest, opts ...grpc.CallOption) (*QueryParamsResponse, error) + // EthCall implements the `eth_call` rpc api + EthCall(ctx context.Context, in *EthCallRequest, opts ...grpc.CallOption) (*MsgEthereumTxResponse, error) + // EstimateGas implements the `eth_estimateGas` rpc api + EstimateGas(ctx context.Context, in *EthCallRequest, opts ...grpc.CallOption) (*EstimateGasResponse, error) + // TraceTx implements the `debug_traceTransaction` rpc api + TraceTx(ctx context.Context, in *QueryTraceTxRequest, opts ...grpc.CallOption) (*QueryTraceTxResponse, error) + // TraceBlock implements the `debug_traceBlockByNumber` and `debug_traceBlockByHash` rpc api + TraceBlock(ctx context.Context, in *QueryTraceBlockRequest, opts ...grpc.CallOption) (*QueryTraceBlockResponse, error) +} + +type queryClient struct { + cc grpc1.ClientConn +} + +func NewQueryClient(cc grpc1.ClientConn) QueryClient { + return &queryClient{cc} +} + +func (c *queryClient) Account(ctx context.Context, in *QueryAccountRequest, opts ...grpc.CallOption) (*QueryAccountResponse, error) { + out := new(QueryAccountResponse) + err := c.cc.Invoke(ctx, "/ethermint.evm.v1.Query/Account", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *queryClient) CosmosAccount(ctx context.Context, in *QueryCosmosAccountRequest, opts ...grpc.CallOption) (*QueryCosmosAccountResponse, error) { + out := new(QueryCosmosAccountResponse) + err := c.cc.Invoke(ctx, "/ethermint.evm.v1.Query/CosmosAccount", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *queryClient) ValidatorAccount(ctx context.Context, in *QueryValidatorAccountRequest, opts ...grpc.CallOption) (*QueryValidatorAccountResponse, error) { + out := new(QueryValidatorAccountResponse) + err := c.cc.Invoke(ctx, "/ethermint.evm.v1.Query/ValidatorAccount", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *queryClient) Balance(ctx context.Context, in *QueryBalanceRequest, opts ...grpc.CallOption) (*QueryBalanceResponse, error) { + out := new(QueryBalanceResponse) + err := c.cc.Invoke(ctx, "/ethermint.evm.v1.Query/Balance", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *queryClient) Storage(ctx context.Context, in *QueryStorageRequest, opts ...grpc.CallOption) (*QueryStorageResponse, error) { + out := new(QueryStorageResponse) + err := c.cc.Invoke(ctx, "/ethermint.evm.v1.Query/Storage", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *queryClient) Code(ctx context.Context, in *QueryCodeRequest, opts ...grpc.CallOption) (*QueryCodeResponse, error) { + out := new(QueryCodeResponse) + err := c.cc.Invoke(ctx, "/ethermint.evm.v1.Query/Code", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *queryClient) Params(ctx context.Context, in *QueryParamsRequest, opts ...grpc.CallOption) (*QueryParamsResponse, error) { + out := new(QueryParamsResponse) + err := c.cc.Invoke(ctx, "/ethermint.evm.v1.Query/Params", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *queryClient) EthCall(ctx context.Context, in *EthCallRequest, opts ...grpc.CallOption) (*MsgEthereumTxResponse, error) { + out := new(MsgEthereumTxResponse) + err := c.cc.Invoke(ctx, "/ethermint.evm.v1.Query/EthCall", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *queryClient) EstimateGas(ctx context.Context, in *EthCallRequest, opts ...grpc.CallOption) (*EstimateGasResponse, error) { + out := new(EstimateGasResponse) + err := c.cc.Invoke(ctx, "/ethermint.evm.v1.Query/EstimateGas", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *queryClient) TraceTx(ctx context.Context, in *QueryTraceTxRequest, opts ...grpc.CallOption) (*QueryTraceTxResponse, error) { + out := new(QueryTraceTxResponse) + err := c.cc.Invoke(ctx, "/ethermint.evm.v1.Query/TraceTx", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *queryClient) TraceBlock(ctx context.Context, in *QueryTraceBlockRequest, opts ...grpc.CallOption) (*QueryTraceBlockResponse, error) { + out := new(QueryTraceBlockResponse) + err := c.cc.Invoke(ctx, "/ethermint.evm.v1.Query/TraceBlock", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +// QueryServer is the server API for Query service. +type QueryServer interface { + // Account queries an Ethereum account. + Account(context.Context, *QueryAccountRequest) (*QueryAccountResponse, error) + // CosmosAccount queries an Ethereum account's Cosmos Address. + CosmosAccount(context.Context, *QueryCosmosAccountRequest) (*QueryCosmosAccountResponse, error) + // ValidatorAccount queries an Ethereum account's from a validator consensus + // Address. + ValidatorAccount(context.Context, *QueryValidatorAccountRequest) (*QueryValidatorAccountResponse, error) + // Balance queries the balance of a the EVM denomination for a single + // EthAccount. + Balance(context.Context, *QueryBalanceRequest) (*QueryBalanceResponse, error) + // Storage queries the balance of all coins for a single account. + Storage(context.Context, *QueryStorageRequest) (*QueryStorageResponse, error) + // Code queries the balance of all coins for a single account. + Code(context.Context, *QueryCodeRequest) (*QueryCodeResponse, error) + // Params queries the parameters of x/evm module. + Params(context.Context, *QueryParamsRequest) (*QueryParamsResponse, error) + // EthCall implements the `eth_call` rpc api + EthCall(context.Context, *EthCallRequest) (*MsgEthereumTxResponse, error) + // EstimateGas implements the `eth_estimateGas` rpc api + EstimateGas(context.Context, *EthCallRequest) (*EstimateGasResponse, error) + // TraceTx implements the `debug_traceTransaction` rpc api + TraceTx(context.Context, *QueryTraceTxRequest) (*QueryTraceTxResponse, error) + // TraceBlock implements the `debug_traceBlockByNumber` and `debug_traceBlockByHash` rpc api + TraceBlock(context.Context, *QueryTraceBlockRequest) (*QueryTraceBlockResponse, error) +} + +// UnimplementedQueryServer can be embedded to have forward compatible implementations. +type UnimplementedQueryServer struct { +} + +func (*UnimplementedQueryServer) Account(ctx context.Context, req *QueryAccountRequest) (*QueryAccountResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method Account not implemented") +} +func (*UnimplementedQueryServer) CosmosAccount(ctx context.Context, req *QueryCosmosAccountRequest) (*QueryCosmosAccountResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method CosmosAccount not implemented") +} +func (*UnimplementedQueryServer) ValidatorAccount(ctx context.Context, req *QueryValidatorAccountRequest) (*QueryValidatorAccountResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method ValidatorAccount not implemented") +} +func (*UnimplementedQueryServer) Balance(ctx context.Context, req *QueryBalanceRequest) (*QueryBalanceResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method Balance not implemented") +} +func (*UnimplementedQueryServer) Storage(ctx context.Context, req *QueryStorageRequest) (*QueryStorageResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method Storage not implemented") +} +func (*UnimplementedQueryServer) Code(ctx context.Context, req *QueryCodeRequest) (*QueryCodeResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method Code not implemented") +} +func (*UnimplementedQueryServer) Params(ctx context.Context, req *QueryParamsRequest) (*QueryParamsResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method Params not implemented") +} +func (*UnimplementedQueryServer) EthCall(ctx context.Context, req *EthCallRequest) (*MsgEthereumTxResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method EthCall not implemented") +} +func (*UnimplementedQueryServer) EstimateGas(ctx context.Context, req *EthCallRequest) (*EstimateGasResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method EstimateGas not implemented") +} +func (*UnimplementedQueryServer) TraceTx(ctx context.Context, req *QueryTraceTxRequest) (*QueryTraceTxResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method TraceTx not implemented") +} +func (*UnimplementedQueryServer) TraceBlock(ctx context.Context, req *QueryTraceBlockRequest) (*QueryTraceBlockResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method TraceBlock not implemented") +} + +func RegisterQueryServer(s grpc1.Server, srv QueryServer) { + s.RegisterService(&_Query_serviceDesc, srv) +} + +func _Query_Account_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(QueryAccountRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServer).Account(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/ethermint.evm.v1.Query/Account", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServer).Account(ctx, req.(*QueryAccountRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Query_CosmosAccount_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(QueryCosmosAccountRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServer).CosmosAccount(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/ethermint.evm.v1.Query/CosmosAccount", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServer).CosmosAccount(ctx, req.(*QueryCosmosAccountRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Query_ValidatorAccount_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(QueryValidatorAccountRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServer).ValidatorAccount(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/ethermint.evm.v1.Query/ValidatorAccount", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServer).ValidatorAccount(ctx, req.(*QueryValidatorAccountRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Query_Balance_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(QueryBalanceRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServer).Balance(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/ethermint.evm.v1.Query/Balance", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServer).Balance(ctx, req.(*QueryBalanceRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Query_Storage_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(QueryStorageRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServer).Storage(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/ethermint.evm.v1.Query/Storage", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServer).Storage(ctx, req.(*QueryStorageRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Query_Code_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(QueryCodeRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServer).Code(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/ethermint.evm.v1.Query/Code", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServer).Code(ctx, req.(*QueryCodeRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Query_Params_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(QueryParamsRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServer).Params(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/ethermint.evm.v1.Query/Params", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServer).Params(ctx, req.(*QueryParamsRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Query_EthCall_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(EthCallRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServer).EthCall(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/ethermint.evm.v1.Query/EthCall", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServer).EthCall(ctx, req.(*EthCallRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Query_EstimateGas_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(EthCallRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServer).EstimateGas(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/ethermint.evm.v1.Query/EstimateGas", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServer).EstimateGas(ctx, req.(*EthCallRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Query_TraceTx_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(QueryTraceTxRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServer).TraceTx(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/ethermint.evm.v1.Query/TraceTx", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServer).TraceTx(ctx, req.(*QueryTraceTxRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Query_TraceBlock_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(QueryTraceBlockRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServer).TraceBlock(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/ethermint.evm.v1.Query/TraceBlock", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServer).TraceBlock(ctx, req.(*QueryTraceBlockRequest)) + } + return interceptor(ctx, in, info, handler) +} + +var _Query_serviceDesc = grpc.ServiceDesc{ + ServiceName: "ethermint.evm.v1.Query", + HandlerType: (*QueryServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "Account", + Handler: _Query_Account_Handler, + }, + { + MethodName: "CosmosAccount", + Handler: _Query_CosmosAccount_Handler, + }, + { + MethodName: "ValidatorAccount", + Handler: _Query_ValidatorAccount_Handler, + }, + { + MethodName: "Balance", + Handler: _Query_Balance_Handler, + }, + { + MethodName: "Storage", + Handler: _Query_Storage_Handler, + }, + { + MethodName: "Code", + Handler: _Query_Code_Handler, + }, + { + MethodName: "Params", + Handler: _Query_Params_Handler, + }, + { + MethodName: "EthCall", + Handler: _Query_EthCall_Handler, + }, + { + MethodName: "EstimateGas", + Handler: _Query_EstimateGas_Handler, + }, + { + MethodName: "TraceTx", + Handler: _Query_TraceTx_Handler, + }, + { + MethodName: "TraceBlock", + Handler: _Query_TraceBlock_Handler, + }, + }, + Streams: []grpc.StreamDesc{}, + Metadata: "ethermint/evm/v1/query.proto", +} + +func (m *QueryAccountRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *QueryAccountRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryAccountRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Address) > 0 { + i -= len(m.Address) + copy(dAtA[i:], m.Address) + i = encodeVarintQuery(dAtA, i, uint64(len(m.Address))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *QueryAccountResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *QueryAccountResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryAccountResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Nonce != 0 { + i = encodeVarintQuery(dAtA, i, uint64(m.Nonce)) + i-- + dAtA[i] = 0x18 + } + if len(m.CodeHash) > 0 { + i -= len(m.CodeHash) + copy(dAtA[i:], m.CodeHash) + i = encodeVarintQuery(dAtA, i, uint64(len(m.CodeHash))) + i-- + dAtA[i] = 0x12 + } + if len(m.Balance) > 0 { + i -= len(m.Balance) + copy(dAtA[i:], m.Balance) + i = encodeVarintQuery(dAtA, i, uint64(len(m.Balance))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *QueryCosmosAccountRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *QueryCosmosAccountRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryCosmosAccountRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Address) > 0 { + i -= len(m.Address) + copy(dAtA[i:], m.Address) + i = encodeVarintQuery(dAtA, i, uint64(len(m.Address))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *QueryCosmosAccountResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *QueryCosmosAccountResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryCosmosAccountResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.AccountNumber != 0 { + i = encodeVarintQuery(dAtA, i, uint64(m.AccountNumber)) + i-- + dAtA[i] = 0x18 + } + if m.Sequence != 0 { + i = encodeVarintQuery(dAtA, i, uint64(m.Sequence)) + i-- + dAtA[i] = 0x10 + } + if len(m.CosmosAddress) > 0 { + i -= len(m.CosmosAddress) + copy(dAtA[i:], m.CosmosAddress) + i = encodeVarintQuery(dAtA, i, uint64(len(m.CosmosAddress))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *QueryValidatorAccountRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *QueryValidatorAccountRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryValidatorAccountRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.ConsAddress) > 0 { + i -= len(m.ConsAddress) + copy(dAtA[i:], m.ConsAddress) + i = encodeVarintQuery(dAtA, i, uint64(len(m.ConsAddress))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *QueryValidatorAccountResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *QueryValidatorAccountResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryValidatorAccountResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.AccountNumber != 0 { + i = encodeVarintQuery(dAtA, i, uint64(m.AccountNumber)) + i-- + dAtA[i] = 0x18 + } + if m.Sequence != 0 { + i = encodeVarintQuery(dAtA, i, uint64(m.Sequence)) + i-- + dAtA[i] = 0x10 + } + if len(m.AccountAddress) > 0 { + i -= len(m.AccountAddress) + copy(dAtA[i:], m.AccountAddress) + i = encodeVarintQuery(dAtA, i, uint64(len(m.AccountAddress))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *QueryBalanceRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *QueryBalanceRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryBalanceRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Address) > 0 { + i -= len(m.Address) + copy(dAtA[i:], m.Address) + i = encodeVarintQuery(dAtA, i, uint64(len(m.Address))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *QueryBalanceResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *QueryBalanceResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryBalanceResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Balance) > 0 { + i -= len(m.Balance) + copy(dAtA[i:], m.Balance) + i = encodeVarintQuery(dAtA, i, uint64(len(m.Balance))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *QueryStorageRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *QueryStorageRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryStorageRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Key) > 0 { + i -= len(m.Key) + copy(dAtA[i:], m.Key) + i = encodeVarintQuery(dAtA, i, uint64(len(m.Key))) + i-- + dAtA[i] = 0x12 + } + if len(m.Address) > 0 { + i -= len(m.Address) + copy(dAtA[i:], m.Address) + i = encodeVarintQuery(dAtA, i, uint64(len(m.Address))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *QueryStorageResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *QueryStorageResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryStorageResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Value) > 0 { + i -= len(m.Value) + copy(dAtA[i:], m.Value) + i = encodeVarintQuery(dAtA, i, uint64(len(m.Value))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *QueryCodeRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *QueryCodeRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryCodeRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Address) > 0 { + i -= len(m.Address) + copy(dAtA[i:], m.Address) + i = encodeVarintQuery(dAtA, i, uint64(len(m.Address))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *QueryCodeResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *QueryCodeResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryCodeResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Code) > 0 { + i -= len(m.Code) + copy(dAtA[i:], m.Code) + i = encodeVarintQuery(dAtA, i, uint64(len(m.Code))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *QueryTxLogsRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *QueryTxLogsRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryTxLogsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Pagination != nil { + { + size, err := m.Pagination.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintQuery(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if len(m.Hash) > 0 { + i -= len(m.Hash) + copy(dAtA[i:], m.Hash) + i = encodeVarintQuery(dAtA, i, uint64(len(m.Hash))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *QueryTxLogsResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *QueryTxLogsResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryTxLogsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Pagination != nil { + { + size, err := m.Pagination.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintQuery(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if len(m.Logs) > 0 { + for iNdEx := len(m.Logs) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Logs[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintQuery(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + +func (m *QueryParamsRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *QueryParamsRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryParamsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + return len(dAtA) - i, nil +} + +func (m *QueryParamsResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *QueryParamsResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryParamsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + { + size, err := m.Params.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintQuery(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *EthCallRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *EthCallRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *EthCallRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.GasCap != 0 { + i = encodeVarintQuery(dAtA, i, uint64(m.GasCap)) + i-- + dAtA[i] = 0x10 + } + if len(m.Args) > 0 { + i -= len(m.Args) + copy(dAtA[i:], m.Args) + i = encodeVarintQuery(dAtA, i, uint64(len(m.Args))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *EstimateGasResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *EstimateGasResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *EstimateGasResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Gas != 0 { + i = encodeVarintQuery(dAtA, i, uint64(m.Gas)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *QueryTraceTxRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *QueryTraceTxRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryTraceTxRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + n4, err4 := github_com_cosmos_gogoproto_types.StdTimeMarshalTo(m.BlockTime, dAtA[i-github_com_cosmos_gogoproto_types.SizeOfStdTime(m.BlockTime):]) + if err4 != nil { + return 0, err4 + } + i -= n4 + i = encodeVarintQuery(dAtA, i, uint64(n4)) + i-- + dAtA[i] = 0x3a + if len(m.BlockHash) > 0 { + i -= len(m.BlockHash) + copy(dAtA[i:], m.BlockHash) + i = encodeVarintQuery(dAtA, i, uint64(len(m.BlockHash))) + i-- + dAtA[i] = 0x32 + } + if m.BlockNumber != 0 { + i = encodeVarintQuery(dAtA, i, uint64(m.BlockNumber)) + i-- + dAtA[i] = 0x28 + } + if len(m.Predecessors) > 0 { + for iNdEx := len(m.Predecessors) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Predecessors[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintQuery(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x22 + } + } + if m.TraceConfig != nil { + { + size, err := m.TraceConfig.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintQuery(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } + if m.TxIndex != 0 { + i = encodeVarintQuery(dAtA, i, uint64(m.TxIndex)) + i-- + dAtA[i] = 0x10 + } + if m.Msg != nil { + { + size, err := m.Msg.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintQuery(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *QueryTraceTxResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *QueryTraceTxResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryTraceTxResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Data) > 0 { + i -= len(m.Data) + copy(dAtA[i:], m.Data) + i = encodeVarintQuery(dAtA, i, uint64(len(m.Data))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *QueryTraceBlockRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *QueryTraceBlockRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryTraceBlockRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + n7, err7 := github_com_cosmos_gogoproto_types.StdTimeMarshalTo(m.BlockTime, dAtA[i-github_com_cosmos_gogoproto_types.SizeOfStdTime(m.BlockTime):]) + if err7 != nil { + return 0, err7 + } + i -= n7 + i = encodeVarintQuery(dAtA, i, uint64(n7)) + i-- + dAtA[i] = 0x3a + if len(m.BlockHash) > 0 { + i -= len(m.BlockHash) + copy(dAtA[i:], m.BlockHash) + i = encodeVarintQuery(dAtA, i, uint64(len(m.BlockHash))) + i-- + dAtA[i] = 0x32 + } + if m.BlockNumber != 0 { + i = encodeVarintQuery(dAtA, i, uint64(m.BlockNumber)) + i-- + dAtA[i] = 0x28 + } + if m.TraceConfig != nil { + { + size, err := m.TraceConfig.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintQuery(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } + if len(m.Txs) > 0 { + for iNdEx := len(m.Txs) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Txs[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintQuery(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + +func (m *QueryTraceBlockResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *QueryTraceBlockResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryTraceBlockResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Data) > 0 { + i -= len(m.Data) + copy(dAtA[i:], m.Data) + i = encodeVarintQuery(dAtA, i, uint64(len(m.Data))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func encodeVarintQuery(dAtA []byte, offset int, v uint64) int { + offset -= sovQuery(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} +func (m *QueryAccountRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Address) + if l > 0 { + n += 1 + l + sovQuery(uint64(l)) + } + return n +} + +func (m *QueryAccountResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Balance) + if l > 0 { + n += 1 + l + sovQuery(uint64(l)) + } + l = len(m.CodeHash) + if l > 0 { + n += 1 + l + sovQuery(uint64(l)) + } + if m.Nonce != 0 { + n += 1 + sovQuery(uint64(m.Nonce)) + } + return n +} + +func (m *QueryCosmosAccountRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Address) + if l > 0 { + n += 1 + l + sovQuery(uint64(l)) + } + return n +} + +func (m *QueryCosmosAccountResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.CosmosAddress) + if l > 0 { + n += 1 + l + sovQuery(uint64(l)) + } + if m.Sequence != 0 { + n += 1 + sovQuery(uint64(m.Sequence)) + } + if m.AccountNumber != 0 { + n += 1 + sovQuery(uint64(m.AccountNumber)) + } + return n +} + +func (m *QueryValidatorAccountRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.ConsAddress) + if l > 0 { + n += 1 + l + sovQuery(uint64(l)) + } + return n +} + +func (m *QueryValidatorAccountResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.AccountAddress) + if l > 0 { + n += 1 + l + sovQuery(uint64(l)) + } + if m.Sequence != 0 { + n += 1 + sovQuery(uint64(m.Sequence)) + } + if m.AccountNumber != 0 { + n += 1 + sovQuery(uint64(m.AccountNumber)) + } + return n +} + +func (m *QueryBalanceRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Address) + if l > 0 { + n += 1 + l + sovQuery(uint64(l)) + } + return n +} + +func (m *QueryBalanceResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Balance) + if l > 0 { + n += 1 + l + sovQuery(uint64(l)) + } + return n +} + +func (m *QueryStorageRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Address) + if l > 0 { + n += 1 + l + sovQuery(uint64(l)) + } + l = len(m.Key) + if l > 0 { + n += 1 + l + sovQuery(uint64(l)) + } + return n +} + +func (m *QueryStorageResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Value) + if l > 0 { + n += 1 + l + sovQuery(uint64(l)) + } + return n +} + +func (m *QueryCodeRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Address) + if l > 0 { + n += 1 + l + sovQuery(uint64(l)) + } + return n +} + +func (m *QueryCodeResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Code) + if l > 0 { + n += 1 + l + sovQuery(uint64(l)) + } + return n +} + +func (m *QueryTxLogsRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Hash) + if l > 0 { + n += 1 + l + sovQuery(uint64(l)) + } + if m.Pagination != nil { + l = m.Pagination.Size() + n += 1 + l + sovQuery(uint64(l)) + } + return n +} + +func (m *QueryTxLogsResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.Logs) > 0 { + for _, e := range m.Logs { + l = e.Size() + n += 1 + l + sovQuery(uint64(l)) + } + } + if m.Pagination != nil { + l = m.Pagination.Size() + n += 1 + l + sovQuery(uint64(l)) + } + return n +} + +func (m *QueryParamsRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *QueryParamsResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = m.Params.Size() + n += 1 + l + sovQuery(uint64(l)) + return n +} + +func (m *EthCallRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Args) + if l > 0 { + n += 1 + l + sovQuery(uint64(l)) + } + if m.GasCap != 0 { + n += 1 + sovQuery(uint64(m.GasCap)) + } + return n +} + +func (m *EstimateGasResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Gas != 0 { + n += 1 + sovQuery(uint64(m.Gas)) + } + return n +} + +func (m *QueryTraceTxRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Msg != nil { + l = m.Msg.Size() + n += 1 + l + sovQuery(uint64(l)) + } + if m.TxIndex != 0 { + n += 1 + sovQuery(uint64(m.TxIndex)) + } + if m.TraceConfig != nil { + l = m.TraceConfig.Size() + n += 1 + l + sovQuery(uint64(l)) + } + if len(m.Predecessors) > 0 { + for _, e := range m.Predecessors { + l = e.Size() + n += 1 + l + sovQuery(uint64(l)) + } + } + if m.BlockNumber != 0 { + n += 1 + sovQuery(uint64(m.BlockNumber)) + } + l = len(m.BlockHash) + if l > 0 { + n += 1 + l + sovQuery(uint64(l)) + } + l = github_com_cosmos_gogoproto_types.SizeOfStdTime(m.BlockTime) + n += 1 + l + sovQuery(uint64(l)) + return n +} + +func (m *QueryTraceTxResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Data) + if l > 0 { + n += 1 + l + sovQuery(uint64(l)) + } + return n +} + +func (m *QueryTraceBlockRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.Txs) > 0 { + for _, e := range m.Txs { + l = e.Size() + n += 1 + l + sovQuery(uint64(l)) + } + } + if m.TraceConfig != nil { + l = m.TraceConfig.Size() + n += 1 + l + sovQuery(uint64(l)) + } + if m.BlockNumber != 0 { + n += 1 + sovQuery(uint64(m.BlockNumber)) + } + l = len(m.BlockHash) + if l > 0 { + n += 1 + l + sovQuery(uint64(l)) + } + l = github_com_cosmos_gogoproto_types.SizeOfStdTime(m.BlockTime) + n += 1 + l + sovQuery(uint64(l)) + return n +} + +func (m *QueryTraceBlockResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Data) + if l > 0 { + n += 1 + l + sovQuery(uint64(l)) + } + return n +} + +func sovQuery(x uint64) (n int) { + return (math_bits.Len64(x|1) + 6) / 7 +} +func sozQuery(x uint64) (n int) { + return sovQuery(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *QueryAccountRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: QueryAccountRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryAccountRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Address = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *QueryAccountResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: QueryAccountResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryAccountResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Balance", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Balance = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field CodeHash", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.CodeHash = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Nonce", wireType) + } + m.Nonce = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Nonce |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *QueryCosmosAccountRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: QueryCosmosAccountRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryCosmosAccountRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Address = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *QueryCosmosAccountResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: QueryCosmosAccountResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryCosmosAccountResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field CosmosAddress", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.CosmosAddress = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Sequence", wireType) + } + m.Sequence = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Sequence |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field AccountNumber", wireType) + } + m.AccountNumber = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.AccountNumber |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *QueryValidatorAccountRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: QueryValidatorAccountRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryValidatorAccountRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ConsAddress", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ConsAddress = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *QueryValidatorAccountResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: QueryValidatorAccountResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryValidatorAccountResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field AccountAddress", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.AccountAddress = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Sequence", wireType) + } + m.Sequence = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Sequence |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field AccountNumber", wireType) + } + m.AccountNumber = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.AccountNumber |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *QueryBalanceRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: QueryBalanceRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryBalanceRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Address = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *QueryBalanceResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: QueryBalanceResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryBalanceResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Balance", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Balance = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *QueryStorageRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: QueryStorageRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryStorageRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Address = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Key = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *QueryStorageResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: QueryStorageResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryStorageResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Value = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *QueryCodeRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: QueryCodeRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryCodeRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Address = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *QueryCodeResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: QueryCodeResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryCodeResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Code = append(m.Code[:0], dAtA[iNdEx:postIndex]...) + if m.Code == nil { + m.Code = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *QueryTxLogsRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: QueryTxLogsRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryTxLogsRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Hash", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Hash = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Pagination == nil { + m.Pagination = &query.PageRequest{} + } + if err := m.Pagination.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *QueryTxLogsResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: QueryTxLogsResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryTxLogsResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Logs", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Logs = append(m.Logs, &Log{}) + if err := m.Logs[len(m.Logs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Pagination", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Pagination == nil { + m.Pagination = &query.PageResponse{} + } + if err := m.Pagination.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *QueryParamsRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: QueryParamsRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryParamsRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *QueryParamsResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: QueryParamsResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryParamsResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Params", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Params.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *EthCallRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: EthCallRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: EthCallRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Args", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Args = append(m.Args[:0], dAtA[iNdEx:postIndex]...) + if m.Args == nil { + m.Args = []byte{} + } + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field GasCap", wireType) + } + m.GasCap = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.GasCap |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *EstimateGasResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: EstimateGasResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: EstimateGasResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Gas", wireType) + } + m.Gas = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Gas |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *QueryTraceTxRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: QueryTraceTxRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryTraceTxRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Msg", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Msg == nil { + m.Msg = &MsgEthereumTx{} + } + if err := m.Msg.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field TxIndex", wireType) + } + m.TxIndex = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.TxIndex |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field TraceConfig", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.TraceConfig == nil { + m.TraceConfig = &TraceConfig{} + } + if err := m.TraceConfig.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Predecessors", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Predecessors = append(m.Predecessors, &MsgEthereumTx{}) + if err := m.Predecessors[len(m.Predecessors)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field BlockNumber", wireType) + } + m.BlockNumber = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.BlockNumber |= int64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BlockHash", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.BlockHash = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BlockTime", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := github_com_cosmos_gogoproto_types.StdTimeUnmarshal(&m.BlockTime, dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *QueryTraceTxResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: QueryTraceTxResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryTraceTxResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Data = append(m.Data[:0], dAtA[iNdEx:postIndex]...) + if m.Data == nil { + m.Data = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *QueryTraceBlockRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: QueryTraceBlockRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryTraceBlockRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Txs", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Txs = append(m.Txs, &MsgEthereumTx{}) + if err := m.Txs[len(m.Txs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field TraceConfig", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.TraceConfig == nil { + m.TraceConfig = &TraceConfig{} + } + if err := m.TraceConfig.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field BlockNumber", wireType) + } + m.BlockNumber = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.BlockNumber |= int64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BlockHash", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.BlockHash = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BlockTime", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := github_com_cosmos_gogoproto_types.StdTimeUnmarshal(&m.BlockTime, dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *QueryTraceBlockResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: QueryTraceBlockResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryTraceBlockResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Data = append(m.Data[:0], dAtA[iNdEx:postIndex]...) + if m.Data == nil { + m.Data = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipQuery(dAtA []byte) (n int, err error) { + l := len(dAtA) + iNdEx := 0 + depth := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowQuery + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowQuery + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if dAtA[iNdEx-1] < 0x80 { + break + } + } + case 1: + iNdEx += 8 + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowQuery + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if length < 0 { + return 0, ErrInvalidLengthQuery + } + iNdEx += length + case 3: + depth++ + case 4: + if depth == 0 { + return 0, ErrUnexpectedEndOfGroupQuery + } + depth-- + case 5: + iNdEx += 4 + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + if iNdEx < 0 { + return 0, ErrInvalidLengthQuery + } + if depth == 0 { + return iNdEx, nil + } + } + return 0, io.ErrUnexpectedEOF +} + +var ( + ErrInvalidLengthQuery = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowQuery = fmt.Errorf("proto: integer overflow") + ErrUnexpectedEndOfGroupQuery = fmt.Errorf("proto: unexpected end of group") +) diff --git a/ethermint/x/evm/types/tx.pb.go b/ethermint/x/evm/types/tx.pb.go new file mode 100644 index 0000000..5a1d21d --- /dev/null +++ b/ethermint/x/evm/types/tx.pb.go @@ -0,0 +1,2910 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: ethermint/evm/v1/tx.proto + +package types + +import ( + context "context" + encoding_binary "encoding/binary" + fmt "fmt" + github_com_cosmos_cosmos_sdk_types "github.com/cosmos/cosmos-sdk/types" + grpc1 "github.com/cosmos/gogoproto/grpc" + proto "github.com/cosmos/gogoproto/proto" + _ "github.com/gogo/protobuf/gogoproto" + types "github.com/irisnet/core-sdk-go/common/codec/types" + _ "github.com/regen-network/cosmos-proto" + _ "google.golang.org/genproto/googleapis/api/annotations" + grpc "google.golang.org/grpc" + codes "google.golang.org/grpc/codes" + status "google.golang.org/grpc/status" + io "io" + math "math" + math_bits "math/bits" +) + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the proto package it is being compiled against. +// A compilation error at this line likely means your copy of the +// proto package needs to be updated. +const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package + +// MsgEthereumTx encapsulates an Ethereum transaction as an SDK message. +type MsgEthereumTx struct { + // inner transaction data + Data *types.Any `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"` + // encoded storage size of the transaction + Size_ float64 `protobuf:"fixed64,2,opt,name=size,proto3" json:"-"` + // transaction hash in hex format + Hash string `protobuf:"bytes,3,opt,name=hash,proto3" json:"hash,omitempty" rlp:"-"` + // ethereum signer address in hex format. This address value is checked + // against the address derived from the signature (V, R, S) using the + // secp256k1 elliptic curve + From string `protobuf:"bytes,4,opt,name=from,proto3" json:"from,omitempty"` + // feeGranter + FeePayer string `protobuf:"bytes,5,opt,name=fee_payer,json=feePayer,proto3" json:"fee_payer,omitempty"` +} + +func (m *MsgEthereumTx) Reset() { *m = MsgEthereumTx{} } +func (m *MsgEthereumTx) String() string { return proto.CompactTextString(m) } +func (*MsgEthereumTx) ProtoMessage() {} +func (*MsgEthereumTx) Descriptor() ([]byte, []int) { + return fileDescriptor_f75ac0a12d075f21, []int{0} +} +func (m *MsgEthereumTx) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgEthereumTx) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgEthereumTx.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *MsgEthereumTx) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgEthereumTx.Merge(m, src) +} +func (m *MsgEthereumTx) XXX_Size() int { + return m.Size() +} +func (m *MsgEthereumTx) XXX_DiscardUnknown() { + xxx_messageInfo_MsgEthereumTx.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgEthereumTx proto.InternalMessageInfo + +// LegacyTx is the transaction data of regular Ethereum transactions. +type LegacyTx struct { + // nonce corresponds to the account nonce (transaction sequence). + Nonce uint64 `protobuf:"varint,1,opt,name=nonce,proto3" json:"nonce,omitempty"` + // gas price defines the value for each gas unit + GasPrice *github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,2,opt,name=gas_price,json=gasPrice,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"gas_price,omitempty"` + // gas defines the gas limit defined for the transaction. + GasLimit uint64 `protobuf:"varint,3,opt,name=gas,proto3" json:"gas,omitempty"` + // hex formatted address of the recipient + To string `protobuf:"bytes,4,opt,name=to,proto3" json:"to,omitempty"` + // value defines the unsigned integer value of the transaction amount. + Amount *github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,5,opt,name=value,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"value,omitempty"` + // input defines the data payload bytes of the transaction. + Data []byte `protobuf:"bytes,6,opt,name=data,proto3" json:"data,omitempty"` + // v defines the signature value + V []byte `protobuf:"bytes,7,opt,name=v,proto3" json:"v,omitempty"` + // r defines the signature value + R []byte `protobuf:"bytes,8,opt,name=r,proto3" json:"r,omitempty"` + // s define the signature value + S []byte `protobuf:"bytes,9,opt,name=s,proto3" json:"s,omitempty"` +} + +func (m *LegacyTx) Reset() { *m = LegacyTx{} } +func (m *LegacyTx) String() string { return proto.CompactTextString(m) } +func (*LegacyTx) ProtoMessage() {} +func (*LegacyTx) Descriptor() ([]byte, []int) { + return fileDescriptor_f75ac0a12d075f21, []int{1} +} +func (m *LegacyTx) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *LegacyTx) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_LegacyTx.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *LegacyTx) XXX_Merge(src proto.Message) { + xxx_messageInfo_LegacyTx.Merge(m, src) +} +func (m *LegacyTx) XXX_Size() int { + return m.Size() +} +func (m *LegacyTx) XXX_DiscardUnknown() { + xxx_messageInfo_LegacyTx.DiscardUnknown(m) +} + +var xxx_messageInfo_LegacyTx proto.InternalMessageInfo + +// AccessListTx is the data of EIP-2930 access list transactions. +type AccessListTx struct { + // destination EVM chain ID + ChainID *github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,1,opt,name=chain_id,json=chainId,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"chainID"` + // nonce corresponds to the account nonce (transaction sequence). + Nonce uint64 `protobuf:"varint,2,opt,name=nonce,proto3" json:"nonce,omitempty"` + // gas price defines the value for each gas unit + GasPrice *github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,3,opt,name=gas_price,json=gasPrice,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"gas_price,omitempty"` + // gas defines the gas limit defined for the transaction. + GasLimit uint64 `protobuf:"varint,4,opt,name=gas,proto3" json:"gas,omitempty"` + // hex formatted address of the recipient + To string `protobuf:"bytes,5,opt,name=to,proto3" json:"to,omitempty"` + // value defines the unsigned integer value of the transaction amount. + Amount *github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,6,opt,name=value,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"value,omitempty"` + // input defines the data payload bytes of the transaction. + Data []byte `protobuf:"bytes,7,opt,name=data,proto3" json:"data,omitempty"` + Accesses AccessList `protobuf:"bytes,8,rep,name=accesses,proto3,castrepeated=AccessList" json:"accessList"` + // v defines the signature value + V []byte `protobuf:"bytes,9,opt,name=v,proto3" json:"v,omitempty"` + // r defines the signature value + R []byte `protobuf:"bytes,10,opt,name=r,proto3" json:"r,omitempty"` + // s define the signature value + S []byte `protobuf:"bytes,11,opt,name=s,proto3" json:"s,omitempty"` +} + +func (m *AccessListTx) Reset() { *m = AccessListTx{} } +func (m *AccessListTx) String() string { return proto.CompactTextString(m) } +func (*AccessListTx) ProtoMessage() {} +func (*AccessListTx) Descriptor() ([]byte, []int) { + return fileDescriptor_f75ac0a12d075f21, []int{2} +} +func (m *AccessListTx) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *AccessListTx) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_AccessListTx.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *AccessListTx) XXX_Merge(src proto.Message) { + xxx_messageInfo_AccessListTx.Merge(m, src) +} +func (m *AccessListTx) XXX_Size() int { + return m.Size() +} +func (m *AccessListTx) XXX_DiscardUnknown() { + xxx_messageInfo_AccessListTx.DiscardUnknown(m) +} + +var xxx_messageInfo_AccessListTx proto.InternalMessageInfo + +// DynamicFeeTx is the data of EIP-1559 dinamic fee transactions. +type DynamicFeeTx struct { + // destination EVM chain ID + ChainID *github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,1,opt,name=chain_id,json=chainId,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"chainID"` + // nonce corresponds to the account nonce (transaction sequence). + Nonce uint64 `protobuf:"varint,2,opt,name=nonce,proto3" json:"nonce,omitempty"` + // gas tip cap defines the max value for the gas tip + GasTipCap *github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,3,opt,name=gas_tip_cap,json=gasTipCap,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"gas_tip_cap,omitempty"` + // gas fee cap defines the max value for the gas fee + GasFeeCap *github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,4,opt,name=gas_fee_cap,json=gasFeeCap,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"gas_fee_cap,omitempty"` + // gas defines the gas limit defined for the transaction. + GasLimit uint64 `protobuf:"varint,5,opt,name=gas,proto3" json:"gas,omitempty"` + // hex formatted address of the recipient + To string `protobuf:"bytes,6,opt,name=to,proto3" json:"to,omitempty"` + // value defines the the transaction amount. + Amount *github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,7,opt,name=value,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"value,omitempty"` + // input defines the data payload bytes of the transaction. + Data []byte `protobuf:"bytes,8,opt,name=data,proto3" json:"data,omitempty"` + Accesses AccessList `protobuf:"bytes,9,rep,name=accesses,proto3,castrepeated=AccessList" json:"accessList"` + // v defines the signature value + V []byte `protobuf:"bytes,10,opt,name=v,proto3" json:"v,omitempty"` + // r defines the signature value + R []byte `protobuf:"bytes,11,opt,name=r,proto3" json:"r,omitempty"` + // s define the signature value + S []byte `protobuf:"bytes,12,opt,name=s,proto3" json:"s,omitempty"` +} + +func (m *DynamicFeeTx) Reset() { *m = DynamicFeeTx{} } +func (m *DynamicFeeTx) String() string { return proto.CompactTextString(m) } +func (*DynamicFeeTx) ProtoMessage() {} +func (*DynamicFeeTx) Descriptor() ([]byte, []int) { + return fileDescriptor_f75ac0a12d075f21, []int{3} +} +func (m *DynamicFeeTx) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *DynamicFeeTx) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_DynamicFeeTx.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *DynamicFeeTx) XXX_Merge(src proto.Message) { + xxx_messageInfo_DynamicFeeTx.Merge(m, src) +} +func (m *DynamicFeeTx) XXX_Size() int { + return m.Size() +} +func (m *DynamicFeeTx) XXX_DiscardUnknown() { + xxx_messageInfo_DynamicFeeTx.DiscardUnknown(m) +} + +var xxx_messageInfo_DynamicFeeTx proto.InternalMessageInfo + +type ExtensionOptionsEthereumTx struct { +} + +func (m *ExtensionOptionsEthereumTx) Reset() { *m = ExtensionOptionsEthereumTx{} } +func (m *ExtensionOptionsEthereumTx) String() string { return proto.CompactTextString(m) } +func (*ExtensionOptionsEthereumTx) ProtoMessage() {} +func (*ExtensionOptionsEthereumTx) Descriptor() ([]byte, []int) { + return fileDescriptor_f75ac0a12d075f21, []int{4} +} +func (m *ExtensionOptionsEthereumTx) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ExtensionOptionsEthereumTx) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ExtensionOptionsEthereumTx.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *ExtensionOptionsEthereumTx) XXX_Merge(src proto.Message) { + xxx_messageInfo_ExtensionOptionsEthereumTx.Merge(m, src) +} +func (m *ExtensionOptionsEthereumTx) XXX_Size() int { + return m.Size() +} +func (m *ExtensionOptionsEthereumTx) XXX_DiscardUnknown() { + xxx_messageInfo_ExtensionOptionsEthereumTx.DiscardUnknown(m) +} + +var xxx_messageInfo_ExtensionOptionsEthereumTx proto.InternalMessageInfo + +// MsgEthereumTxResponse defines the Msg/EthereumTx response type. +type MsgEthereumTxResponse struct { + // ethereum transaction hash in hex format. This hash differs from the + // Tendermint sha256 hash of the transaction bytes. See + // https://github.com/tendermint/tendermint/issues/6539 for reference + Hash string `protobuf:"bytes,1,opt,name=hash,proto3" json:"hash,omitempty"` + // logs contains the transaction hash and the proto-compatible ethereum + // logs. + Logs []*Log `protobuf:"bytes,2,rep,name=logs,proto3" json:"logs,omitempty"` + // returned data from evm function (result or data supplied with revert + // opcode) + Ret []byte `protobuf:"bytes,3,opt,name=ret,proto3" json:"ret,omitempty"` + // vm error is the error returned by vm execution + VmError string `protobuf:"bytes,4,opt,name=vm_error,json=vmError,proto3" json:"vm_error,omitempty"` + // gas consumed by the transaction + GasUsed uint64 `protobuf:"varint,5,opt,name=gas_used,json=gasUsed,proto3" json:"gas_used,omitempty"` +} + +func (m *MsgEthereumTxResponse) Reset() { *m = MsgEthereumTxResponse{} } +func (m *MsgEthereumTxResponse) String() string { return proto.CompactTextString(m) } +func (*MsgEthereumTxResponse) ProtoMessage() {} +func (*MsgEthereumTxResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_f75ac0a12d075f21, []int{5} +} +func (m *MsgEthereumTxResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgEthereumTxResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgEthereumTxResponse.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *MsgEthereumTxResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgEthereumTxResponse.Merge(m, src) +} +func (m *MsgEthereumTxResponse) XXX_Size() int { + return m.Size() +} +func (m *MsgEthereumTxResponse) XXX_DiscardUnknown() { + xxx_messageInfo_MsgEthereumTxResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgEthereumTxResponse proto.InternalMessageInfo + +func init() { + proto.RegisterType((*MsgEthereumTx)(nil), "ethermint.evm.v1.MsgEthereumTx") + proto.RegisterType((*LegacyTx)(nil), "ethermint.evm.v1.LegacyTx") + proto.RegisterType((*AccessListTx)(nil), "ethermint.evm.v1.AccessListTx") + proto.RegisterType((*DynamicFeeTx)(nil), "ethermint.evm.v1.DynamicFeeTx") + proto.RegisterType((*ExtensionOptionsEthereumTx)(nil), "ethermint.evm.v1.ExtensionOptionsEthereumTx") + proto.RegisterType((*MsgEthereumTxResponse)(nil), "ethermint.evm.v1.MsgEthereumTxResponse") +} + +func init() { proto.RegisterFile("ethermint/evm/v1/tx.proto", fileDescriptor_f75ac0a12d075f21) } + +var fileDescriptor_f75ac0a12d075f21 = []byte{ + // 881 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x55, 0x4f, 0x8f, 0xdb, 0x44, + 0x14, 0xcf, 0x24, 0x4e, 0xe2, 0x4c, 0x42, 0x55, 0x8d, 0xb6, 0x92, 0x37, 0xd0, 0x38, 0x8a, 0x04, + 0x04, 0xa4, 0xd8, 0xea, 0xd2, 0xd3, 0x9e, 0xd8, 0x74, 0xb7, 0x55, 0xab, 0x2d, 0x54, 0x56, 0xb8, + 0xd0, 0x43, 0x34, 0xeb, 0xcc, 0x3a, 0x23, 0xe2, 0x19, 0xcb, 0x33, 0xb1, 0x12, 0x24, 0x2e, 0x88, + 0x03, 0x47, 0x24, 0xbe, 0x00, 0x07, 0x4e, 0x88, 0x1b, 0x7c, 0x00, 0x8e, 0x3d, 0x56, 0x70, 0x41, + 0x1c, 0x0c, 0xca, 0x72, 0xda, 0x1b, 0x7c, 0x02, 0x34, 0x33, 0xde, 0x3f, 0x21, 0xda, 0x02, 0xa5, + 0x88, 0x53, 0xde, 0xf3, 0xef, 0xf9, 0xf9, 0xbd, 0xf7, 0xfb, 0xe5, 0x3d, 0xb8, 0x4d, 0xe4, 0x94, + 0xa4, 0x31, 0x65, 0xd2, 0x27, 0x59, 0xec, 0x67, 0xb7, 0x7c, 0xb9, 0xf0, 0x92, 0x94, 0x4b, 0x8e, + 0xae, 0x9f, 0x43, 0x1e, 0xc9, 0x62, 0x2f, 0xbb, 0xd5, 0xde, 0x8a, 0x78, 0xc4, 0x35, 0xe8, 0x2b, + 0xcb, 0xc4, 0xb5, 0x5f, 0x89, 0x38, 0x8f, 0x66, 0xc4, 0xc7, 0x09, 0xf5, 0x31, 0x63, 0x5c, 0x62, + 0x49, 0x39, 0x13, 0x05, 0xba, 0x5d, 0xa0, 0xda, 0x3b, 0x9a, 0x1f, 0xfb, 0x98, 0x2d, 0xcf, 0xa0, + 0x90, 0x8b, 0x98, 0x8b, 0xb1, 0xc9, 0x68, 0x9c, 0x02, 0x6a, 0x6f, 0x94, 0xa5, 0x4a, 0xd0, 0x58, + 0xef, 0x6b, 0x00, 0x5f, 0x7a, 0x28, 0xa2, 0x03, 0x15, 0x41, 0xe6, 0xf1, 0x68, 0x81, 0xfa, 0xd0, + 0x9a, 0x60, 0x89, 0x1d, 0xd0, 0x05, 0xfd, 0xe6, 0xce, 0x96, 0x67, 0x3e, 0xe9, 0x9d, 0x7d, 0xd2, + 0xdb, 0x63, 0xcb, 0x40, 0x47, 0xa0, 0x6d, 0x68, 0x09, 0xfa, 0x21, 0x71, 0xca, 0x5d, 0xd0, 0x07, + 0xc3, 0xea, 0x69, 0xee, 0x82, 0x41, 0xa0, 0x1f, 0x21, 0x17, 0x5a, 0x53, 0x2c, 0xa6, 0x4e, 0xa5, + 0x0b, 0xfa, 0x8d, 0x61, 0xf3, 0xf7, 0xdc, 0xad, 0xa7, 0xb3, 0x64, 0xb7, 0x37, 0xe8, 0x05, 0x1a, + 0x40, 0x08, 0x5a, 0xc7, 0x29, 0x8f, 0x1d, 0x4b, 0x05, 0x04, 0xda, 0x46, 0x2f, 0xc3, 0xc6, 0x31, + 0x21, 0xe3, 0x04, 0x2f, 0x49, 0xea, 0x54, 0x35, 0x60, 0x1f, 0x13, 0xf2, 0x48, 0xf9, 0xbb, 0xd6, + 0xa7, 0x5f, 0xb8, 0xa5, 0xde, 0x37, 0x65, 0x68, 0x1f, 0x92, 0x08, 0x87, 0xcb, 0xd1, 0x02, 0x6d, + 0xc1, 0x2a, 0xe3, 0x2c, 0x24, 0xba, 0x54, 0x2b, 0x30, 0x0e, 0xba, 0x07, 0x1b, 0x11, 0x56, 0x73, + 0xa0, 0xa1, 0x29, 0xad, 0x31, 0x7c, 0xf3, 0xa7, 0xdc, 0x7d, 0x2d, 0xa2, 0x72, 0x3a, 0x3f, 0xf2, + 0x42, 0x1e, 0x17, 0xd3, 0x29, 0x7e, 0x06, 0x62, 0xf2, 0x81, 0x2f, 0x97, 0x09, 0x11, 0xde, 0x7d, + 0x26, 0x03, 0x3b, 0xc2, 0xe2, 0x91, 0x7a, 0x17, 0x75, 0x60, 0x25, 0xc2, 0x42, 0xb7, 0x60, 0x0d, + 0x5b, 0xab, 0xdc, 0xb5, 0xef, 0x61, 0x71, 0x48, 0x63, 0x2a, 0x03, 0x05, 0xa0, 0x6b, 0xb0, 0x2c, + 0x79, 0xd1, 0x40, 0x59, 0x72, 0xf4, 0x00, 0x56, 0x33, 0x3c, 0x9b, 0x13, 0x53, 0xfa, 0xf0, 0xf6, + 0xdf, 0xff, 0xe8, 0x2a, 0x77, 0x6b, 0x7b, 0x31, 0x9f, 0x33, 0x19, 0x98, 0x14, 0x6a, 0x3c, 0x9a, + 0x84, 0x5a, 0x17, 0xf4, 0x5b, 0xc5, 0xb8, 0x5b, 0x10, 0x64, 0x4e, 0x5d, 0x3f, 0x00, 0x99, 0xf2, + 0x52, 0xc7, 0x36, 0x5e, 0xaa, 0x3c, 0xe1, 0x34, 0x8c, 0x27, 0x76, 0xaf, 0xa9, 0x59, 0x7d, 0xff, + 0xed, 0xa0, 0x36, 0x5a, 0xec, 0x63, 0x89, 0x7b, 0xbf, 0x55, 0x60, 0x6b, 0x2f, 0x0c, 0x89, 0x10, + 0x87, 0x54, 0xc8, 0xd1, 0x02, 0x3d, 0x86, 0x76, 0x38, 0xc5, 0x94, 0x8d, 0xe9, 0x44, 0x0f, 0xaf, + 0x31, 0x7c, 0xfb, 0x1f, 0x55, 0x5b, 0xbf, 0xa3, 0xde, 0xbe, 0xbf, 0x7f, 0x9a, 0xbb, 0xf5, 0xd0, + 0x98, 0x41, 0x61, 0x4c, 0x2e, 0x68, 0x29, 0x5f, 0x49, 0x4b, 0xe5, 0xdf, 0xd3, 0x62, 0x3d, 0x9b, + 0x96, 0xea, 0x26, 0x2d, 0xb5, 0x17, 0x47, 0x4b, 0xfd, 0x12, 0x2d, 0x8f, 0xa1, 0x8d, 0xf5, 0x6c, + 0x89, 0x70, 0xec, 0x6e, 0xa5, 0xdf, 0xdc, 0xb9, 0xe9, 0xfd, 0xf9, 0xcf, 0xee, 0x99, 0xe9, 0x8f, + 0xe6, 0xc9, 0x8c, 0x0c, 0xbb, 0x4f, 0x72, 0xb7, 0x74, 0x9a, 0xbb, 0x10, 0x9f, 0x53, 0xf2, 0xd5, + 0xcf, 0x2e, 0xbc, 0x20, 0x28, 0x38, 0x4f, 0x68, 0x38, 0x6f, 0xac, 0x71, 0x0e, 0xd7, 0x38, 0x6f, + 0x5e, 0xc5, 0xf9, 0x77, 0x16, 0x6c, 0xed, 0x2f, 0x19, 0x8e, 0x69, 0x78, 0x97, 0x90, 0xff, 0x87, + 0xf3, 0x07, 0xb0, 0xa9, 0x38, 0x97, 0x34, 0x19, 0x87, 0x38, 0x79, 0x0e, 0xd6, 0x95, 0x64, 0x46, + 0x34, 0xb9, 0x83, 0x93, 0xb3, 0x5c, 0x6a, 0x41, 0xa8, 0x5c, 0xd6, 0x73, 0xe5, 0xba, 0x4b, 0x88, + 0xca, 0x55, 0x48, 0xa8, 0xfa, 0x6c, 0x09, 0xd5, 0x36, 0x25, 0x54, 0x7f, 0x71, 0x12, 0xb2, 0xaf, + 0x90, 0x50, 0xe3, 0x3f, 0x91, 0x10, 0x5c, 0x93, 0x50, 0x73, 0x4d, 0x42, 0xad, 0xab, 0x24, 0xd4, + 0x83, 0xed, 0x83, 0x85, 0x24, 0x4c, 0x50, 0xce, 0xde, 0x4d, 0xf4, 0x1d, 0xba, 0xb8, 0x13, 0xc5, + 0x42, 0xfe, 0x12, 0xc0, 0x1b, 0x6b, 0xf7, 0x23, 0x20, 0x22, 0xe1, 0x4c, 0xe8, 0x46, 0xf5, 0x09, + 0x00, 0x66, 0xc3, 0xeb, 0xad, 0xff, 0x06, 0xb4, 0x66, 0x3c, 0x12, 0x4e, 0x59, 0x37, 0x79, 0x63, + 0xb3, 0xc9, 0x43, 0x1e, 0x05, 0x3a, 0x04, 0x5d, 0x87, 0x95, 0x94, 0x48, 0xad, 0x99, 0x56, 0xa0, + 0x4c, 0xb4, 0x0d, 0xed, 0x2c, 0x1e, 0x93, 0x34, 0xe5, 0x69, 0xb1, 0x75, 0xeb, 0x59, 0x7c, 0xa0, + 0x5c, 0x05, 0x29, 0x71, 0xcc, 0x05, 0x99, 0x18, 0x56, 0x83, 0x7a, 0x84, 0xc5, 0x7b, 0x82, 0x4c, + 0x4c, 0x99, 0x3b, 0x9f, 0x00, 0x58, 0x79, 0x28, 0x22, 0xf4, 0x11, 0x84, 0x97, 0x4e, 0x9d, 0xbb, + 0x59, 0xc0, 0x5a, 0x2f, 0xed, 0xd7, 0xff, 0x22, 0xe0, 0xac, 0xd9, 0xde, 0xab, 0x1f, 0xff, 0xf0, + 0xeb, 0xe7, 0x65, 0xb7, 0x77, 0xd3, 0xdf, 0xbc, 0xb5, 0x45, 0xf4, 0x58, 0x2e, 0x86, 0xef, 0x3c, + 0x59, 0x75, 0xc0, 0xd3, 0x55, 0x07, 0xfc, 0xb2, 0xea, 0x80, 0xcf, 0x4e, 0x3a, 0xa5, 0xa7, 0x27, + 0x9d, 0xd2, 0x8f, 0x27, 0x9d, 0xd2, 0xfb, 0xb7, 0x2f, 0xe9, 0x89, 0xa6, 0x54, 0x30, 0x22, 0xfd, + 0x90, 0xa7, 0x44, 0xc9, 0x69, 0x10, 0xf1, 0x4b, 0x69, 0x17, 0x3a, 0xb1, 0x56, 0xd8, 0x51, 0x4d, + 0x5f, 0xe5, 0xb7, 0xfe, 0x08, 0x00, 0x00, 0xff, 0xff, 0xc8, 0xfb, 0x08, 0x4a, 0x79, 0x08, 0x00, + 0x00, +} + +// Reference imports to suppress errors if they are not otherwise used. +var _ context.Context +var _ grpc.ClientConn + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the grpc package it is being compiled against. +const _ = grpc.SupportPackageIsVersion4 + +// MsgClient is the client API for Msg service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. +type MsgClient interface { + // EthereumTx defines a method submitting Ethereum transactions. + EthereumTx(ctx context.Context, in *MsgEthereumTx, opts ...grpc.CallOption) (*MsgEthereumTxResponse, error) +} + +type msgClient struct { + cc grpc1.ClientConn +} + +func NewMsgClient(cc grpc1.ClientConn) MsgClient { + return &msgClient{cc} +} + +func (c *msgClient) EthereumTx(ctx context.Context, in *MsgEthereumTx, opts ...grpc.CallOption) (*MsgEthereumTxResponse, error) { + out := new(MsgEthereumTxResponse) + err := c.cc.Invoke(ctx, "/ethermint.evm.v1.Msg/EthereumTx", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +// MsgServer is the server API for Msg service. +type MsgServer interface { + // EthereumTx defines a method submitting Ethereum transactions. + EthereumTx(context.Context, *MsgEthereumTx) (*MsgEthereumTxResponse, error) +} + +// UnimplementedMsgServer can be embedded to have forward compatible implementations. +type UnimplementedMsgServer struct { +} + +func (*UnimplementedMsgServer) EthereumTx(ctx context.Context, req *MsgEthereumTx) (*MsgEthereumTxResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method EthereumTx not implemented") +} + +func RegisterMsgServer(s grpc1.Server, srv MsgServer) { + s.RegisterService(&_Msg_serviceDesc, srv) +} + +func _Msg_EthereumTx_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgEthereumTx) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(MsgServer).EthereumTx(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/ethermint.evm.v1.Msg/EthereumTx", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).EthereumTx(ctx, req.(*MsgEthereumTx)) + } + return interceptor(ctx, in, info, handler) +} + +var _Msg_serviceDesc = grpc.ServiceDesc{ + ServiceName: "ethermint.evm.v1.Msg", + HandlerType: (*MsgServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "EthereumTx", + Handler: _Msg_EthereumTx_Handler, + }, + }, + Streams: []grpc.StreamDesc{}, + Metadata: "ethermint/evm/v1/tx.proto", +} + +func (m *MsgEthereumTx) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *MsgEthereumTx) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgEthereumTx) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.FeePayer) > 0 { + i -= len(m.FeePayer) + copy(dAtA[i:], m.FeePayer) + i = encodeVarintTx(dAtA, i, uint64(len(m.FeePayer))) + i-- + dAtA[i] = 0x2a + } + if len(m.From) > 0 { + i -= len(m.From) + copy(dAtA[i:], m.From) + i = encodeVarintTx(dAtA, i, uint64(len(m.From))) + i-- + dAtA[i] = 0x22 + } + if len(m.Hash) > 0 { + i -= len(m.Hash) + copy(dAtA[i:], m.Hash) + i = encodeVarintTx(dAtA, i, uint64(len(m.Hash))) + i-- + dAtA[i] = 0x1a + } + if m.Size_ != 0 { + i -= 8 + encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.Size_)))) + i-- + dAtA[i] = 0x11 + } + if m.Data != nil { + { + size, err := m.Data.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTx(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *LegacyTx) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *LegacyTx) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *LegacyTx) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.S) > 0 { + i -= len(m.S) + copy(dAtA[i:], m.S) + i = encodeVarintTx(dAtA, i, uint64(len(m.S))) + i-- + dAtA[i] = 0x4a + } + if len(m.R) > 0 { + i -= len(m.R) + copy(dAtA[i:], m.R) + i = encodeVarintTx(dAtA, i, uint64(len(m.R))) + i-- + dAtA[i] = 0x42 + } + if len(m.V) > 0 { + i -= len(m.V) + copy(dAtA[i:], m.V) + i = encodeVarintTx(dAtA, i, uint64(len(m.V))) + i-- + dAtA[i] = 0x3a + } + if len(m.Data) > 0 { + i -= len(m.Data) + copy(dAtA[i:], m.Data) + i = encodeVarintTx(dAtA, i, uint64(len(m.Data))) + i-- + dAtA[i] = 0x32 + } + if m.Amount != nil { + { + size := m.Amount.Size() + i -= size + if _, err := m.Amount.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + i = encodeVarintTx(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x2a + } + if len(m.To) > 0 { + i -= len(m.To) + copy(dAtA[i:], m.To) + i = encodeVarintTx(dAtA, i, uint64(len(m.To))) + i-- + dAtA[i] = 0x22 + } + if m.GasLimit != 0 { + i = encodeVarintTx(dAtA, i, uint64(m.GasLimit)) + i-- + dAtA[i] = 0x18 + } + if m.GasPrice != nil { + { + size := m.GasPrice.Size() + i -= size + if _, err := m.GasPrice.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + i = encodeVarintTx(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if m.Nonce != 0 { + i = encodeVarintTx(dAtA, i, uint64(m.Nonce)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *AccessListTx) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *AccessListTx) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *AccessListTx) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.S) > 0 { + i -= len(m.S) + copy(dAtA[i:], m.S) + i = encodeVarintTx(dAtA, i, uint64(len(m.S))) + i-- + dAtA[i] = 0x5a + } + if len(m.R) > 0 { + i -= len(m.R) + copy(dAtA[i:], m.R) + i = encodeVarintTx(dAtA, i, uint64(len(m.R))) + i-- + dAtA[i] = 0x52 + } + if len(m.V) > 0 { + i -= len(m.V) + copy(dAtA[i:], m.V) + i = encodeVarintTx(dAtA, i, uint64(len(m.V))) + i-- + dAtA[i] = 0x4a + } + if len(m.Accesses) > 0 { + for iNdEx := len(m.Accesses) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Accesses[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTx(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x42 + } + } + if len(m.Data) > 0 { + i -= len(m.Data) + copy(dAtA[i:], m.Data) + i = encodeVarintTx(dAtA, i, uint64(len(m.Data))) + i-- + dAtA[i] = 0x3a + } + if m.Amount != nil { + { + size := m.Amount.Size() + i -= size + if _, err := m.Amount.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + i = encodeVarintTx(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x32 + } + if len(m.To) > 0 { + i -= len(m.To) + copy(dAtA[i:], m.To) + i = encodeVarintTx(dAtA, i, uint64(len(m.To))) + i-- + dAtA[i] = 0x2a + } + if m.GasLimit != 0 { + i = encodeVarintTx(dAtA, i, uint64(m.GasLimit)) + i-- + dAtA[i] = 0x20 + } + if m.GasPrice != nil { + { + size := m.GasPrice.Size() + i -= size + if _, err := m.GasPrice.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + i = encodeVarintTx(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } + if m.Nonce != 0 { + i = encodeVarintTx(dAtA, i, uint64(m.Nonce)) + i-- + dAtA[i] = 0x10 + } + if m.ChainID != nil { + { + size := m.ChainID.Size() + i -= size + if _, err := m.ChainID.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + i = encodeVarintTx(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *DynamicFeeTx) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *DynamicFeeTx) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *DynamicFeeTx) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.S) > 0 { + i -= len(m.S) + copy(dAtA[i:], m.S) + i = encodeVarintTx(dAtA, i, uint64(len(m.S))) + i-- + dAtA[i] = 0x62 + } + if len(m.R) > 0 { + i -= len(m.R) + copy(dAtA[i:], m.R) + i = encodeVarintTx(dAtA, i, uint64(len(m.R))) + i-- + dAtA[i] = 0x5a + } + if len(m.V) > 0 { + i -= len(m.V) + copy(dAtA[i:], m.V) + i = encodeVarintTx(dAtA, i, uint64(len(m.V))) + i-- + dAtA[i] = 0x52 + } + if len(m.Accesses) > 0 { + for iNdEx := len(m.Accesses) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Accesses[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTx(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x4a + } + } + if len(m.Data) > 0 { + i -= len(m.Data) + copy(dAtA[i:], m.Data) + i = encodeVarintTx(dAtA, i, uint64(len(m.Data))) + i-- + dAtA[i] = 0x42 + } + if m.Amount != nil { + { + size := m.Amount.Size() + i -= size + if _, err := m.Amount.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + i = encodeVarintTx(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x3a + } + if len(m.To) > 0 { + i -= len(m.To) + copy(dAtA[i:], m.To) + i = encodeVarintTx(dAtA, i, uint64(len(m.To))) + i-- + dAtA[i] = 0x32 + } + if m.GasLimit != 0 { + i = encodeVarintTx(dAtA, i, uint64(m.GasLimit)) + i-- + dAtA[i] = 0x28 + } + if m.GasFeeCap != nil { + { + size := m.GasFeeCap.Size() + i -= size + if _, err := m.GasFeeCap.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + i = encodeVarintTx(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x22 + } + if m.GasTipCap != nil { + { + size := m.GasTipCap.Size() + i -= size + if _, err := m.GasTipCap.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + i = encodeVarintTx(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } + if m.Nonce != 0 { + i = encodeVarintTx(dAtA, i, uint64(m.Nonce)) + i-- + dAtA[i] = 0x10 + } + if m.ChainID != nil { + { + size := m.ChainID.Size() + i -= size + if _, err := m.ChainID.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + i = encodeVarintTx(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ExtensionOptionsEthereumTx) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ExtensionOptionsEthereumTx) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ExtensionOptionsEthereumTx) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + return len(dAtA) - i, nil +} + +func (m *MsgEthereumTxResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *MsgEthereumTxResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgEthereumTxResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.GasUsed != 0 { + i = encodeVarintTx(dAtA, i, uint64(m.GasUsed)) + i-- + dAtA[i] = 0x28 + } + if len(m.VmError) > 0 { + i -= len(m.VmError) + copy(dAtA[i:], m.VmError) + i = encodeVarintTx(dAtA, i, uint64(len(m.VmError))) + i-- + dAtA[i] = 0x22 + } + if len(m.Ret) > 0 { + i -= len(m.Ret) + copy(dAtA[i:], m.Ret) + i = encodeVarintTx(dAtA, i, uint64(len(m.Ret))) + i-- + dAtA[i] = 0x1a + } + if len(m.Logs) > 0 { + for iNdEx := len(m.Logs) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Logs[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTx(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + } + if len(m.Hash) > 0 { + i -= len(m.Hash) + copy(dAtA[i:], m.Hash) + i = encodeVarintTx(dAtA, i, uint64(len(m.Hash))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func encodeVarintTx(dAtA []byte, offset int, v uint64) int { + offset -= sovTx(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} +func (m *MsgEthereumTx) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Data != nil { + l = m.Data.Size() + n += 1 + l + sovTx(uint64(l)) + } + if m.Size_ != 0 { + n += 9 + } + l = len(m.Hash) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = len(m.From) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = len(m.FeePayer) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + return n +} + +func (m *LegacyTx) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Nonce != 0 { + n += 1 + sovTx(uint64(m.Nonce)) + } + if m.GasPrice != nil { + l = m.GasPrice.Size() + n += 1 + l + sovTx(uint64(l)) + } + if m.GasLimit != 0 { + n += 1 + sovTx(uint64(m.GasLimit)) + } + l = len(m.To) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + if m.Amount != nil { + l = m.Amount.Size() + n += 1 + l + sovTx(uint64(l)) + } + l = len(m.Data) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = len(m.V) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = len(m.R) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = len(m.S) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + return n +} + +func (m *AccessListTx) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.ChainID != nil { + l = m.ChainID.Size() + n += 1 + l + sovTx(uint64(l)) + } + if m.Nonce != 0 { + n += 1 + sovTx(uint64(m.Nonce)) + } + if m.GasPrice != nil { + l = m.GasPrice.Size() + n += 1 + l + sovTx(uint64(l)) + } + if m.GasLimit != 0 { + n += 1 + sovTx(uint64(m.GasLimit)) + } + l = len(m.To) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + if m.Amount != nil { + l = m.Amount.Size() + n += 1 + l + sovTx(uint64(l)) + } + l = len(m.Data) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + if len(m.Accesses) > 0 { + for _, e := range m.Accesses { + l = e.Size() + n += 1 + l + sovTx(uint64(l)) + } + } + l = len(m.V) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = len(m.R) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = len(m.S) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + return n +} + +func (m *DynamicFeeTx) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.ChainID != nil { + l = m.ChainID.Size() + n += 1 + l + sovTx(uint64(l)) + } + if m.Nonce != 0 { + n += 1 + sovTx(uint64(m.Nonce)) + } + if m.GasTipCap != nil { + l = m.GasTipCap.Size() + n += 1 + l + sovTx(uint64(l)) + } + if m.GasFeeCap != nil { + l = m.GasFeeCap.Size() + n += 1 + l + sovTx(uint64(l)) + } + if m.GasLimit != 0 { + n += 1 + sovTx(uint64(m.GasLimit)) + } + l = len(m.To) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + if m.Amount != nil { + l = m.Amount.Size() + n += 1 + l + sovTx(uint64(l)) + } + l = len(m.Data) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + if len(m.Accesses) > 0 { + for _, e := range m.Accesses { + l = e.Size() + n += 1 + l + sovTx(uint64(l)) + } + } + l = len(m.V) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = len(m.R) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = len(m.S) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + return n +} + +func (m *ExtensionOptionsEthereumTx) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *MsgEthereumTxResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Hash) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + if len(m.Logs) > 0 { + for _, e := range m.Logs { + l = e.Size() + n += 1 + l + sovTx(uint64(l)) + } + } + l = len(m.Ret) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = len(m.VmError) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + if m.GasUsed != 0 { + n += 1 + sovTx(uint64(m.GasUsed)) + } + return n +} + +func sovTx(x uint64) (n int) { + return (math_bits.Len64(x|1) + 6) / 7 +} +func sozTx(x uint64) (n int) { + return sovTx(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *MsgEthereumTx) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: MsgEthereumTx: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgEthereumTx: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Data == nil { + m.Data = &types.Any{} + } + if err := m.Data.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Size_", wireType) + } + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:])) + iNdEx += 8 + m.Size_ = float64(math.Float64frombits(v)) + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Hash", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Hash = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field From", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.From = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FeePayer", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.FeePayer = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTx(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTx + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *LegacyTx) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: LegacyTx: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: LegacyTx: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Nonce", wireType) + } + m.Nonce = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Nonce |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field GasPrice", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + var v github_com_cosmos_cosmos_sdk_types.Int + m.GasPrice = &v + if err := m.GasPrice.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field GasLimit", wireType) + } + m.GasLimit = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.GasLimit |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field To", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.To = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Amount", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + var v github_com_cosmos_cosmos_sdk_types.Int + m.Amount = &v + if err := m.Amount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Data = append(m.Data[:0], dAtA[iNdEx:postIndex]...) + if m.Data == nil { + m.Data = []byte{} + } + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field V", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.V = append(m.V[:0], dAtA[iNdEx:postIndex]...) + if m.V == nil { + m.V = []byte{} + } + iNdEx = postIndex + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field R", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.R = append(m.R[:0], dAtA[iNdEx:postIndex]...) + if m.R == nil { + m.R = []byte{} + } + iNdEx = postIndex + case 9: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field S", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.S = append(m.S[:0], dAtA[iNdEx:postIndex]...) + if m.S == nil { + m.S = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTx(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTx + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *AccessListTx) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: AccessListTx: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: AccessListTx: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ChainID", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + var v github_com_cosmos_cosmos_sdk_types.Int + m.ChainID = &v + if err := m.ChainID.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Nonce", wireType) + } + m.Nonce = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Nonce |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field GasPrice", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + var v github_com_cosmos_cosmos_sdk_types.Int + m.GasPrice = &v + if err := m.GasPrice.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field GasLimit", wireType) + } + m.GasLimit = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.GasLimit |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field To", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.To = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Amount", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + var v github_com_cosmos_cosmos_sdk_types.Int + m.Amount = &v + if err := m.Amount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Data = append(m.Data[:0], dAtA[iNdEx:postIndex]...) + if m.Data == nil { + m.Data = []byte{} + } + iNdEx = postIndex + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Accesses", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Accesses = append(m.Accesses, AccessTuple{}) + if err := m.Accesses[len(m.Accesses)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 9: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field V", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.V = append(m.V[:0], dAtA[iNdEx:postIndex]...) + if m.V == nil { + m.V = []byte{} + } + iNdEx = postIndex + case 10: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field R", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.R = append(m.R[:0], dAtA[iNdEx:postIndex]...) + if m.R == nil { + m.R = []byte{} + } + iNdEx = postIndex + case 11: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field S", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.S = append(m.S[:0], dAtA[iNdEx:postIndex]...) + if m.S == nil { + m.S = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTx(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTx + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *DynamicFeeTx) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: DynamicFeeTx: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: DynamicFeeTx: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ChainID", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + var v github_com_cosmos_cosmos_sdk_types.Int + m.ChainID = &v + if err := m.ChainID.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Nonce", wireType) + } + m.Nonce = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Nonce |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field GasTipCap", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + var v github_com_cosmos_cosmos_sdk_types.Int + m.GasTipCap = &v + if err := m.GasTipCap.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field GasFeeCap", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + var v github_com_cosmos_cosmos_sdk_types.Int + m.GasFeeCap = &v + if err := m.GasFeeCap.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field GasLimit", wireType) + } + m.GasLimit = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.GasLimit |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field To", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.To = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Amount", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + var v github_com_cosmos_cosmos_sdk_types.Int + m.Amount = &v + if err := m.Amount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Data = append(m.Data[:0], dAtA[iNdEx:postIndex]...) + if m.Data == nil { + m.Data = []byte{} + } + iNdEx = postIndex + case 9: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Accesses", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Accesses = append(m.Accesses, AccessTuple{}) + if err := m.Accesses[len(m.Accesses)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 10: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field V", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.V = append(m.V[:0], dAtA[iNdEx:postIndex]...) + if m.V == nil { + m.V = []byte{} + } + iNdEx = postIndex + case 11: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field R", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.R = append(m.R[:0], dAtA[iNdEx:postIndex]...) + if m.R == nil { + m.R = []byte{} + } + iNdEx = postIndex + case 12: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field S", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.S = append(m.S[:0], dAtA[iNdEx:postIndex]...) + if m.S == nil { + m.S = []byte{} + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTx(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTx + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ExtensionOptionsEthereumTx) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ExtensionOptionsEthereumTx: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ExtensionOptionsEthereumTx: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipTx(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTx + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *MsgEthereumTxResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: MsgEthereumTxResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgEthereumTxResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Hash", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Hash = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Logs", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Logs = append(m.Logs, &Log{}) + if err := m.Logs[len(m.Logs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Ret", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Ret = append(m.Ret[:0], dAtA[iNdEx:postIndex]...) + if m.Ret == nil { + m.Ret = []byte{} + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field VmError", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.VmError = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 5: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field GasUsed", wireType) + } + m.GasUsed = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.GasUsed |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipTx(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTx + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipTx(dAtA []byte) (n int, err error) { + l := len(dAtA) + iNdEx := 0 + depth := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowTx + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowTx + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if dAtA[iNdEx-1] < 0x80 { + break + } + } + case 1: + iNdEx += 8 + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowTx + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if length < 0 { + return 0, ErrInvalidLengthTx + } + iNdEx += length + case 3: + depth++ + case 4: + if depth == 0 { + return 0, ErrUnexpectedEndOfGroupTx + } + depth-- + case 5: + iNdEx += 4 + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + if iNdEx < 0 { + return 0, ErrInvalidLengthTx + } + if depth == 0 { + return iNdEx, nil + } + } + return 0, io.ErrUnexpectedEOF +} + +var ( + ErrInvalidLengthTx = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowTx = fmt.Errorf("proto: integer overflow") + ErrUnexpectedEndOfGroupTx = fmt.Errorf("proto: unexpected end of group") +) diff --git a/ethermint/x/evm/types/tx_data.go b/ethermint/x/evm/types/tx_data.go new file mode 100644 index 0000000..316a668 --- /dev/null +++ b/ethermint/x/evm/types/tx_data.go @@ -0,0 +1,120 @@ +package types + +import ( + "math/big" + + "github.com/ethereum/go-ethereum/common" + ethtypes "github.com/ethereum/go-ethereum/core/types" +) + +var ( + _ TxData = &LegacyTx{} + _ TxData = &AccessListTx{} + _ TxData = &DynamicFeeTx{} +) + +// TxData implements the Ethereum transaction tx structure. It is used +// solely as intended in Ethereum abiding by the protocol. +type TxData interface { + // TODO: embed ethtypes.TxData. See https://github.com/ethereum/go-ethereum/issues/23154 + + TxType() byte + Copy() TxData + GetChainID() *big.Int + GetAccessList() ethtypes.AccessList + GetData() []byte + GetNonce() uint64 + GetGas() uint64 + GetGasPrice() *big.Int + GetGasTipCap() *big.Int + GetGasFeeCap() *big.Int + GetValue() *big.Int + GetTo() *common.Address + + GetRawSignatureValues() (v, r, s *big.Int) + SetSignatureValues(chainID, v, r, s *big.Int) + + AsEthereumData() ethtypes.TxData + Validate() error + + // static fee + Fee() *big.Int + Cost() *big.Int + + // effective fee according to current base fee + EffectiveFee(baseFee *big.Int) *big.Int + EffectiveCost(baseFee *big.Int) *big.Int +} + +func NewTxDataFromTx(tx *ethtypes.Transaction) (TxData, error) { + var txData TxData + var err error + switch tx.Type() { + case ethtypes.DynamicFeeTxType: + txData, err = newDynamicFeeTx(tx) + case ethtypes.AccessListTxType: + txData, err = newAccessListTx(tx) + default: + txData, err = newLegacyTx(tx) + } + if err != nil { + return nil, err + } + + return txData, nil +} + +// DeriveChainID derives the chain id from the given v parameter. +// +// CONTRACT: v value is either: +// +// - {0,1} + CHAIN_ID * 2 + 35, if EIP155 is used +// - {0,1} + 27, otherwise +// +// Ref: https://github.com/ethereum/EIPs/blob/master/EIPS/eip-155.md +func DeriveChainID(v *big.Int) *big.Int { + if v == nil || v.Sign() < 1 { + return nil + } + + if v.BitLen() <= 64 { + v := v.Uint64() + if v == 27 || v == 28 { + return new(big.Int) + } + + if v < 35 { + return nil + } + + // V MUST be of the form {0,1} + CHAIN_ID * 2 + 35 + return new(big.Int).SetUint64((v - 35) / 2) + } + v = new(big.Int).Sub(v, big.NewInt(35)) + return v.Div(v, big.NewInt(2)) +} + +func rawSignatureValues(vBz, rBz, sBz []byte) (v, r, s *big.Int) { + if len(vBz) > 0 { + v = new(big.Int).SetBytes(vBz) + } + if len(rBz) > 0 { + r = new(big.Int).SetBytes(rBz) + } + if len(sBz) > 0 { + s = new(big.Int).SetBytes(sBz) + } + return v, r, s +} + +func fee(gasPrice *big.Int, gas uint64) *big.Int { + gasLimit := new(big.Int).SetUint64(gas) + return new(big.Int).Mul(gasPrice, gasLimit) +} + +func cost(fee, value *big.Int) *big.Int { + if value != nil { + return new(big.Int).Add(fee, value) + } + return fee +} diff --git a/ethermint/x/evm/types/utils.go b/ethermint/x/evm/types/utils.go new file mode 100644 index 0000000..bd20221 --- /dev/null +++ b/ethermint/x/evm/types/utils.go @@ -0,0 +1,109 @@ +package types + +import ( + "fmt" + "math/big" + + sdktypes "github.com/irisnet/core-sdk-go/types" + + "github.com/gogo/protobuf/proto" + + sdk "github.com/cosmos/cosmos-sdk/types" + sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" + + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/crypto" +) + +const maxBitLen = 256 + +var EmptyCodeHash = crypto.Keccak256(nil) + +// DecodeTxResponse decodes an protobuf-encoded byte slice into TxResponse +func DecodeTxResponse(in []byte) (*MsgEthereumTxResponse, error) { + var txMsgData sdk.TxMsgData + if err := proto.Unmarshal(in, &txMsgData); err != nil { + return nil, err + } + + data := txMsgData.GetData() + if len(data) == 0 { + return &MsgEthereumTxResponse{}, nil + } + + var res MsgEthereumTxResponse + + err := proto.Unmarshal(data[0].GetData(), &res) + if err != nil { + return nil, sdkerrors.Wrap(err, "failed to unmarshal tx response message data") + } + + return &res, nil +} + +// EncodeTransactionLogs encodes TransactionLogs slice into a protobuf-encoded byte slice. +func EncodeTransactionLogs(res *TransactionLogs) ([]byte, error) { + return proto.Marshal(res) +} + +// DecodeTxResponse decodes an protobuf-encoded byte slice into TransactionLogs +func DecodeTransactionLogs(data []byte) (TransactionLogs, error) { + var logs TransactionLogs + err := proto.Unmarshal(data, &logs) + if err != nil { + return TransactionLogs{}, err + } + return logs, nil +} + +// UnwrapEthereumMsg extract MsgEthereumTx from wrapping sdk.Tx +func UnwrapEthereumMsg(tx *sdktypes.Tx, ethHash common.Hash) (*MsgEthereumTx, error) { + if tx == nil { + return nil, fmt.Errorf("invalid tx: nil") + } + + for _, msg := range (*tx).GetMsgs() { + ethMsg, ok := msg.(*MsgEthereumTx) + if !ok { + return nil, fmt.Errorf("invalid tx type: %T", tx) + } + if ethMsg.AsTransaction().Hash() == ethHash { + return ethMsg, nil + } + } + + return nil, fmt.Errorf("eth tx not found: %s", ethHash) +} + +// BinSearch execute the binary search and hone in on an executable gas limit +func BinSearch(lo, hi uint64, executable func(uint64) (bool, *MsgEthereumTxResponse, error)) (uint64, error) { + for lo+1 < hi { + mid := (hi + lo) / 2 + failed, _, err := executable(mid) + // If the error is not nil(consensus error), it means the provided message + // call or transaction will never be accepted no matter how much gas it is + // assigned. Return the error directly, don't struggle any more. + if err != nil { + return 0, err + } + if failed { + lo = mid + } else { + hi = mid + } + } + return hi, nil +} + +// SafeNewIntFromBigInt constructs Int from big.Int, return error if more than 256bits +func SafeNewIntFromBigInt(i *big.Int) (sdk.Int, error) { + if !IsValidInt256(i) { + return sdk.NewInt(0), fmt.Errorf("big int out of bound: %s", i) + } + return sdk.NewIntFromBigInt(i), nil +} + +// IsValidInt256 check the bound of 256 bit number +func IsValidInt256(i *big.Int) bool { + return i == nil || i.BitLen() <= maxBitLen +} diff --git a/feegrant/feegrant.pb.go b/feegrant/feegrant.pb.go index b61e789..229a9bc 100644 --- a/feegrant/feegrant.pb.go +++ b/feegrant/feegrant.pb.go @@ -5,9 +5,9 @@ package feegrant import ( fmt "fmt" + proto "github.com/cosmos/gogoproto/proto" + github_com_cosmos_gogoproto_types "github.com/cosmos/gogoproto/types" _ "github.com/gogo/protobuf/gogoproto" - proto "github.com/gogo/protobuf/proto" - github_com_gogo_protobuf_types "github.com/gogo/protobuf/types" types1 "github.com/irisnet/core-sdk-go/common/codec/types" github_com_irisnet_core_sdk_go_types "github.com/irisnet/core-sdk-go/types" types "github.com/irisnet/core-sdk-go/types" @@ -354,7 +354,7 @@ func (m *BasicAllowance) MarshalToSizedBuffer(dAtA []byte) (int, error) { var l int _ = l if m.Expiration != nil { - n1, err1 := github_com_gogo_protobuf_types.StdTimeMarshalTo(*m.Expiration, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(*m.Expiration):]) + n1, err1 := github_com_cosmos_gogoproto_types.StdTimeMarshalTo(*m.Expiration, dAtA[i-github_com_cosmos_gogoproto_types.SizeOfStdTime(*m.Expiration):]) if err1 != nil { return 0, err1 } @@ -400,7 +400,7 @@ func (m *PeriodicAllowance) MarshalToSizedBuffer(dAtA []byte) (int, error) { _ = i var l int _ = l - n2, err2 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.PeriodReset, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.PeriodReset):]) + n2, err2 := github_com_cosmos_gogoproto_types.StdTimeMarshalTo(m.PeriodReset, dAtA[i-github_com_cosmos_gogoproto_types.SizeOfStdTime(m.PeriodReset):]) if err2 != nil { return 0, err2 } @@ -436,7 +436,7 @@ func (m *PeriodicAllowance) MarshalToSizedBuffer(dAtA []byte) (int, error) { dAtA[i] = 0x1a } } - n3, err3 := github_com_gogo_protobuf_types.StdDurationMarshalTo(m.Period, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdDuration(m.Period):]) + n3, err3 := github_com_cosmos_gogoproto_types.StdDurationMarshalTo(m.Period, dAtA[i-github_com_cosmos_gogoproto_types.SizeOfStdDuration(m.Period):]) if err3 != nil { return 0, err3 } @@ -574,7 +574,7 @@ func (m *BasicAllowance) Size() (n int) { } } if m.Expiration != nil { - l = github_com_gogo_protobuf_types.SizeOfStdTime(*m.Expiration) + l = github_com_cosmos_gogoproto_types.SizeOfStdTime(*m.Expiration) n += 1 + l + sovFeegrant(uint64(l)) } return n @@ -588,7 +588,7 @@ func (m *PeriodicAllowance) Size() (n int) { _ = l l = m.Basic.Size() n += 1 + l + sovFeegrant(uint64(l)) - l = github_com_gogo_protobuf_types.SizeOfStdDuration(m.Period) + l = github_com_cosmos_gogoproto_types.SizeOfStdDuration(m.Period) n += 1 + l + sovFeegrant(uint64(l)) if len(m.PeriodSpendLimit) > 0 { for _, e := range m.PeriodSpendLimit { @@ -602,7 +602,7 @@ func (m *PeriodicAllowance) Size() (n int) { n += 1 + l + sovFeegrant(uint64(l)) } } - l = github_com_gogo_protobuf_types.SizeOfStdTime(m.PeriodReset) + l = github_com_cosmos_gogoproto_types.SizeOfStdTime(m.PeriodReset) n += 1 + l + sovFeegrant(uint64(l)) return n } @@ -748,7 +748,7 @@ func (m *BasicAllowance) Unmarshal(dAtA []byte) error { if m.Expiration == nil { m.Expiration = new(time.Time) } - if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(m.Expiration, dAtA[iNdEx:postIndex]); err != nil { + if err := github_com_cosmos_gogoproto_types.StdTimeUnmarshal(m.Expiration, dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -864,7 +864,7 @@ func (m *PeriodicAllowance) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if err := github_com_gogo_protobuf_types.StdDurationUnmarshal(&m.Period, dAtA[iNdEx:postIndex]); err != nil { + if err := github_com_cosmos_gogoproto_types.StdDurationUnmarshal(&m.Period, dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -965,7 +965,7 @@ func (m *PeriodicAllowance) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.PeriodReset, dAtA[iNdEx:postIndex]); err != nil { + if err := github_com_cosmos_gogoproto_types.StdTimeUnmarshal(&m.PeriodReset, dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex diff --git a/feegrant/query.pb.go b/feegrant/query.pb.go index 6a1d2f1..bcb553c 100644 --- a/feegrant/query.pb.go +++ b/feegrant/query.pb.go @@ -6,8 +6,8 @@ package feegrant import ( context "context" fmt "fmt" - grpc1 "github.com/gogo/protobuf/grpc" - proto "github.com/gogo/protobuf/proto" + grpc1 "github.com/cosmos/gogoproto/grpc" + proto "github.com/cosmos/gogoproto/proto" query "github.com/irisnet/core-sdk-go/types/query" _ "google.golang.org/genproto/googleapis/api/annotations" grpc "google.golang.org/grpc" diff --git a/feegrant/tx.pb.go b/feegrant/tx.pb.go index 8591c56..d4d8769 100644 --- a/feegrant/tx.pb.go +++ b/feegrant/tx.pb.go @@ -6,9 +6,9 @@ package feegrant import ( context "context" fmt "fmt" + grpc1 "github.com/cosmos/gogoproto/grpc" + proto "github.com/cosmos/gogoproto/proto" _ "github.com/gogo/protobuf/gogoproto" - grpc1 "github.com/gogo/protobuf/grpc" - proto "github.com/gogo/protobuf/proto" types "github.com/irisnet/core-sdk-go/common/codec/types" _ "github.com/regen-network/cosmos-proto" grpc "google.golang.org/grpc" diff --git a/go.mod b/go.mod index fe8858f..6cf1d3a 100644 --- a/go.mod +++ b/go.mod @@ -13,6 +13,7 @@ require ( github.com/btcsuite/btcutil v1.0.3-0.20201208143702-a53e38424cce github.com/cosmos/cosmos-sdk v0.44.3 github.com/cosmos/go-bip39 v1.0.0 + github.com/cosmos/gogoproto v1.4.6 github.com/dvsekhvalnov/jose2go v0.0.0-20201001154944-b09cfaf05951 github.com/ethereum/go-ethereum v1.10.16 github.com/gogo/protobuf v1.3.3 @@ -33,7 +34,7 @@ require ( github.com/sasha-s/go-deadlock v0.2.1-0.20190427202633-1595213edefa // indirect github.com/sirupsen/logrus v1.7.0 github.com/spf13/viper v1.9.0 // indirect - github.com/stretchr/testify v1.7.0 + github.com/stretchr/testify v1.8.1 github.com/tendermint/crypto v0.0.0-20191022145703-50d29ede1e15 github.com/tendermint/go-amino v0.16.0 github.com/tendermint/tendermint v0.34.14 @@ -41,13 +42,10 @@ require ( github.com/tjfoc/gmsm v1.4.0 github.com/tklauser/go-sysconf v0.3.7 // indirect go.etcd.io/bbolt v1.3.6 // indirect - golang.org/x/crypto v0.0.0-20211115234514-b4de73f9ece8 - golang.org/x/net v0.0.0-20211111160137-58aab5ef257a // indirect - golang.org/x/sys v0.0.0-20211111213525-f221eed1c01e // indirect - golang.org/x/text v0.3.7 // indirect - google.golang.org/genproto v0.0.0-20211116182654-e63d96a377c4 - google.golang.org/grpc v1.41.0 - google.golang.org/protobuf v1.27.1 + golang.org/x/crypto v0.1.0 + google.golang.org/genproto v0.0.0-20230110181048-76db0878b65f + google.golang.org/grpc v1.53.0 + google.golang.org/protobuf v1.28.1 gopkg.in/yaml.v2 v2.4.0 ) diff --git a/go.sum b/go.sum index 2bc88be..98862ac 100644 --- a/go.sum +++ b/go.sum @@ -4,6 +4,7 @@ cloud.google.com/go v0.38.0/go.mod h1:990N+gfupTy94rShfmMCWGDn0LpTmnzTp2qbd1dvSR cloud.google.com/go v0.43.0/go.mod h1:BOSR3VbTLkk6FDC/TcffxP4NF/FFBGA5ku+jvKOP7pg= cloud.google.com/go v0.44.1/go.mod h1:iSa0KzasP4Uvy3f1mN/7PiObzGgflwredwwASm/v6AU= cloud.google.com/go v0.44.2/go.mod h1:60680Gw3Yr4ikxnPRS/oxxkBccT6SA1yMk63TGekxKY= +cloud.google.com/go v0.44.3/go.mod h1:60680Gw3Yr4ikxnPRS/oxxkBccT6SA1yMk63TGekxKY= cloud.google.com/go v0.45.1/go.mod h1:RpBamKRgapWJb87xiFSdk4g1CME7QZg3uwTez+TSTjc= cloud.google.com/go v0.46.3/go.mod h1:a6bKKbmY7er1mI7TEI4lsAkts/mkhTSZK8w33B4RAg0= cloud.google.com/go v0.50.0/go.mod h1:r9sluTvynVuxRIOHXQEHMFffphuXHOMZMycpNR5e6To= @@ -17,6 +18,7 @@ cloud.google.com/go v0.62.0/go.mod h1:jmCYTdRCQuc1PHIIJ/maLInMho30T/Y0M4hTdTShOY cloud.google.com/go v0.65.0/go.mod h1:O5N8zS7uWy9vkA9vayVHs65eM1ubvY4h553ofrNHObY= cloud.google.com/go v0.72.0/go.mod h1:M+5Vjvlc2wnp6tjzE102Dw08nGShTscUx2nZMufOKPI= cloud.google.com/go v0.74.0/go.mod h1:VV1xSbzvo+9QJOxLDaJfTjx5e+MePCpCWwvftOeQmWk= +cloud.google.com/go v0.75.0/go.mod h1:VGuuCn7PG0dwsd5XPVm2Mm3wlh3EL55/79EKB6hlPTY= cloud.google.com/go v0.78.0/go.mod h1:QjdrLG0uq+YwhjoVOLsS1t7TW8fs36kLs4XO5R5ECHg= cloud.google.com/go v0.79.0/go.mod h1:3bzgcEeQlzbuEAYu4mrWhKqWjmpprinYgKJLgKHnbb8= cloud.google.com/go v0.81.0/go.mod h1:mk/AM35KwGk/Nm2YSeZbxXdrNK3KZOYHmLkOqC2V6E0= @@ -25,26 +27,368 @@ cloud.google.com/go v0.84.0/go.mod h1:RazrYuxIK6Kb7YrzzhPoLmCVzl7Sup4NrbKPg8KHSU cloud.google.com/go v0.87.0/go.mod h1:TpDYlFy7vuLzZMMZ+B6iRiELaY7z/gJPaqbMx6mlWcY= cloud.google.com/go v0.90.0/go.mod h1:kRX0mNRHe0e2rC6oNakvwQqzyDmg57xJ+SZU1eT2aDQ= cloud.google.com/go v0.93.3/go.mod h1:8utlLll2EF5XMAV15woO4lSbWQlk8rer9aLOfLh7+YI= +cloud.google.com/go v0.94.1/go.mod h1:qAlAugsXlC+JWO+Bke5vCtc9ONxjQT3drlTTnAplMW4= +cloud.google.com/go v0.97.0/go.mod h1:GF7l59pYBVlXQIBLx3a761cZ41F9bBH3JUlihCt2Udc= +cloud.google.com/go v0.99.0/go.mod h1:w0Xx2nLzqWJPuozYQX+hFfCSI8WioryfRDzkoI/Y2ZA= +cloud.google.com/go v0.100.1/go.mod h1:fs4QogzfH5n2pBXBP9vRiU+eCny7lD2vmFZy79Iuw1U= +cloud.google.com/go v0.100.2/go.mod h1:4Xra9TjzAeYHrl5+oeLlzbM2k3mjVhZh4UqTZ//w99A= +cloud.google.com/go v0.102.0/go.mod h1:oWcCzKlqJ5zgHQt9YsaeTY9KzIvjyy0ArmiBUgpQ+nc= +cloud.google.com/go v0.102.1/go.mod h1:XZ77E9qnTEnrgEOvr4xzfdX5TRo7fB4T2F4O6+34hIU= +cloud.google.com/go v0.104.0/go.mod h1:OO6xxXdJyvuJPcEPBLN9BJPD+jep5G1+2U5B5gkRYtA= +cloud.google.com/go v0.105.0/go.mod h1:PrLgOJNe5nfE9UMxKxgXj4mD3voiP+YQ6gdt6KMFOKM= +cloud.google.com/go v0.107.0/go.mod h1:wpc2eNrD7hXUTy8EKS10jkxpZBjASrORK7goS+3YX2I= +cloud.google.com/go/accessapproval v1.4.0/go.mod h1:zybIuC3KpDOvotz59lFe5qxRZx6C75OtwbisN56xYB4= +cloud.google.com/go/accessapproval v1.5.0/go.mod h1:HFy3tuiGvMdcd/u+Cu5b9NkO1pEICJ46IR82PoUdplw= +cloud.google.com/go/accesscontextmanager v1.3.0/go.mod h1:TgCBehyr5gNMz7ZaH9xubp+CE8dkrszb4oK9CWyvD4o= +cloud.google.com/go/accesscontextmanager v1.4.0/go.mod h1:/Kjh7BBu/Gh83sv+K60vN9QE5NJcd80sU33vIe2IFPE= +cloud.google.com/go/aiplatform v1.22.0/go.mod h1:ig5Nct50bZlzV6NvKaTwmplLLddFx0YReh9WfTO5jKw= +cloud.google.com/go/aiplatform v1.24.0/go.mod h1:67UUvRBKG6GTayHKV8DBv2RtR1t93YRu5B1P3x99mYY= +cloud.google.com/go/aiplatform v1.27.0/go.mod h1:Bvxqtl40l0WImSb04d0hXFU7gDOiq9jQmorivIiWcKg= +cloud.google.com/go/analytics v0.11.0/go.mod h1:DjEWCu41bVbYcKyvlws9Er60YE4a//bK6mnhWvQeFNI= +cloud.google.com/go/analytics v0.12.0/go.mod h1:gkfj9h6XRf9+TS4bmuhPEShsh3hH8PAZzm/41OOhQd4= +cloud.google.com/go/apigateway v1.3.0/go.mod h1:89Z8Bhpmxu6AmUxuVRg/ECRGReEdiP3vQtk4Z1J9rJk= +cloud.google.com/go/apigateway v1.4.0/go.mod h1:pHVY9MKGaH9PQ3pJ4YLzoj6U5FUDeDFBllIz7WmzJoc= +cloud.google.com/go/apigeeconnect v1.3.0/go.mod h1:G/AwXFAKo0gIXkPTVfZDd2qA1TxBXJ3MgMRBQkIi9jc= +cloud.google.com/go/apigeeconnect v1.4.0/go.mod h1:kV4NwOKqjvt2JYR0AoIWo2QGfoRtn/pkS3QlHp0Ni04= +cloud.google.com/go/appengine v1.4.0/go.mod h1:CS2NhuBuDXM9f+qscZ6V86m1MIIqPj3WC/UoEuR1Sno= +cloud.google.com/go/appengine v1.5.0/go.mod h1:TfasSozdkFI0zeoxW3PTBLiNqRmzraodCWatWI9Dmak= +cloud.google.com/go/area120 v0.5.0/go.mod h1:DE/n4mp+iqVyvxHN41Vf1CR602GiHQjFPusMFW6bGR4= +cloud.google.com/go/area120 v0.6.0/go.mod h1:39yFJqWVgm0UZqWTOdqkLhjoC7uFfgXRC8g/ZegeAh0= +cloud.google.com/go/artifactregistry v1.6.0/go.mod h1:IYt0oBPSAGYj/kprzsBjZ/4LnG/zOcHyFHjWPCi6SAQ= +cloud.google.com/go/artifactregistry v1.7.0/go.mod h1:mqTOFOnGZx8EtSqK/ZWcsm/4U8B77rbcLP6ruDU2Ixk= +cloud.google.com/go/artifactregistry v1.8.0/go.mod h1:w3GQXkJX8hiKN0v+at4b0qotwijQbYUqF2GWkZzAhC0= +cloud.google.com/go/artifactregistry v1.9.0/go.mod h1:2K2RqvA2CYvAeARHRkLDhMDJ3OXy26h3XW+3/Jh2uYc= +cloud.google.com/go/asset v1.5.0/go.mod h1:5mfs8UvcM5wHhqtSv8J1CtxxaQq3AdBxxQi2jGW/K4o= +cloud.google.com/go/asset v1.7.0/go.mod h1:YbENsRK4+xTiL+Ofoj5Ckf+O17kJtgp3Y3nn4uzZz5s= +cloud.google.com/go/asset v1.8.0/go.mod h1:mUNGKhiqIdbr8X7KNayoYvyc4HbbFO9URsjbytpUaW0= +cloud.google.com/go/asset v1.9.0/go.mod h1:83MOE6jEJBMqFKadM9NLRcs80Gdw76qGuHn8m3h8oHQ= +cloud.google.com/go/asset v1.10.0/go.mod h1:pLz7uokL80qKhzKr4xXGvBQXnzHn5evJAEAtZiIb0wY= +cloud.google.com/go/assuredworkloads v1.5.0/go.mod h1:n8HOZ6pff6re5KYfBXcFvSViQjDwxFkAkmUFffJRbbY= +cloud.google.com/go/assuredworkloads v1.6.0/go.mod h1:yo2YOk37Yc89Rsd5QMVECvjaMKymF9OP+QXWlKXUkXw= +cloud.google.com/go/assuredworkloads v1.7.0/go.mod h1:z/736/oNmtGAyU47reJgGN+KVoYoxeLBoj4XkKYscNI= +cloud.google.com/go/assuredworkloads v1.8.0/go.mod h1:AsX2cqyNCOvEQC8RMPnoc0yEarXQk6WEKkxYfL6kGIo= +cloud.google.com/go/assuredworkloads v1.9.0/go.mod h1:kFuI1P78bplYtT77Tb1hi0FMxM0vVpRC7VVoJC3ZoT0= +cloud.google.com/go/automl v1.5.0/go.mod h1:34EjfoFGMZ5sgJ9EoLsRtdPSNZLcfflJR39VbVNS2M0= +cloud.google.com/go/automl v1.6.0/go.mod h1:ugf8a6Fx+zP0D59WLhqgTDsQI9w07o64uf/Is3Nh5p8= +cloud.google.com/go/automl v1.7.0/go.mod h1:RL9MYCCsJEOmt0Wf3z9uzG0a7adTT1fe+aObgSpkCt8= +cloud.google.com/go/automl v1.8.0/go.mod h1:xWx7G/aPEe/NP+qzYXktoBSDfjO+vnKMGgsApGJJquM= +cloud.google.com/go/baremetalsolution v0.3.0/go.mod h1:XOrocE+pvK1xFfleEnShBlNAXf+j5blPPxrhjKgnIFc= +cloud.google.com/go/baremetalsolution v0.4.0/go.mod h1:BymplhAadOO/eBa7KewQ0Ppg4A4Wplbn+PsFKRLo0uI= +cloud.google.com/go/batch v0.3.0/go.mod h1:TR18ZoAekj1GuirsUsR1ZTKN3FC/4UDnScjT8NXImFE= +cloud.google.com/go/batch v0.4.0/go.mod h1:WZkHnP43R/QCGQsZ+0JyG4i79ranE2u8xvjq/9+STPE= +cloud.google.com/go/beyondcorp v0.2.0/go.mod h1:TB7Bd+EEtcw9PCPQhCJtJGjk/7TC6ckmnSFS+xwTfm4= +cloud.google.com/go/beyondcorp v0.3.0/go.mod h1:E5U5lcrcXMsCuoDNyGrpyTm/hn7ne941Jz2vmksAxW8= cloud.google.com/go/bigquery v1.0.1/go.mod h1:i/xbL2UlR5RvWAURpBYZTtm/cXjCha9lbfbpx4poX+o= cloud.google.com/go/bigquery v1.3.0/go.mod h1:PjpwJnslEMmckchkHFfq+HTD2DmtT67aNFKH1/VBDHE= cloud.google.com/go/bigquery v1.4.0/go.mod h1:S8dzgnTigyfTmLBfrtrhyYhwRxG72rYxvftPBK2Dvzc= cloud.google.com/go/bigquery v1.5.0/go.mod h1:snEHRnqQbz117VIFhE8bmtwIDY80NLUZUMb4Nv6dBIg= cloud.google.com/go/bigquery v1.7.0/go.mod h1://okPTzCYNXSlb24MZs83e2Do+h+VXtc4gLoIoXIAPc= cloud.google.com/go/bigquery v1.8.0/go.mod h1:J5hqkt3O0uAFnINi6JXValWIb1v0goeZM77hZzJN/fQ= +cloud.google.com/go/bigquery v1.42.0/go.mod h1:8dRTJxhtG+vwBKzE5OseQn/hiydoQN3EedCaOdYmxRA= +cloud.google.com/go/bigquery v1.43.0/go.mod h1:ZMQcXHsl+xmU1z36G2jNGZmKp9zNY5BUua5wDgmNCfw= +cloud.google.com/go/bigquery v1.44.0/go.mod h1:0Y33VqXTEsbamHJvJHdFmtqHvMIY28aK1+dFsvaChGc= cloud.google.com/go/bigtable v1.2.0/go.mod h1:JcVAOl45lrTmQfLj7T6TxyMzIN/3FGGcFm+2xVAli2o= +cloud.google.com/go/billing v1.4.0/go.mod h1:g9IdKBEFlItS8bTtlrZdVLWSSdSyFUZKXNS02zKMOZY= +cloud.google.com/go/billing v1.5.0/go.mod h1:mztb1tBc3QekhjSgmpf/CV4LzWXLzCArwpLmP2Gm88s= +cloud.google.com/go/billing v1.6.0/go.mod h1:WoXzguj+BeHXPbKfNWkqVtDdzORazmCjraY+vrxcyvI= +cloud.google.com/go/billing v1.7.0/go.mod h1:q457N3Hbj9lYwwRbnlD7vUpyjq6u5U1RAOArInEiD5Y= +cloud.google.com/go/binaryauthorization v1.1.0/go.mod h1:xwnoWu3Y84jbuHa0zd526MJYmtnVXn0syOjaJgy4+dM= +cloud.google.com/go/binaryauthorization v1.2.0/go.mod h1:86WKkJHtRcv5ViNABtYMhhNWRrD1Vpi//uKEy7aYEfI= +cloud.google.com/go/binaryauthorization v1.3.0/go.mod h1:lRZbKgjDIIQvzYQS1p99A7/U1JqvqeZg0wiI5tp6tg0= +cloud.google.com/go/binaryauthorization v1.4.0/go.mod h1:tsSPQrBd77VLplV70GUhBf/Zm3FsKmgSqgm4UmiDItk= +cloud.google.com/go/certificatemanager v1.3.0/go.mod h1:n6twGDvcUBFu9uBgt4eYvvf3sQ6My8jADcOVwHmzadg= +cloud.google.com/go/certificatemanager v1.4.0/go.mod h1:vowpercVFyqs8ABSmrdV+GiFf2H/ch3KyudYQEMM590= +cloud.google.com/go/channel v1.8.0/go.mod h1:W5SwCXDJsq/rg3tn3oG0LOxpAo6IMxNa09ngphpSlnk= +cloud.google.com/go/channel v1.9.0/go.mod h1:jcu05W0my9Vx4mt3/rEHpfxc9eKi9XwsdDL8yBMbKUk= +cloud.google.com/go/cloudbuild v1.3.0/go.mod h1:WequR4ULxlqvMsjDEEEFnOG5ZSRSgWOywXYDb1vPE6U= +cloud.google.com/go/cloudbuild v1.4.0/go.mod h1:5Qwa40LHiOXmz3386FrjrYM93rM/hdRr7b53sySrTqA= +cloud.google.com/go/clouddms v1.3.0/go.mod h1:oK6XsCDdW4Ib3jCCBugx+gVjevp2TMXFtgxvPSee3OM= +cloud.google.com/go/clouddms v1.4.0/go.mod h1:Eh7sUGCC+aKry14O1NRljhjyrr0NFC0G2cjwX0cByRk= +cloud.google.com/go/cloudtasks v1.5.0/go.mod h1:fD92REy1x5woxkKEkLdvavGnPJGEn8Uic9nWuLzqCpY= +cloud.google.com/go/cloudtasks v1.6.0/go.mod h1:C6Io+sxuke9/KNRkbQpihnW93SWDU3uXt92nu85HkYI= +cloud.google.com/go/cloudtasks v1.7.0/go.mod h1:ImsfdYWwlWNJbdgPIIGJWC+gemEGTBK/SunNQQNCAb4= +cloud.google.com/go/cloudtasks v1.8.0/go.mod h1:gQXUIwCSOI4yPVK7DgTVFiiP0ZW/eQkydWzwVMdHxrI= +cloud.google.com/go/compute v0.1.0/go.mod h1:GAesmwr110a34z04OlxYkATPBEfVhkymfTBXtfbBFow= +cloud.google.com/go/compute v1.3.0/go.mod h1:cCZiE1NHEtai4wiufUhW8I8S1JKkAnhnQJWM7YD99wM= +cloud.google.com/go/compute v1.5.0/go.mod h1:9SMHyhJlzhlkJqrPAc839t2BZFTSk6Jdj6mkzQJeu0M= +cloud.google.com/go/compute v1.6.0/go.mod h1:T29tfhtVbq1wvAPo0E3+7vhgmkOYeXjhFvz/FMzPu0s= +cloud.google.com/go/compute v1.6.1/go.mod h1:g85FgpzFvNULZ+S8AYq87axRKuf2Kh7deLqV/jJ3thU= +cloud.google.com/go/compute v1.7.0/go.mod h1:435lt8av5oL9P3fv1OEzSbSUe+ybHXGMPQHHZWZxy9U= +cloud.google.com/go/compute v1.10.0/go.mod h1:ER5CLbMxl90o2jtNbGSbtfOpQKR0t15FOtRsugnLrlU= +cloud.google.com/go/compute v1.12.0/go.mod h1:e8yNOBcBONZU1vJKCvCoDw/4JQsA0dpM4x/6PIIOocU= +cloud.google.com/go/compute v1.12.1/go.mod h1:e8yNOBcBONZU1vJKCvCoDw/4JQsA0dpM4x/6PIIOocU= +cloud.google.com/go/compute v1.13.0/go.mod h1:5aPTS0cUNMIc1CE546K+Th6weJUNQErARyZtRXDJ8GE= +cloud.google.com/go/compute v1.14.0/go.mod h1:YfLtxrj9sU4Yxv+sXzZkyPjEyPBZfXHUvjxega5vAdo= +cloud.google.com/go/compute v1.15.1/go.mod h1:bjjoF/NtFUrkD/urWfdHaKuOPDR5nWIs63rR+SXhcpA= +cloud.google.com/go/compute/metadata v0.1.0/go.mod h1:Z1VN+bulIf6bt4P/C37K4DyZYZEXYonfTBHHFPO/4UU= +cloud.google.com/go/compute/metadata v0.2.0/go.mod h1:zFmK7XCadkQkj6TtorcaGlCW1hT1fIilQDwofLpJ20k= +cloud.google.com/go/compute/metadata v0.2.1/go.mod h1:jgHgmJd2RKBGzXqF5LR2EZMGxBkeanZ9wwa75XHJgOM= +cloud.google.com/go/compute/metadata v0.2.3/go.mod h1:VAV5nSsACxMJvgaAuX6Pk2AawlZn8kiOGuCv6gTkwuA= +cloud.google.com/go/contactcenterinsights v1.3.0/go.mod h1:Eu2oemoePuEFc/xKFPjbTuPSj0fYJcPls9TFlPNnHHY= +cloud.google.com/go/contactcenterinsights v1.4.0/go.mod h1:L2YzkGbPsv+vMQMCADxJoT9YiTTnSEd6fEvCeHTYVck= +cloud.google.com/go/container v1.6.0/go.mod h1:Xazp7GjJSeUYo688S+6J5V+n/t+G5sKBTFkKNudGRxg= +cloud.google.com/go/container v1.7.0/go.mod h1:Dp5AHtmothHGX3DwwIHPgq45Y8KmNsgN3amoYfxVkLo= +cloud.google.com/go/containeranalysis v0.5.1/go.mod h1:1D92jd8gRR/c0fGMlymRgxWD3Qw9C1ff6/T7mLgVL8I= +cloud.google.com/go/containeranalysis v0.6.0/go.mod h1:HEJoiEIu+lEXM+k7+qLCci0h33lX3ZqoYFdmPcoO7s4= +cloud.google.com/go/datacatalog v1.3.0/go.mod h1:g9svFY6tuR+j+hrTw3J2dNcmI0dzmSiyOzm8kpLq0a0= +cloud.google.com/go/datacatalog v1.5.0/go.mod h1:M7GPLNQeLfWqeIm3iuiruhPzkt65+Bx8dAKvScX8jvs= +cloud.google.com/go/datacatalog v1.6.0/go.mod h1:+aEyF8JKg+uXcIdAmmaMUmZ3q1b/lKLtXCmXdnc0lbc= +cloud.google.com/go/datacatalog v1.7.0/go.mod h1:9mEl4AuDYWw81UGc41HonIHH7/sn52H0/tc8f8ZbZIE= +cloud.google.com/go/datacatalog v1.8.0/go.mod h1:KYuoVOv9BM8EYz/4eMFxrr4DUKhGIOXxZoKYF5wdISM= +cloud.google.com/go/dataflow v0.6.0/go.mod h1:9QwV89cGoxjjSR9/r7eFDqqjtvbKxAK2BaYU6PVk9UM= +cloud.google.com/go/dataflow v0.7.0/go.mod h1:PX526vb4ijFMesO1o202EaUmouZKBpjHsTlCtB4parQ= +cloud.google.com/go/dataform v0.3.0/go.mod h1:cj8uNliRlHpa6L3yVhDOBrUXH+BPAO1+KFMQQNSThKo= +cloud.google.com/go/dataform v0.4.0/go.mod h1:fwV6Y4Ty2yIFL89huYlEkwUPtS7YZinZbzzj5S9FzCE= +cloud.google.com/go/dataform v0.5.0/go.mod h1:GFUYRe8IBa2hcomWplodVmUx/iTL0FrsauObOM3Ipr0= +cloud.google.com/go/datafusion v1.4.0/go.mod h1:1Zb6VN+W6ALo85cXnM1IKiPw+yQMKMhB9TsTSRDo/38= +cloud.google.com/go/datafusion v1.5.0/go.mod h1:Kz+l1FGHB0J+4XF2fud96WMmRiq/wj8N9u007vyXZ2w= +cloud.google.com/go/datalabeling v0.5.0/go.mod h1:TGcJ0G2NzcsXSE/97yWjIZO0bXj0KbVlINXMG9ud42I= +cloud.google.com/go/datalabeling v0.6.0/go.mod h1:WqdISuk/+WIGeMkpw/1q7bK/tFEZxsrFJOJdY2bXvTQ= +cloud.google.com/go/dataplex v1.3.0/go.mod h1:hQuRtDg+fCiFgC8j0zV222HvzFQdRd+SVX8gdmFcZzA= +cloud.google.com/go/dataplex v1.4.0/go.mod h1:X51GfLXEMVJ6UN47ESVqvlsRplbLhcsAt0kZCCKsU0A= +cloud.google.com/go/dataproc v1.7.0/go.mod h1:CKAlMjII9H90RXaMpSxQ8EU6dQx6iAYNPcYPOkSbi8s= +cloud.google.com/go/dataproc v1.8.0/go.mod h1:5OW+zNAH0pMpw14JVrPONsxMQYMBqJuzORhIBfBn9uI= +cloud.google.com/go/dataqna v0.5.0/go.mod h1:90Hyk596ft3zUQ8NkFfvICSIfHFh1Bc7C4cK3vbhkeo= +cloud.google.com/go/dataqna v0.6.0/go.mod h1:1lqNpM7rqNLVgWBJyk5NF6Uen2PHym0jtVJonplVsDA= cloud.google.com/go/datastore v1.0.0/go.mod h1:LXYbyblFSglQ5pkeyhO+Qmw7ukd3C+pD7TKLgZqpHYE= cloud.google.com/go/datastore v1.1.0/go.mod h1:umbIZjpQpHh4hmRpGhH4tLFup+FVzqBi1b3c64qFpCk= +cloud.google.com/go/datastore v1.10.0/go.mod h1:PC5UzAmDEkAmkfaknstTYbNpgE49HAgW2J1gcgUfmdM= +cloud.google.com/go/datastream v1.2.0/go.mod h1:i/uTP8/fZwgATHS/XFu0TcNUhuA0twZxxQ3EyCUQMwo= +cloud.google.com/go/datastream v1.3.0/go.mod h1:cqlOX8xlyYF/uxhiKn6Hbv6WjwPPuI9W2M9SAXwaLLQ= +cloud.google.com/go/datastream v1.4.0/go.mod h1:h9dpzScPhDTs5noEMQVWP8Wx8AFBRyS0s8KWPx/9r0g= +cloud.google.com/go/datastream v1.5.0/go.mod h1:6TZMMNPwjUqZHBKPQ1wwXpb0d5VDVPl2/XoS5yi88q4= +cloud.google.com/go/deploy v1.4.0/go.mod h1:5Xghikd4VrmMLNaF6FiRFDlHb59VM59YoDQnOUdsH/c= +cloud.google.com/go/deploy v1.5.0/go.mod h1:ffgdD0B89tToyW/U/D2eL0jN2+IEV/3EMuXHA0l4r+s= +cloud.google.com/go/dialogflow v1.15.0/go.mod h1:HbHDWs33WOGJgn6rfzBW1Kv807BE3O1+xGbn59zZWI4= +cloud.google.com/go/dialogflow v1.16.1/go.mod h1:po6LlzGfK+smoSmTBnbkIZY2w8ffjz/RcGSS+sh1el0= +cloud.google.com/go/dialogflow v1.17.0/go.mod h1:YNP09C/kXA1aZdBgC/VtXX74G/TKn7XVCcVumTflA+8= +cloud.google.com/go/dialogflow v1.18.0/go.mod h1:trO7Zu5YdyEuR+BhSNOqJezyFQ3aUzz0njv7sMx/iek= +cloud.google.com/go/dialogflow v1.19.0/go.mod h1:JVmlG1TwykZDtxtTXujec4tQ+D8SBFMoosgy+6Gn0s0= +cloud.google.com/go/dlp v1.6.0/go.mod h1:9eyB2xIhpU0sVwUixfBubDoRwP+GjeUoxxeueZmqvmM= +cloud.google.com/go/dlp v1.7.0/go.mod h1:68ak9vCiMBjbasxeVD17hVPxDEck+ExiHavX8kiHG+Q= +cloud.google.com/go/documentai v1.7.0/go.mod h1:lJvftZB5NRiFSX4moiye1SMxHx0Bc3x1+p9e/RfXYiU= +cloud.google.com/go/documentai v1.8.0/go.mod h1:xGHNEB7CtsnySCNrCFdCyyMz44RhFEEX2Q7UD0c5IhU= +cloud.google.com/go/documentai v1.9.0/go.mod h1:FS5485S8R00U10GhgBC0aNGrJxBP8ZVpEeJ7PQDZd6k= +cloud.google.com/go/documentai v1.10.0/go.mod h1:vod47hKQIPeCfN2QS/jULIvQTugbmdc0ZvxxfQY1bg4= +cloud.google.com/go/domains v0.6.0/go.mod h1:T9Rz3GasrpYk6mEGHh4rymIhjlnIuB4ofT1wTxDeT4Y= +cloud.google.com/go/domains v0.7.0/go.mod h1:PtZeqS1xjnXuRPKE/88Iru/LdfoRyEHYA9nFQf4UKpg= +cloud.google.com/go/edgecontainer v0.1.0/go.mod h1:WgkZ9tp10bFxqO8BLPqv2LlfmQF1X8lZqwW4r1BTajk= +cloud.google.com/go/edgecontainer v0.2.0/go.mod h1:RTmLijy+lGpQ7BXuTDa4C4ssxyXT34NIuHIgKuP4s5w= +cloud.google.com/go/errorreporting v0.3.0/go.mod h1:xsP2yaAp+OAW4OIm60An2bbLpqIhKXdWR/tawvl7QzU= +cloud.google.com/go/essentialcontacts v1.3.0/go.mod h1:r+OnHa5jfj90qIfZDO/VztSFqbQan7HV75p8sA+mdGI= +cloud.google.com/go/essentialcontacts v1.4.0/go.mod h1:8tRldvHYsmnBCHdFpvU+GL75oWiBKl80BiqlFh9tp+8= +cloud.google.com/go/eventarc v1.7.0/go.mod h1:6ctpF3zTnaQCxUjHUdcfgcA1A2T309+omHZth7gDfmc= +cloud.google.com/go/eventarc v1.8.0/go.mod h1:imbzxkyAU4ubfsaKYdQg04WS1NvncblHEup4kvF+4gw= +cloud.google.com/go/filestore v1.3.0/go.mod h1:+qbvHGvXU1HaKX2nD0WEPo92TP/8AQuCVEBXNY9z0+w= +cloud.google.com/go/filestore v1.4.0/go.mod h1:PaG5oDfo9r224f8OYXURtAsY+Fbyq/bLYoINEK8XQAI= cloud.google.com/go/firestore v1.1.0/go.mod h1:ulACoGHTpvq5r8rxGJ4ddJZBZqakUQqClKRT5SZwBmk= cloud.google.com/go/firestore v1.6.0/go.mod h1:afJwI0vaXwAG54kI7A//lP/lSPDkQORQuMkv56TxEPU= +cloud.google.com/go/firestore v1.9.0/go.mod h1:HMkjKHNTtRyZNiMzu7YAsLr9K3X2udY2AMwDaMEQiiE= +cloud.google.com/go/functions v1.6.0/go.mod h1:3H1UA3qiIPRWD7PeZKLvHZ9SaQhR26XIJcC0A5GbvAk= +cloud.google.com/go/functions v1.7.0/go.mod h1:+d+QBcWM+RsrgZfV9xo6KfA1GlzJfxcfZcRPEhDDfzg= +cloud.google.com/go/functions v1.8.0/go.mod h1:RTZ4/HsQjIqIYP9a9YPbU+QFoQsAlYgrwOXJWHn1POY= +cloud.google.com/go/functions v1.9.0/go.mod h1:Y+Dz8yGguzO3PpIjhLTbnqV1CWmgQ5UwtlpzoyquQ08= +cloud.google.com/go/gaming v1.5.0/go.mod h1:ol7rGcxP/qHTRQE/RO4bxkXq+Fix0j6D4LFPzYTIrDM= +cloud.google.com/go/gaming v1.6.0/go.mod h1:YMU1GEvA39Qt3zWGyAVA9bpYz/yAhTvaQ1t2sK4KPUA= +cloud.google.com/go/gaming v1.7.0/go.mod h1:LrB8U7MHdGgFG851iHAfqUdLcKBdQ55hzXy9xBJz0+w= +cloud.google.com/go/gaming v1.8.0/go.mod h1:xAqjS8b7jAVW0KFYeRUxngo9My3f33kFmua++Pi+ggM= +cloud.google.com/go/gkebackup v0.2.0/go.mod h1:XKvv/4LfG829/B8B7xRkk8zRrOEbKtEam6yNfuQNH60= +cloud.google.com/go/gkebackup v0.3.0/go.mod h1:n/E671i1aOQvUxT541aTkCwExO/bTer2HDlj4TsBRAo= +cloud.google.com/go/gkeconnect v0.5.0/go.mod h1:c5lsNAg5EwAy7fkqX/+goqFsU1Da/jQFqArp+wGNr/o= +cloud.google.com/go/gkeconnect v0.6.0/go.mod h1:Mln67KyU/sHJEBY8kFZ0xTeyPtzbq9StAVvEULYK16A= +cloud.google.com/go/gkehub v0.9.0/go.mod h1:WYHN6WG8w9bXU0hqNxt8rm5uxnk8IH+lPY9J2TV7BK0= +cloud.google.com/go/gkehub v0.10.0/go.mod h1:UIPwxI0DsrpsVoWpLB0stwKCP+WFVG9+y977wO+hBH0= +cloud.google.com/go/gkemulticloud v0.3.0/go.mod h1:7orzy7O0S+5kq95e4Hpn7RysVA7dPs8W/GgfUtsPbrA= +cloud.google.com/go/gkemulticloud v0.4.0/go.mod h1:E9gxVBnseLWCk24ch+P9+B2CoDFJZTyIgLKSalC7tuI= +cloud.google.com/go/grafeas v0.2.0/go.mod h1:KhxgtF2hb0P191HlY5besjYm6MqTSTj3LSI+M+ByZHc= +cloud.google.com/go/gsuiteaddons v1.3.0/go.mod h1:EUNK/J1lZEZO8yPtykKxLXI6JSVN2rg9bN8SXOa0bgM= +cloud.google.com/go/gsuiteaddons v1.4.0/go.mod h1:rZK5I8hht7u7HxFQcFei0+AtfS9uSushomRlg+3ua1o= +cloud.google.com/go/iam v0.1.0/go.mod h1:vcUNEa0pEm0qRVpmWepWaFMIAI8/hjB9mO8rNCJtF6c= +cloud.google.com/go/iam v0.3.0/go.mod h1:XzJPvDayI+9zsASAFO68Hk07u3z+f+JrT2xXNdp4bnY= +cloud.google.com/go/iam v0.5.0/go.mod h1:wPU9Vt0P4UmCux7mqtRu6jcpPAb74cP1fh50J3QpkUc= +cloud.google.com/go/iam v0.6.0/go.mod h1:+1AH33ueBne5MzYccyMHtEKqLE4/kJOibtffMHDMFMc= +cloud.google.com/go/iam v0.7.0/go.mod h1:H5Br8wRaDGNc8XP3keLc4unfUUZeyH3Sfl9XpQEYOeg= +cloud.google.com/go/iam v0.8.0/go.mod h1:lga0/y3iH6CX7sYqypWJ33hf7kkfXJag67naqGESjkE= +cloud.google.com/go/iap v1.4.0/go.mod h1:RGFwRJdihTINIe4wZ2iCP0zF/qu18ZwyKxrhMhygBEc= +cloud.google.com/go/iap v1.5.0/go.mod h1:UH/CGgKd4KyohZL5Pt0jSKE4m3FR51qg6FKQ/z/Ix9A= +cloud.google.com/go/ids v1.1.0/go.mod h1:WIuwCaYVOzHIj2OhN9HAwvW+DBdmUAdcWlFxRl+KubM= +cloud.google.com/go/ids v1.2.0/go.mod h1:5WXvp4n25S0rA/mQWAg1YEEBBq6/s+7ml1RDCW1IrcY= +cloud.google.com/go/iot v1.3.0/go.mod h1:r7RGh2B61+B8oz0AGE+J72AhA0G7tdXItODWsaA2oLs= +cloud.google.com/go/iot v1.4.0/go.mod h1:dIDxPOn0UvNDUMD8Ger7FIaTuvMkj+aGk94RPP0iV+g= +cloud.google.com/go/kms v1.4.0/go.mod h1:fajBHndQ+6ubNw6Ss2sSd+SWvjL26RNo/dr7uxsnnOA= +cloud.google.com/go/kms v1.5.0/go.mod h1:QJS2YY0eJGBg3mnDfuaCyLauWwBJiHRboYxJ++1xJNg= +cloud.google.com/go/kms v1.6.0/go.mod h1:Jjy850yySiasBUDi6KFUwUv2n1+o7QZFyuUJg6OgjA0= +cloud.google.com/go/language v1.4.0/go.mod h1:F9dRpNFQmJbkaop6g0JhSBXCNlO90e1KWx5iDdxbWic= +cloud.google.com/go/language v1.6.0/go.mod h1:6dJ8t3B+lUYfStgls25GusK04NLh3eDLQnWM3mdEbhI= +cloud.google.com/go/language v1.7.0/go.mod h1:DJ6dYN/W+SQOjF8e1hLQXMF21AkH2w9wiPzPCJa2MIE= +cloud.google.com/go/language v1.8.0/go.mod h1:qYPVHf7SPoNNiCL2Dr0FfEFNil1qi3pQEyygwpgVKB8= +cloud.google.com/go/lifesciences v0.5.0/go.mod h1:3oIKy8ycWGPUyZDR/8RNnTOYevhaMLqh5vLUXs9zvT8= +cloud.google.com/go/lifesciences v0.6.0/go.mod h1:ddj6tSX/7BOnhxCSd3ZcETvtNr8NZ6t/iPhY2Tyfu08= +cloud.google.com/go/logging v1.6.1/go.mod h1:5ZO0mHHbvm8gEmeEUHrmDlTDSu5imF6MUP9OfilNXBw= +cloud.google.com/go/longrunning v0.1.1/go.mod h1:UUFxuDWkv22EuY93jjmDMFT5GPQKeFVJBIF6QlTqdsE= +cloud.google.com/go/longrunning v0.3.0/go.mod h1:qth9Y41RRSUE69rDcOn6DdK3HfQfsUI0YSmW3iIlLJc= +cloud.google.com/go/managedidentities v1.3.0/go.mod h1:UzlW3cBOiPrzucO5qWkNkh0w33KFtBJU281hacNvsdE= +cloud.google.com/go/managedidentities v1.4.0/go.mod h1:NWSBYbEMgqmbZsLIyKvxrYbtqOsxY1ZrGM+9RgDqInM= +cloud.google.com/go/maps v0.1.0/go.mod h1:BQM97WGyfw9FWEmQMpZ5T6cpovXXSd1cGmFma94eubI= +cloud.google.com/go/mediatranslation v0.5.0/go.mod h1:jGPUhGTybqsPQn91pNXw0xVHfuJ3leR1wj37oU3y1f4= +cloud.google.com/go/mediatranslation v0.6.0/go.mod h1:hHdBCTYNigsBxshbznuIMFNe5QXEowAuNmmC7h8pu5w= +cloud.google.com/go/memcache v1.4.0/go.mod h1:rTOfiGZtJX1AaFUrOgsMHX5kAzaTQ8azHiuDoTPzNsE= +cloud.google.com/go/memcache v1.5.0/go.mod h1:dk3fCK7dVo0cUU2c36jKb4VqKPS22BTkf81Xq617aWM= +cloud.google.com/go/memcache v1.6.0/go.mod h1:XS5xB0eQZdHtTuTF9Hf8eJkKtR3pVRCcvJwtm68T3rA= +cloud.google.com/go/memcache v1.7.0/go.mod h1:ywMKfjWhNtkQTxrWxCkCFkoPjLHPW6A7WOTVI8xy3LY= +cloud.google.com/go/metastore v1.5.0/go.mod h1:2ZNrDcQwghfdtCwJ33nM0+GrBGlVuh8rakL3vdPY3XY= +cloud.google.com/go/metastore v1.6.0/go.mod h1:6cyQTls8CWXzk45G55x57DVQ9gWg7RiH65+YgPsNh9s= +cloud.google.com/go/metastore v1.7.0/go.mod h1:s45D0B4IlsINu87/AsWiEVYbLaIMeUSoxlKKDqBGFS8= +cloud.google.com/go/metastore v1.8.0/go.mod h1:zHiMc4ZUpBiM7twCIFQmJ9JMEkDSyZS9U12uf7wHqSI= +cloud.google.com/go/monitoring v1.7.0/go.mod h1:HpYse6kkGo//7p6sT0wsIC6IBDET0RhIsnmlA53dvEk= +cloud.google.com/go/monitoring v1.8.0/go.mod h1:E7PtoMJ1kQXWxPjB6mv2fhC5/15jInuulFdYYtlcvT4= +cloud.google.com/go/networkconnectivity v1.4.0/go.mod h1:nOl7YL8odKyAOtzNX73/M5/mGZgqqMeryi6UPZTk/rA= +cloud.google.com/go/networkconnectivity v1.5.0/go.mod h1:3GzqJx7uhtlM3kln0+x5wyFvuVH1pIBJjhCpjzSt75o= +cloud.google.com/go/networkconnectivity v1.6.0/go.mod h1:OJOoEXW+0LAxHh89nXd64uGG+FbQoeH8DtxCHVOMlaM= +cloud.google.com/go/networkconnectivity v1.7.0/go.mod h1:RMuSbkdbPwNMQjB5HBWD5MpTBnNm39iAVpC3TmsExt8= +cloud.google.com/go/networkmanagement v1.4.0/go.mod h1:Q9mdLLRn60AsOrPc8rs8iNV6OHXaGcDdsIQe1ohekq8= +cloud.google.com/go/networkmanagement v1.5.0/go.mod h1:ZnOeZ/evzUdUsnvRt792H0uYEnHQEMaz+REhhzJRcf4= +cloud.google.com/go/networksecurity v0.5.0/go.mod h1:xS6fOCoqpVC5zx15Z/MqkfDwH4+m/61A3ODiDV1xmiQ= +cloud.google.com/go/networksecurity v0.6.0/go.mod h1:Q5fjhTr9WMI5mbpRYEbiexTzROf7ZbDzvzCrNl14nyU= +cloud.google.com/go/notebooks v1.2.0/go.mod h1:9+wtppMfVPUeJ8fIWPOq1UnATHISkGXGqTkxeieQ6UY= +cloud.google.com/go/notebooks v1.3.0/go.mod h1:bFR5lj07DtCPC7YAAJ//vHskFBxA5JzYlH68kXVdk34= +cloud.google.com/go/notebooks v1.4.0/go.mod h1:4QPMngcwmgb6uw7Po99B2xv5ufVoIQ7nOGDyL4P8AgA= +cloud.google.com/go/notebooks v1.5.0/go.mod h1:q8mwhnP9aR8Hpfnrc5iN5IBhrXUy8S2vuYs+kBJ/gu0= +cloud.google.com/go/optimization v1.1.0/go.mod h1:5po+wfvX5AQlPznyVEZjGJTMr4+CAkJf2XSTQOOl9l4= +cloud.google.com/go/optimization v1.2.0/go.mod h1:Lr7SOHdRDENsh+WXVmQhQTrzdu9ybg0NecjHidBq6xs= +cloud.google.com/go/orchestration v1.3.0/go.mod h1:Sj5tq/JpWiB//X/q3Ngwdl5K7B7Y0KZ7bfv0wL6fqVA= +cloud.google.com/go/orchestration v1.4.0/go.mod h1:6W5NLFWs2TlniBphAViZEVhrXRSMgUGDfW7vrWKvsBk= +cloud.google.com/go/orgpolicy v1.4.0/go.mod h1:xrSLIV4RePWmP9P3tBl8S93lTmlAxjm06NSm2UTmKvE= +cloud.google.com/go/orgpolicy v1.5.0/go.mod h1:hZEc5q3wzwXJaKrsx5+Ewg0u1LxJ51nNFlext7Tanwc= +cloud.google.com/go/osconfig v1.7.0/go.mod h1:oVHeCeZELfJP7XLxcBGTMBvRO+1nQ5tFG9VQTmYS2Fs= +cloud.google.com/go/osconfig v1.8.0/go.mod h1:EQqZLu5w5XA7eKizepumcvWx+m8mJUhEwiPqWiZeEdg= +cloud.google.com/go/osconfig v1.9.0/go.mod h1:Yx+IeIZJ3bdWmzbQU4fxNl8xsZ4amB+dygAwFPlvnNo= +cloud.google.com/go/osconfig v1.10.0/go.mod h1:uMhCzqC5I8zfD9zDEAfvgVhDS8oIjySWh+l4WK6GnWw= +cloud.google.com/go/oslogin v1.4.0/go.mod h1:YdgMXWRaElXz/lDk1Na6Fh5orF7gvmJ0FGLIs9LId4E= +cloud.google.com/go/oslogin v1.5.0/go.mod h1:D260Qj11W2qx/HVF29zBg+0fd6YCSjSqLUkY/qEenQU= +cloud.google.com/go/oslogin v1.6.0/go.mod h1:zOJ1O3+dTU8WPlGEkFSh7qeHPPSoxrcMbbK1Nm2iX70= +cloud.google.com/go/oslogin v1.7.0/go.mod h1:e04SN0xO1UNJ1M5GP0vzVBFicIe4O53FOfcixIqTyXo= +cloud.google.com/go/phishingprotection v0.5.0/go.mod h1:Y3HZknsK9bc9dMi+oE8Bim0lczMU6hrX0UpADuMefr0= +cloud.google.com/go/phishingprotection v0.6.0/go.mod h1:9Y3LBLgy0kDTcYET8ZH3bq/7qni15yVUoAxiFxnlSUA= +cloud.google.com/go/policytroubleshooter v1.3.0/go.mod h1:qy0+VwANja+kKrjlQuOzmlvscn4RNsAc0e15GGqfMxg= +cloud.google.com/go/policytroubleshooter v1.4.0/go.mod h1:DZT4BcRw3QoO8ota9xw/LKtPa8lKeCByYeKTIf/vxdE= +cloud.google.com/go/privatecatalog v0.5.0/go.mod h1:XgosMUvvPyxDjAVNDYxJ7wBW8//hLDDYmnsNcMGq1K0= +cloud.google.com/go/privatecatalog v0.6.0/go.mod h1:i/fbkZR0hLN29eEWiiwue8Pb+GforiEIBnV9yrRUOKI= cloud.google.com/go/pubsub v1.0.1/go.mod h1:R0Gpsv3s54REJCy4fxDixWD93lHJMoZTyQ2kNxGRt3I= cloud.google.com/go/pubsub v1.1.0/go.mod h1:EwwdRX2sKPjnvnqCa270oGRyludottCI76h+R3AArQw= cloud.google.com/go/pubsub v1.2.0/go.mod h1:jhfEVHT8odbXTkndysNHCcx0awwzvfOlguIAii9o8iA= cloud.google.com/go/pubsub v1.3.1/go.mod h1:i+ucay31+CNRpDW4Lu78I4xXG+O1r/MAHgjpRVR+TSU= +cloud.google.com/go/pubsub v1.26.0/go.mod h1:QgBH3U/jdJy/ftjPhTkyXNj543Tin1pRYcdcPRnFIRI= +cloud.google.com/go/pubsub v1.27.1/go.mod h1:hQN39ymbV9geqBnfQq6Xf63yNhUAhv9CZhzp5O6qsW0= +cloud.google.com/go/pubsublite v1.5.0/go.mod h1:xapqNQ1CuLfGi23Yda/9l4bBCKz/wC3KIJ5gKcxveZg= +cloud.google.com/go/recaptchaenterprise v1.3.1/go.mod h1:OdD+q+y4XGeAlxRaMn1Y7/GveP6zmq76byL6tjPE7d4= +cloud.google.com/go/recaptchaenterprise/v2 v2.1.0/go.mod h1:w9yVqajwroDNTfGuhmOjPDN//rZGySaf6PtFVcSCa7o= +cloud.google.com/go/recaptchaenterprise/v2 v2.2.0/go.mod h1:/Zu5jisWGeERrd5HnlS3EUGb/D335f9k51B/FVil0jk= +cloud.google.com/go/recaptchaenterprise/v2 v2.3.0/go.mod h1:O9LwGCjrhGHBQET5CA7dd5NwwNQUErSgEDit1DLNTdo= +cloud.google.com/go/recaptchaenterprise/v2 v2.4.0/go.mod h1:Am3LHfOuBstrLrNCBrlI5sbwx9LBg3te2N6hGvHn2mE= +cloud.google.com/go/recaptchaenterprise/v2 v2.5.0/go.mod h1:O8LzcHXN3rz0j+LBC91jrwI3R+1ZSZEWrfL7XHgNo9U= +cloud.google.com/go/recommendationengine v0.5.0/go.mod h1:E5756pJcVFeVgaQv3WNpImkFP8a+RptV6dDLGPILjvg= +cloud.google.com/go/recommendationengine v0.6.0/go.mod h1:08mq2umu9oIqc7tDy8sx+MNJdLG0fUi3vaSVbztHgJ4= +cloud.google.com/go/recommender v1.5.0/go.mod h1:jdoeiBIVrJe9gQjwd759ecLJbxCDED4A6p+mqoqDvTg= +cloud.google.com/go/recommender v1.6.0/go.mod h1:+yETpm25mcoiECKh9DEScGzIRyDKpZ0cEhWGo+8bo+c= +cloud.google.com/go/recommender v1.7.0/go.mod h1:XLHs/W+T8olwlGOgfQenXBTbIseGclClff6lhFVe9Bs= +cloud.google.com/go/recommender v1.8.0/go.mod h1:PkjXrTT05BFKwxaUxQmtIlrtj0kph108r02ZZQ5FE70= +cloud.google.com/go/redis v1.7.0/go.mod h1:V3x5Jq1jzUcg+UNsRvdmsfuFnit1cfe3Z/PGyq/lm4Y= +cloud.google.com/go/redis v1.8.0/go.mod h1:Fm2szCDavWzBk2cDKxrkmWBqoCiL1+Ctwq7EyqBCA/A= +cloud.google.com/go/redis v1.9.0/go.mod h1:HMYQuajvb2D0LvMgZmLDZW8V5aOC/WxstZHiy4g8OiA= +cloud.google.com/go/redis v1.10.0/go.mod h1:ThJf3mMBQtW18JzGgh41/Wld6vnDDc/F/F35UolRZPM= +cloud.google.com/go/resourcemanager v1.3.0/go.mod h1:bAtrTjZQFJkiWTPDb1WBjzvc6/kifjj4QBYuKCCoqKA= +cloud.google.com/go/resourcemanager v1.4.0/go.mod h1:MwxuzkumyTX7/a3n37gmsT3py7LIXwrShilPh3P1tR0= +cloud.google.com/go/resourcesettings v1.3.0/go.mod h1:lzew8VfESA5DQ8gdlHwMrqZs1S9V87v3oCnKCWoOuQU= +cloud.google.com/go/resourcesettings v1.4.0/go.mod h1:ldiH9IJpcrlC3VSuCGvjR5of/ezRrOxFtpJoJo5SmXg= +cloud.google.com/go/retail v1.8.0/go.mod h1:QblKS8waDmNUhghY2TI9O3JLlFk8jybHeV4BF19FrE4= +cloud.google.com/go/retail v1.9.0/go.mod h1:g6jb6mKuCS1QKnH/dpu7isX253absFl6iE92nHwlBUY= +cloud.google.com/go/retail v1.10.0/go.mod h1:2gDk9HsL4HMS4oZwz6daui2/jmKvqShXKQuB2RZ+cCc= +cloud.google.com/go/retail v1.11.0/go.mod h1:MBLk1NaWPmh6iVFSz9MeKG/Psyd7TAgm6y/9L2B4x9Y= +cloud.google.com/go/run v0.2.0/go.mod h1:CNtKsTA1sDcnqqIFR3Pb5Tq0usWxJJvsWOCPldRU3Do= +cloud.google.com/go/run v0.3.0/go.mod h1:TuyY1+taHxTjrD0ZFk2iAR+xyOXEA0ztb7U3UNA0zBo= +cloud.google.com/go/scheduler v1.4.0/go.mod h1:drcJBmxF3aqZJRhmkHQ9b3uSSpQoltBPGPxGAWROx6s= +cloud.google.com/go/scheduler v1.5.0/go.mod h1:ri073ym49NW3AfT6DZi21vLZrG07GXr5p3H1KxN5QlI= +cloud.google.com/go/scheduler v1.6.0/go.mod h1:SgeKVM7MIwPn3BqtcBntpLyrIJftQISRrYB5ZtT+KOk= +cloud.google.com/go/scheduler v1.7.0/go.mod h1:jyCiBqWW956uBjjPMMuX09n3x37mtyPJegEWKxRsn44= +cloud.google.com/go/secretmanager v1.6.0/go.mod h1:awVa/OXF6IiyaU1wQ34inzQNc4ISIDIrId8qE5QGgKA= +cloud.google.com/go/secretmanager v1.8.0/go.mod h1:hnVgi/bN5MYHd3Gt0SPuTPPp5ENina1/LxM+2W9U9J4= +cloud.google.com/go/secretmanager v1.9.0/go.mod h1:b71qH2l1yHmWQHt9LC80akm86mX8AL6X1MA01dW8ht4= +cloud.google.com/go/security v1.5.0/go.mod h1:lgxGdyOKKjHL4YG3/YwIL2zLqMFCKs0UbQwgyZmfJl4= +cloud.google.com/go/security v1.7.0/go.mod h1:mZklORHl6Bg7CNnnjLH//0UlAlaXqiG7Lb9PsPXLfD0= +cloud.google.com/go/security v1.8.0/go.mod h1:hAQOwgmaHhztFhiQ41CjDODdWP0+AE1B3sX4OFlq+GU= +cloud.google.com/go/security v1.9.0/go.mod h1:6Ta1bO8LXI89nZnmnsZGp9lVoVWXqsVbIq/t9dzI+2Q= +cloud.google.com/go/security v1.10.0/go.mod h1:QtOMZByJVlibUT2h9afNDWRZ1G96gVywH8T5GUSb9IA= +cloud.google.com/go/securitycenter v1.13.0/go.mod h1:cv5qNAqjY84FCN6Y9z28WlkKXyWsgLO832YiWwkCWcU= +cloud.google.com/go/securitycenter v1.14.0/go.mod h1:gZLAhtyKv85n52XYWt6RmeBdydyxfPeTrpToDPw4Auc= +cloud.google.com/go/securitycenter v1.15.0/go.mod h1:PeKJ0t8MoFmmXLXWm41JidyzI3PJjd8sXWaVqg43WWk= +cloud.google.com/go/securitycenter v1.16.0/go.mod h1:Q9GMaLQFUD+5ZTabrbujNWLtSLZIZF7SAR0wWECrjdk= +cloud.google.com/go/servicecontrol v1.4.0/go.mod h1:o0hUSJ1TXJAmi/7fLJAedOovnujSEvjKCAFNXPQ1RaU= +cloud.google.com/go/servicecontrol v1.5.0/go.mod h1:qM0CnXHhyqKVuiZnGKrIurvVImCs8gmqWsDoqe9sU1s= +cloud.google.com/go/servicedirectory v1.4.0/go.mod h1:gH1MUaZCgtP7qQiI+F+A+OpeKF/HQWgtAddhTbhL2bs= +cloud.google.com/go/servicedirectory v1.5.0/go.mod h1:QMKFL0NUySbpZJ1UZs3oFAmdvVxhhxB6eJ/Vlp73dfg= +cloud.google.com/go/servicedirectory v1.6.0/go.mod h1:pUlbnWsLH9c13yGkxCmfumWEPjsRs1RlmJ4pqiNjVL4= +cloud.google.com/go/servicedirectory v1.7.0/go.mod h1:5p/U5oyvgYGYejufvxhgwjL8UVXjkuw7q5XcG10wx1U= +cloud.google.com/go/servicemanagement v1.4.0/go.mod h1:d8t8MDbezI7Z2R1O/wu8oTggo3BI2GKYbdG4y/SJTco= +cloud.google.com/go/servicemanagement v1.5.0/go.mod h1:XGaCRe57kfqu4+lRxaFEAuqmjzF0r+gWHjWqKqBvKFo= +cloud.google.com/go/serviceusage v1.3.0/go.mod h1:Hya1cozXM4SeSKTAgGXgj97GlqUvF5JaoXacR1JTP/E= +cloud.google.com/go/serviceusage v1.4.0/go.mod h1:SB4yxXSaYVuUBYUml6qklyONXNLt83U0Rb+CXyhjEeU= +cloud.google.com/go/shell v1.3.0/go.mod h1:VZ9HmRjZBsjLGXusm7K5Q5lzzByZmJHf1d0IWHEN5X4= +cloud.google.com/go/shell v1.4.0/go.mod h1:HDxPzZf3GkDdhExzD/gs8Grqk+dmYcEjGShZgYa9URw= +cloud.google.com/go/spanner v1.41.0/go.mod h1:MLYDBJR/dY4Wt7ZaMIQ7rXOTLjYrmxLE/5ve9vFfWos= +cloud.google.com/go/speech v1.6.0/go.mod h1:79tcr4FHCimOp56lwC01xnt/WPJZc4v3gzyT7FoBkCM= +cloud.google.com/go/speech v1.7.0/go.mod h1:KptqL+BAQIhMsj1kOP2la5DSEEerPDuOP/2mmkhHhZQ= +cloud.google.com/go/speech v1.8.0/go.mod h1:9bYIl1/tjsAnMgKGHKmBZzXKEkGgtU+MpdDPTE9f7y0= +cloud.google.com/go/speech v1.9.0/go.mod h1:xQ0jTcmnRFFM2RfX/U+rk6FQNUF6DQlydUSyoooSpco= cloud.google.com/go/storage v1.0.0/go.mod h1:IhtSnM/ZTZV8YYJWCY8RULGVqBDmpoyjwiyrjsg+URw= cloud.google.com/go/storage v1.5.0/go.mod h1:tpKbwo567HUNpVclU5sGELwQWBDZ8gh0ZeosJ0Rtdos= cloud.google.com/go/storage v1.6.0/go.mod h1:N7U0C8pVQ/+NIKOBQyamJIeKQKkZ+mxpohlUTyfDhBk= cloud.google.com/go/storage v1.8.0/go.mod h1:Wv1Oy7z6Yz3DshWRJFhqM/UCfaWIRTdp0RXyy7KQOVs= cloud.google.com/go/storage v1.10.0/go.mod h1:FLPqc6j+Ki4BU591ie1oL6qBQGu2Bl/tZ9ullr3+Kg0= +cloud.google.com/go/storage v1.14.0/go.mod h1:GrKmX003DSIwi9o29oFT7YDnHYwZoctc3fOKtUw0Xmo= +cloud.google.com/go/storage v1.22.1/go.mod h1:S8N1cAStu7BOeFfE8KAQzmyyLkK8p/vmRq6kuBTW58Y= +cloud.google.com/go/storage v1.23.0/go.mod h1:vOEEDNFnciUMhBeT6hsJIn3ieU5cFRmzeLgDvXzfIXc= +cloud.google.com/go/storage v1.27.0/go.mod h1:x9DOL8TK/ygDUMieqwfhdpQryTeEkhGKMi80i/iqR2s= +cloud.google.com/go/storagetransfer v1.5.0/go.mod h1:dxNzUopWy7RQevYFHewchb29POFv3/AaBgnhqzqiK0w= +cloud.google.com/go/storagetransfer v1.6.0/go.mod h1:y77xm4CQV/ZhFZH75PLEXY0ROiS7Gh6pSKrM8dJyg6I= +cloud.google.com/go/talent v1.1.0/go.mod h1:Vl4pt9jiHKvOgF9KoZo6Kob9oV4lwd/ZD5Cto54zDRw= +cloud.google.com/go/talent v1.2.0/go.mod h1:MoNF9bhFQbiJ6eFD3uSsg0uBALw4n4gaCaEjBw9zo8g= +cloud.google.com/go/talent v1.3.0/go.mod h1:CmcxwJ/PKfRgd1pBjQgU6W3YBwiewmUzQYH5HHmSCmM= +cloud.google.com/go/talent v1.4.0/go.mod h1:ezFtAgVuRf8jRsvyE6EwmbTK5LKciD4KVnHuDEFmOOA= +cloud.google.com/go/texttospeech v1.4.0/go.mod h1:FX8HQHA6sEpJ7rCMSfXuzBcysDAuWusNNNvN9FELDd8= +cloud.google.com/go/texttospeech v1.5.0/go.mod h1:oKPLhR4n4ZdQqWKURdwxMy0uiTS1xU161C8W57Wkea4= +cloud.google.com/go/tpu v1.3.0/go.mod h1:aJIManG0o20tfDQlRIej44FcwGGl/cD0oiRyMKG19IQ= +cloud.google.com/go/tpu v1.4.0/go.mod h1:mjZaX8p0VBgllCzF6wcU2ovUXN9TONFLd7iz227X2Xg= +cloud.google.com/go/trace v1.3.0/go.mod h1:FFUE83d9Ca57C+K8rDl/Ih8LwOzWIV1krKgxg6N0G28= +cloud.google.com/go/trace v1.4.0/go.mod h1:UG0v8UBqzusp+z63o7FK74SdFE+AXpCLdFb1rshXG+Y= +cloud.google.com/go/translate v1.3.0/go.mod h1:gzMUwRjvOqj5i69y/LYLd8RrNQk+hOmIXTi9+nb3Djs= +cloud.google.com/go/translate v1.4.0/go.mod h1:06Dn/ppvLD6WvA5Rhdp029IX2Mi3Mn7fpMRLPvXT5Wg= +cloud.google.com/go/video v1.8.0/go.mod h1:sTzKFc0bUSByE8Yoh8X0mn8bMymItVGPfTuUBUyRgxk= +cloud.google.com/go/video v1.9.0/go.mod h1:0RhNKFRF5v92f8dQt0yhaHrEuH95m068JYOvLZYnJSw= +cloud.google.com/go/videointelligence v1.6.0/go.mod h1:w0DIDlVRKtwPCn/C4iwZIJdvC69yInhW0cfi+p546uU= +cloud.google.com/go/videointelligence v1.7.0/go.mod h1:k8pI/1wAhjznARtVT9U1llUaFNPh7muw8QyOUpavru4= +cloud.google.com/go/videointelligence v1.8.0/go.mod h1:dIcCn4gVDdS7yte/w+koiXn5dWVplOZkE+xwG9FgK+M= +cloud.google.com/go/videointelligence v1.9.0/go.mod h1:29lVRMPDYHikk3v8EdPSaL8Ku+eMzDljjuvRs105XoU= +cloud.google.com/go/vision v1.2.0/go.mod h1:SmNwgObm5DpFBme2xpyOyasvBc1aPdjvMk2bBk0tKD0= +cloud.google.com/go/vision/v2 v2.2.0/go.mod h1:uCdV4PpN1S0jyCyq8sIM42v2Y6zOLkZs+4R9LrGYwFo= +cloud.google.com/go/vision/v2 v2.3.0/go.mod h1:UO61abBx9QRMFkNBbf1D8B1LXdS2cGiiCRx0vSpZoUo= +cloud.google.com/go/vision/v2 v2.4.0/go.mod h1:VtI579ll9RpVTrdKdkMzckdnwMyX2JILb+MhPqRbPsY= +cloud.google.com/go/vision/v2 v2.5.0/go.mod h1:MmaezXOOE+IWa+cS7OhRRLK2cNv1ZL98zhqFFZaaH2E= +cloud.google.com/go/vmmigration v1.2.0/go.mod h1:IRf0o7myyWFSmVR1ItrBSFLFD/rJkfDCUTO4vLlJvsE= +cloud.google.com/go/vmmigration v1.3.0/go.mod h1:oGJ6ZgGPQOFdjHuocGcLqX4lc98YQ7Ygq8YQwHh9A7g= +cloud.google.com/go/vmwareengine v0.1.0/go.mod h1:RsdNEf/8UDvKllXhMz5J40XxDrNJNN4sagiox+OI208= +cloud.google.com/go/vpcaccess v1.4.0/go.mod h1:aQHVbTWDYUR1EbTApSVvMq1EnT57ppDmQzZ3imqIk4w= +cloud.google.com/go/vpcaccess v1.5.0/go.mod h1:drmg4HLk9NkZpGfCmZ3Tz0Bwnm2+DKqViEpeEpOq0m8= +cloud.google.com/go/webrisk v1.4.0/go.mod h1:Hn8X6Zr+ziE2aNd8SliSDWpEnSS1u4R9+xXZmFiHmGE= +cloud.google.com/go/webrisk v1.5.0/go.mod h1:iPG6fr52Tv7sGk0H6qUFzmL3HHZev1htXuWDEEsqMTg= +cloud.google.com/go/webrisk v1.6.0/go.mod h1:65sW9V9rOosnc9ZY7A7jsy1zoHS5W9IAXv6dGqhMQMc= +cloud.google.com/go/webrisk v1.7.0/go.mod h1:mVMHgEYH0r337nmt1JyLthzMr6YxwN1aAIEc2fTcq7A= +cloud.google.com/go/websecurityscanner v1.3.0/go.mod h1:uImdKm2wyeXQevQJXeh8Uun/Ym1VqworNDlBXQevGMo= +cloud.google.com/go/websecurityscanner v1.4.0/go.mod h1:ebit/Fp0a+FWu5j4JOmJEV8S8CzdTkAS77oDsiSqYWQ= +cloud.google.com/go/workflows v1.6.0/go.mod h1:6t9F5h/unJz41YqfBmqSASJSXccBLtD1Vwf+KmJENM0= +cloud.google.com/go/workflows v1.7.0/go.mod h1:JhSrZuVZWuiDfKEFxU0/F1PQjmpnpcoISEXH2bcHC3M= +cloud.google.com/go/workflows v1.8.0/go.mod h1:ysGhmEajwZxGn1OhGOGKsTXc5PyxOc0vfKf5Af+to4M= +cloud.google.com/go/workflows v1.9.0/go.mod h1:ZGkj1aFIOd9c8Gerkjjq7OW7I5+l6cSvT3ujaO/WwSA= collectd.org v0.3.0/go.mod h1:A/8DzQBkF6abtvrT2j/AU/4tiBgJWYyh0y/oB/4MlWE= dmitri.shuralyov.com/gpu/mtl v0.0.0-20190408044501-666a987793e9/go.mod h1:H6x//7gZCb22OMCxBHrMx7a5I7Hp++hsVxbQ4BYO7hU= filippo.io/edwards25519 v1.0.0-beta.2 h1:/BZRNzm8N4K4eWfK28dL4yescorxtO7YG1yun8fy+pI= @@ -98,6 +442,7 @@ github.com/alecthomas/template v0.0.0-20190718012654-fb15b899a751/go.mod h1:LOuy github.com/alecthomas/units v0.0.0-20151022065526-2efee857e7cf/go.mod h1:ybxpYRFXyAe+OPACYpWeL0wqObRcbAqCMya13uyzqw0= github.com/alecthomas/units v0.0.0-20190717042225-c3de453c63f4/go.mod h1:ybxpYRFXyAe+OPACYpWeL0wqObRcbAqCMya13uyzqw0= github.com/alecthomas/units v0.0.0-20190924025748-f65c72e2690d/go.mod h1:rBZYJk541a8SKzHPHnH3zbiI+7dagKZ0cgpgrD7Fyho= +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/andreyvit/diff v0.0.0-20170406064948-c7f18ee00883/go.mod h1:rCTlJbsFo29Kk6CurOXKm700vrz8f0KW0JNfpkRJY/8= github.com/antihax/optional v1.0.0/go.mod h1:uupD/76wgC+ih3iEmQUL+0Ugr19nfwCT1kdvxnR2qWY= @@ -167,11 +512,14 @@ github.com/c-bata/go-prompt v0.2.2/go.mod h1:VzqtzE2ksDBcdln8G7mk2RX9QyGjH+OVqOC github.com/casbin/casbin/v2 v2.1.2/go.mod h1:YcPU1XXisHhLzuxH9coDNf2FbKpjGlbCg3n9yuLkIJQ= github.com/cenkalti/backoff v2.2.1+incompatible/go.mod h1:90ReRw6GdpyfrHakVjL/QHaoyV4aDUVVkXQJJJ3NXXM= github.com/census-instrumentation/opencensus-proto v0.2.1/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU= +github.com/census-instrumentation/opencensus-proto v0.3.0/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU= +github.com/census-instrumentation/opencensus-proto v0.4.1/go.mod h1:4T9NM4+4Vw91VeyqjLS6ao50K5bOcLKN6Q42XnYaRYw= github.com/cespare/cp v0.1.0/go.mod h1:SOGHArjBr4JWaSDEVpWpo/hNg6RoKrls6Oh40hiwW+s= github.com/cespare/xxhash v1.1.0 h1:a6HrQnmkObjyL+Gs60czilIUGqrzKutQD6XZog3p+ko= github.com/cespare/xxhash v1.1.0/go.mod h1:XrSqR1VqqWfGrhpAt58auRo0WTKS1nRRg3ghfAqPWnc= -github.com/cespare/xxhash/v2 v2.1.1 h1:6MnRN8NT7+YBpUIWxHtefFZOKTAPgGjpQSxqLNn0+qY= github.com/cespare/xxhash/v2 v2.1.1/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= +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/chzyer/logex v1.1.10/go.mod h1:+Ywpsq7O8HXn0nuIou7OrIPyXbp3wmkHB+jjWRnGsAI= github.com/chzyer/readline v0.0.0-20180603132655-2972be24d48e/go.mod h1:nSuG5e5PlCu98SY8svDHJxuZscDgtXS6KTTbou5AhLI= github.com/chzyer/test v0.0.0-20180213035817-a1ea475d72b1/go.mod h1:Q3SI9o4m/ZMnBNeIyt5eFwwo7qiLfzFZmjNmxjkiQlU= @@ -184,8 +532,15 @@ github.com/cloudflare/cloudflare-go v0.14.0/go.mod h1:EnwdgGMaFOruiPZRFSgn+TsQ3h github.com/cncf/udpa/go v0.0.0-20191209042840-269d4d468f6f/go.mod h1:M8M6+tZqaGXZJjfX53e64911xZQV5JYwmTeXPW+k8Sc= github.com/cncf/udpa/go v0.0.0-20200629203442-efcf912fb354/go.mod h1:WmhPx2Nbnhtbo57+VJT5O0JRkEi1Wbu0z5j0R8u5Hbk= github.com/cncf/udpa/go v0.0.0-20201120205902-5459f2c99403/go.mod h1:WmhPx2Nbnhtbo57+VJT5O0JRkEi1Wbu0z5j0R8u5Hbk= +github.com/cncf/udpa/go v0.0.0-20210930031921-04548b0d99d4/go.mod h1:6pvJx4me5XPnfI9Z40ddWsdw2W/uZgQLFXToKeRcDiI= +github.com/cncf/udpa/go v0.0.0-20220112060539-c52dc94e7fbe/go.mod h1:6pvJx4me5XPnfI9Z40ddWsdw2W/uZgQLFXToKeRcDiI= github.com/cncf/xds/go v0.0.0-20210312221358-fbca930ec8ed/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs= github.com/cncf/xds/go v0.0.0-20210805033703-aa0b78936158/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs= +github.com/cncf/xds/go v0.0.0-20210922020428-25de7278fc84/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs= +github.com/cncf/xds/go v0.0.0-20211001041855-01bcc9b48dfe/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs= +github.com/cncf/xds/go v0.0.0-20211011173535-cb28da3451f1/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs= +github.com/cncf/xds/go v0.0.0-20220314180256-7f1daf1720fc/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs= +github.com/cncf/xds/go v0.0.0-20230105202645-06c439db220b/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs= github.com/cockroachdb/datadriven v0.0.0-20190809214429-80d97fb3cbaa/go.mod h1:zn76sxSg3SzpJ0PPJaLDCu+Bu0Lg3sKTORVIj19EIF8= github.com/codahale/hdrhistogram v0.0.0-20161010025455-3a0bb77429bd/go.mod h1:sE/e/2PUdi/liOCUjSTXgM1o87ZssimdTWN964YiIeI= github.com/coinbase/rosetta-sdk-go v0.6.10/go.mod h1:J/JFMsfcePrjJZkwQFLh+hJErkAmdm9Iyy3D5Y0LfXo= @@ -210,6 +565,8 @@ github.com/cosmos/cosmos-sdk v0.44.3/go.mod h1:bA3+VenaR/l/vDiYzaiwbWvRPWHMBX2jG github.com/cosmos/go-bip39 v0.0.0-20180819234021-555e2067c45d/go.mod h1:tSxLoYXyBmiFeKpvmq4dzayMdCjCnu8uqmCysIGBT2Y= github.com/cosmos/go-bip39 v1.0.0 h1:pcomnQdrdH22njcAatO0yWojsUnCO3y2tNoV1cb6hHY= github.com/cosmos/go-bip39 v1.0.0/go.mod h1:RNJv0H/pOIVgxw6KS7QeX2a0Uo0aKUlfhZ4xuwvCdJw= +github.com/cosmos/gogoproto v1.4.6 h1:Ee7z15dWJaGlgM2rWrK8N2IX7PQcuccu8oG68jp5RL4= +github.com/cosmos/gogoproto v1.4.6/go.mod h1:VS/ASYmPgv6zkPKLjR9EB91lwbLHOzaGCirmKKhncfI= github.com/cosmos/iavl v0.15.0-rc5/go.mod h1:WqoPL9yPTQ85QBMT45OOUzPxG/U/JcJoN7uMjgxke/I= github.com/cosmos/iavl v0.17.1 h1:b/Cl8h1PRMvsu24+TYNlKchIu7W6tmxIBGe6E9u2Ybw= github.com/cosmos/iavl v0.17.1/go.mod h1:7aisPZK8yCpQdy3PMvKeO+bhq1NwDjUwjzxwwROUxFk= @@ -231,6 +588,7 @@ github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSs github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/deckarep/golang-set v0.0.0-20180603214616-504e848d77ea/go.mod h1:93vsz/8Wt4joVM7c2AVqh+YRMiUSc14yDtF28KmMOgQ= +github.com/deckarep/golang-set v1.8.0 h1:sk9/l/KqpunDwP7pSjUg0keiOOLEnOBHzykLrsPppp4= github.com/deckarep/golang-set v1.8.0/go.mod h1:5nI87KwE7wgsBU1F4GKAw2Qod7p5kyS383rP6+o6qqo= github.com/decred/dcrd/lru v1.0.0/go.mod h1:mxKOwFd7lFjN2GZYsiz/ecgqR6kkYAl+0pz0tEMk218= github.com/deepmap/oapi-codegen v1.6.0/go.mod h1:ryDa9AgbELGeB+YEXE1dR53yAjHwFvE9iAUlWl9Al3M= @@ -265,6 +623,7 @@ github.com/eapache/go-xerial-snappy v0.0.0-20180814174437-776d5712da21/go.mod h1 github.com/eapache/queue v1.1.0/go.mod h1:6eCeP0CKFpHLu8blIFXhExK/dRa7WDZfr6jVFPTqq+I= github.com/eclipse/paho.mqtt.golang v1.2.0/go.mod h1:H9keYFcgq3Qr5OUJm/JZI/i6U7joQ8SYLhZwfeOo6Ts= github.com/edsrzf/mmap-go v0.0.0-20160512033002-935e0e8a636c/go.mod h1:YO35OhQPt3KJa3ryjFM5Bs14WD66h8eGKpfaBNrHW5M= +github.com/edsrzf/mmap-go v1.0.0 h1:CEBF7HpRnUCSJgGUb5h1Gm7e3VkmVDrR8lvWVLtrOFw= github.com/edsrzf/mmap-go v1.0.0/go.mod h1:YO35OhQPt3KJa3ryjFM5Bs14WD66h8eGKpfaBNrHW5M= github.com/enigmampc/btcutil v1.0.3-0.20200723161021-e2fb6adb2a25 h1:2vLKys4RBU4pn2T/hjXMbvwTr1Cvy5THHrQkbeY9HRk= github.com/enigmampc/btcutil v1.0.3-0.20200723161021-e2fb6adb2a25/go.mod h1:hTr8+TLQmkUkgcuh3mcr5fjrT9c64ZzsBCdCEC6UppY= @@ -277,7 +636,11 @@ github.com/envoyproxy/go-control-plane v0.9.9-0.20201210154907-fd9021fe5dad/go.m github.com/envoyproxy/go-control-plane v0.9.9-0.20210217033140-668b12f5399d/go.mod h1:cXg6YxExXjJnVBQHBLXeUAgxn2UodCpnH306RInaBQk= github.com/envoyproxy/go-control-plane v0.9.9-0.20210512163311-63b5d3c536b0/go.mod h1:hliV/p42l8fGbc6Y9bQ70uLwIvmJyVE5k4iMKlh8wCQ= github.com/envoyproxy/go-control-plane v0.9.10-0.20210907150352-cf90f659a021/go.mod h1:AFq3mo9L8Lqqiid3OhADV3RfLJnjiw63cSpi+fDTRC0= +github.com/envoyproxy/go-control-plane v0.10.2-0.20220325020618-49ff273808a1/go.mod h1:KJwIaB5Mv44NWtYuAOFCVOjcI94vtpEz2JU/D2v6IjE= +github.com/envoyproxy/go-control-plane v0.10.3/go.mod h1:fJJn/j26vwOu972OllsvAgJJM//w9BV6Fxbg2LuVd34= github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c= +github.com/envoyproxy/protoc-gen-validate v0.6.7/go.mod h1:dyJXwwfPK2VSqiB9Klm1J6romD608Ba7Hij42vrOBCo= +github.com/envoyproxy/protoc-gen-validate v0.9.1/go.mod h1:OKNgG7TCp5pF4d6XftA0++PMirau2/yoOwVac3AbF2w= github.com/ethereum/go-ethereum v1.9.25/go.mod h1:vMkFiYLHI4tgPw4k2j4MHKoovchFE8plZ0M9VMk4/oM= github.com/ethereum/go-ethereum v1.10.16 h1:3oPrumn0bCW/idjcxMn5YYVCdK7VzJYIvwGZUGLEaoc= github.com/ethereum/go-ethereum v1.10.16/go.mod h1:Anj6cxczl+AHy63o4X9O8yWNHuN5wMpfb8MAnHkWn7Y= @@ -357,6 +720,7 @@ github.com/gogo/googleapis v1.1.0/go.mod h1:gf4bu3Q80BeJ6H1S1vYPm8/ELATdvryBaNFG github.com/golang/freetype v0.0.0-20170609003504-e2365dfdc4a0/go.mod h1:E/TSTwGwJL78qG/PmXZO1EjYhfJinVAhrmmHX6Z8B9k= github.com/golang/geo v0.0.0-20190916061304-5b978397cfec/go.mod h1:QZ0nwyI2jOfgRAoBvP+ab5aRr7c9x7lhGEJrKvBwjWI= github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q= +github.com/golang/glog v1.0.0/go.mod h1:EWib/APOK0SL3dFbYqvxE3UYd8E6s1ouQ7iEp/0LWV4= github.com/golang/groupcache v0.0.0-20160516000752-02826c3e7903/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc= github.com/golang/groupcache v0.0.0-20190129154638-5b532d6fd5ef/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc= github.com/golang/groupcache v0.0.0-20190702054246-869f871628b6/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc= @@ -370,6 +734,7 @@ github.com/golang/mock v1.4.1/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt github.com/golang/mock v1.4.3/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt3cw= github.com/golang/mock v1.4.4/go.mod h1:l3mdAwkq5BuhzHwde/uurv3sEJeZMXNpwsxVWU71h+4= github.com/golang/mock v1.5.0/go.mod h1:CWnOUgYIOo4TcNZ0wHX3YZCqsaM1I1Jvs6v3mP3KVu8= +github.com/golang/mock v1.6.0 h1:ErTB+efbowRARo13NNdxyJji2egdxLGQhRaY+DUumQc= github.com/golang/mock v1.6.0/go.mod h1:p6yTPP+5HYm5mzsMV8JkE6ZKdX+/wYM6Hr+LicevLPs= github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= github.com/golang/protobuf v1.3.0/go.mod h1:Qd/q+1AKNOZr9uGQzbzCmRO6sUih6GTPZv6a1/R87v0= @@ -413,8 +778,11 @@ github.com/google/go-cmp v0.5.2/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/ github.com/google/go-cmp v0.5.3/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.4/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.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= github.com/google/go-cmp v0.5.6/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= +github.com/google/go-cmp v0.5.7/go.mod h1:n+brtR0CgQNWTVd5ZUFpTBC8YFBDLK/h/bpaJ8/DtOE= +github.com/google/go-cmp v0.5.8/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY= +github.com/google/go-cmp v0.5.9 h1:O2Tfq5qg4qc4AmwVlvv0oLiVAGB7enBSJ2x2DqQFi38= +github.com/google/go-cmp v0.5.9/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY= github.com/google/gofuzz v0.0.0-20170612174753-24818f796faf/go.mod h1:HP5RmnzzSNb993RKQDq4+1A4ia9nllfqcQFTQJedwGI= github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg= github.com/google/gofuzz v1.1.1-0.20200604201612-c04b05f3adfa h1:Q75Upo5UN4JbPFURXZ8nLKYUvF85dyFRop/vQ0Rv+64= @@ -432,6 +800,7 @@ github.com/google/pprof v0.0.0-20200430221834-fc25d7d30c6d/go.mod h1:ZgVRPoUq/hf github.com/google/pprof v0.0.0-20200708004538-1a94d8640e99/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM= github.com/google/pprof v0.0.0-20201023163331-3e6fc7fc9c4c/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE= github.com/google/pprof v0.0.0-20201203190320-1bf35d6f28c2/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE= +github.com/google/pprof v0.0.0-20201218002935-b9804c9f04c2/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE= github.com/google/pprof v0.0.0-20210122040257-d980be63207e/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE= github.com/google/pprof v0.0.0-20210226084205-cbba55b83ad5/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE= github.com/google/pprof v0.0.0-20210601050228-01bbb1931b22/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE= @@ -442,9 +811,22 @@ github.com/google/uuid v1.0.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+ github.com/google/uuid v1.1.1/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= github.com/google/uuid v1.1.2/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= github.com/google/uuid v1.1.5/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= +github.com/google/uuid v1.3.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= +github.com/googleapis/enterprise-certificate-proxy v0.0.0-20220520183353-fd19c99a87aa/go.mod h1:17drOmN3MwGY7t0e+Ei9b45FFGA3fBs3x36SsCg1hq8= +github.com/googleapis/enterprise-certificate-proxy v0.1.0/go.mod h1:17drOmN3MwGY7t0e+Ei9b45FFGA3fBs3x36SsCg1hq8= +github.com/googleapis/enterprise-certificate-proxy v0.2.0/go.mod h1:8C0jb7/mgJe/9KK8Lm7X9ctZC2t60YyIpYEI16jx0Qg= github.com/googleapis/gax-go/v2 v2.0.4/go.mod h1:0Wqv26UfaUD9n4G6kQubkQ+KchISgw+vpHVxEJEs9eg= github.com/googleapis/gax-go/v2 v2.0.5/go.mod h1:DWXyrwAJ9X0FpwwEdw+IPEYBICEFu5mhpdKc/us6bOk= github.com/googleapis/gax-go/v2 v2.1.0/go.mod h1:Q3nei7sK6ybPYH7twZdmQpAd1MKb7pfu6SK+H1/DsU0= +github.com/googleapis/gax-go/v2 v2.1.1/go.mod h1:hddJymUZASv3XPyGkUpKj8pPO47Rmb0eJc8R6ouapiM= +github.com/googleapis/gax-go/v2 v2.2.0/go.mod h1:as02EH8zWkzwUoLbBaFeQ+arQaj/OthfcblKl4IGNaM= +github.com/googleapis/gax-go/v2 v2.3.0/go.mod h1:b8LNqSzNabLiUpXKkY7HAR5jr6bIT99EXz9pXxye9YM= +github.com/googleapis/gax-go/v2 v2.4.0/go.mod h1:XOTVJ59hdnfJLIP/dh8n5CGryZR2LxK9wbMD5+iXC6c= +github.com/googleapis/gax-go/v2 v2.5.1/go.mod h1:h6B0KMMFNtI2ddbGJn3T3ZbwkeT6yqEF02fYlzkUCyo= +github.com/googleapis/gax-go/v2 v2.6.0/go.mod h1:1mjbznJAPHFpesgE5ucqfYEscaz5kMdcIDwU/6+DDoY= +github.com/googleapis/gax-go/v2 v2.7.0/go.mod h1:TEop28CZZQ2y+c0VxMUmu1lV+fQx57QpBWsYpwqHJx8= +github.com/googleapis/go-type-adapters v1.0.0/go.mod h1:zHW75FOG2aur7gAO2B+MLby+cLsWGBF62rFAi7WjWO4= +github.com/googleapis/google-cloud-go-testing v0.0.0-20200911160855-bcd43fbb19e8/go.mod h1:dvDLG8qkwmyD9a/MJJN3XJcT3xFxOKAvTZGvuZmac9g= github.com/gopherjs/gopherjs v0.0.0-20181017120253-0766667cb4d1/go.mod h1:wJfORRmW1u3UXTncJ5qlYoELFm8eSnnEO6hX4iZ3EWY= github.com/gordonklaus/ineffassign v0.0.0-20200309095847-7953dde2c7bf/go.mod h1:cuNKsD1zp2v6XfE/orVX2QE1LC+i254ceGcVeDT3pTU= github.com/gorilla/context v1.1.1/go.mod h1:kBGZzfjB9CEq2AlWe17Uuf7NDRt0dE0s8S51q0aT7Yg= @@ -472,6 +854,8 @@ github.com/grpc-ecosystem/grpc-gateway v1.9.0/go.mod h1:vNeuVxBJEsws4ogUvrchl83t github.com/grpc-ecosystem/grpc-gateway v1.9.5/go.mod h1:vNeuVxBJEsws4ogUvrchl83t/GYV9WGTSLVdBhOQFDY= github.com/grpc-ecosystem/grpc-gateway v1.16.0 h1:gmcG1KaJ57LophUzW0Hy8NmPhnMZb4M0+kPpLofRdBo= github.com/grpc-ecosystem/grpc-gateway v1.16.0/go.mod h1:BDjrQk3hbvj6Nolgz8mAMFbcEtjT1g+wF4CSlocrBnw= +github.com/grpc-ecosystem/grpc-gateway/v2 v2.7.0/go.mod h1:hgWBS7lorOAVIJEQMi4ZsPv9hVvWI6+ch50m39Pf2Ks= +github.com/grpc-ecosystem/grpc-gateway/v2 v2.11.3/go.mod h1:o//XUCC/F+yRGJoPO/VU0GSB0f8Nhgmxx0VIRUvaC0w= github.com/gsterjov/go-libsecret v0.0.0-20161001094733-a6f4afe4910c h1:6rhixN/i8ZofjG1Y75iExal34USq5p+wiN1tpie8IrU= github.com/gsterjov/go-libsecret v0.0.0-20161001094733-a6f4afe4910c/go.mod h1:NMPJylDgVpX0MLRlPy15sqSwOFv/U1GZ2m21JhFfek0= github.com/gtank/merlin v0.1.1-0.20191105220539-8318aed1a79f/go.mod h1:T86dnYJhcGOh5BjZFCJWTDeTK7XW8uE+E21Cy/bIQ+s= @@ -521,14 +905,17 @@ github.com/hashicorp/serf v0.8.2/go.mod h1:6hOLApaqBFA1NXqRQAsxw9QxuDEvNxSQRwA/J github.com/hashicorp/serf v0.9.5/go.mod h1:UWDWwZeL5cuWDJdl0C6wrvrUwEqtQ4ZKBKKENpqIUyk= github.com/hdevalence/ed25519consensus v0.0.0-20210204194344-59a8610d2b87 h1:uUjLpLt6bVvZ72SQc/B4dXcPBw4Vgd7soowdRl52qEM= github.com/hdevalence/ed25519consensus v0.0.0-20210204194344-59a8610d2b87/go.mod h1:XGsKKeXxeRr95aEOgipvluMPlgjr7dGlk9ZTWOjcUcg= +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.1.1/go.mod h1:y4ga/t+u+Xwd7CpDgZESaRcWy0I7XMlTMA25ApIH5Jw= +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/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU= github.com/hudl/fargo v1.3.0/go.mod h1:y3CKSmjA+wD2gak7sUSXTAoopbhU08POFhmITJgmKTg= github.com/huin/goupnp v1.0.0/go.mod h1:n9v9KO1tAxYH82qOn+UTIFQDmx5n1Zxd/ClZDMX7Bnc= github.com/huin/goupnp v1.0.2/go.mod h1:0dxJBVBHqTMjIUMkESDTNgOOx/Mw5wYIfyFmdzSamkM= github.com/huin/goutil v0.0.0-20170803182201-1ca381bf3150/go.mod h1:PpLOETDnJ0o3iZrZfqZzyLl6l7F3c6L1oWn7OICBi6o= +github.com/iancoleman/strcase v0.2.0/go.mod h1:iwCmte+B7n89clKwxIoIXy/HfoL7AsD47ZCWhYzw7ho= github.com/ianlancetaylor/demangle v0.0.0-20181102032728-5e5cf60278f6/go.mod h1:aSSvb/t6k1mPoxDqO4vJh6VOCGPwU4O0C2/Eqndh1Sc= github.com/ianlancetaylor/demangle v0.0.0-20200824232613-28f6c0f3b639/go.mod h1:aSSvb/t6k1mPoxDqO4vJh6VOCGPwU4O0C2/Eqndh1Sc= github.com/improbable-eng/grpc-web v0.14.1/go.mod h1:zEjGHa8DAlkoOXmswrNvhUGEYQA9UI7DhrGeHR1DMGU= @@ -615,6 +1002,8 @@ github.com/libp2p/go-buffer-pool v0.0.2/go.mod h1:MvaB6xw5vOrDl8rYZGLFdKAuk/hRoR github.com/lightstep/lightstep-tracer-common/golang/gogo v0.0.0-20190605223551-bc2310a04743/go.mod h1:qklhhLq1aX+mtWk9cPHPzaBjWImj5ULL6C7HFJtXQMM= github.com/lightstep/lightstep-tracer-go v0.18.1/go.mod h1:jlF1pusYV4pidLvZ+XD0UBX0ZE6WURAspgAczcDHrL4= github.com/lucasjones/reggen v0.0.0-20180717132126-cdb49ff09d77/go.mod h1:5ELEyG+X8f+meRWHuqUOewBOhvHkl7M76pdGEansxW4= +github.com/lyft/protoc-gen-star v0.6.0/go.mod h1:TGAoBVkt8w7MPG72TrKIu85MIdXwDuzJYeZuUPFPNwA= +github.com/lyft/protoc-gen-star v0.6.1/go.mod h1:TGAoBVkt8w7MPG72TrKIu85MIdXwDuzJYeZuUPFPNwA= github.com/lyft/protoc-gen-validate v0.0.13/go.mod h1:XbGvPuh87YZc5TdIa2/I4pLk0QoUACkjt2znoq26NVQ= github.com/magiconair/properties v1.8.0/go.mod h1:PppfXfuXeibc/6YijjN8zIbojt8czPbwD3XqdrwzmxQ= github.com/magiconair/properties v1.8.1/go.mod h1:PppfXfuXeibc/6YijjN8zIbojt8czPbwD3XqdrwzmxQ= @@ -760,6 +1149,7 @@ github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4= github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= github.com/pkg/profile v1.2.1/go.mod h1:hJw3o1OdXxsrSjjVksARp5W95eeEaEfptyVZyv6JUPA= github.com/pkg/sftp v1.10.1/go.mod h1:lYOWFsE0bwd1+KfKJaKeuokY15vzFx25BLbzYYoAxZI= +github.com/pkg/sftp v1.13.1/go.mod h1:3HaPG6Dq1ILlpPZRO0HVMrsydcdLt6HRDccSgb87qRg= github.com/pkg/term v0.0.0-20180730021639-bffc007b7fd5/go.mod h1:eCbImbZ95eXtAUIbLAuAVnBnwf83mjf6QIVH8SHYwqQ= github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= @@ -861,8 +1251,10 @@ github.com/spaolacci/murmur3 v0.0.0-20180118202830-f09979ecbc72/go.mod h1:JwIasO github.com/spaolacci/murmur3 v1.1.0 h1:7c1g84S4BPRrfL5Xrdp6fOJ206sU9y293DDHaoy0bLI= github.com/spaolacci/murmur3 v1.1.0/go.mod h1:JwIasOWyU6f++ZhiEuf87xNszmSA2myDM2Kzu9HwQUA= github.com/spf13/afero v1.1.2/go.mod h1:j4pytiNVoe2o6bmDsKpLACNPDBIoEAkihy7loJ1B0CQ= -github.com/spf13/afero v1.6.0 h1:xoax2sJ2DT8S8xA2paPFjDCScCNeWsg75VG0DLRreiY= +github.com/spf13/afero v1.3.3/go.mod h1:5KUK8ByomD5Ti5Artl0RtHeI5pTF7MIDuXL3yY520V4= github.com/spf13/afero v1.6.0/go.mod h1:Ai8FlHk4v/PARR026UzYexafAt9roJ7LcLMAmO6Z93I= +github.com/spf13/afero v1.9.2 h1:j49Hj62F0n+DaZ1dDCvhABaPNSGNkt32oRFxI33IEMw= +github.com/spf13/afero v1.9.2/go.mod h1:iUV7ddyEEZPO5gA3zD4fJt6iStLlL+Lg4m2cihcDf8Y= github.com/spf13/cast v1.3.0/go.mod h1:Qx5cxh0v+4UWYiBimWS+eyWzqEqokIECu5etghLkUJE= github.com/spf13/cast v1.3.1/go.mod h1:Qx5cxh0v+4UWYiBimWS+eyWzqEqokIECu5etghLkUJE= github.com/spf13/cast v1.4.1 h1:s0hze+J0196ZfEMTs80N7UlFt0BDuQ7Q+JDnHiMWKdA= @@ -893,16 +1285,21 @@ github.com/streadway/amqp v0.0.0-20190827072141-edfb9018d271/go.mod h1:AZpEONHx3 github.com/streadway/handy v0.0.0-20190108123426-d5acb3125c2a/go.mod h1:qNTQ5P5JnDBl6z3cMAg/SywNDC5ABu5ApDIw6lUbRmI= github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= -github.com/stretchr/objx v0.2.0 h1:Hbg2NidpLE8veEBkEZTL3CvlkUIVzuU9jDplZO54c48= github.com/stretchr/objx v0.2.0/go.mod h1:qt09Ya8vawLte6SNmTgCsAVtYtaKzEcn8ATUoHMkEqE= +github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw= +github.com/stretchr/objx v0.5.0 h1:1zr/of2m5FGMsad5YfcqgdqdWrIhu+EBEJRhR1U7z/c= +github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo= github.com/stretchr/testify v1.2.0/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs= 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.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= -github.com/stretchr/testify v1.7.0 h1:nwc3DEeHmmLAfoZucVR881uASk0Mfjw8xYJ99tb5CcY= github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= +github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= +github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU= +github.com/stretchr/testify v1.8.1 h1:w7B6lhMri9wdJUVmEZPGGhZzrYTPvgJArz7wNPgYKsk= +github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4= github.com/subosito/gotenv v1.2.0 h1:Slr1R9HxAlEKefgq5jn9U+DnETlIUa6HfgEzj0g5d7s= github.com/subosito/gotenv v1.2.0/go.mod h1:N0PQaV/YGNqwC0u51sEeR/aUtSLEXKX9iv69rRypqCw= github.com/syndtr/goleveldb v1.0.1-0.20200815110645-5c35d600f0ca/go.mod h1:u2MKkTVTVJWe5D1rCvame8WqhBd88EuIwODJZ1VHCPM= @@ -959,6 +1356,7 @@ github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9de github.com/yuin/goldmark v1.1.32/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= +github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY= github.com/zondax/hid v0.9.0 h1:eiT3P6vNxAEVxXMw66eZUAAnU2zD33JBkfG/EnfAKl8= github.com/zondax/hid v0.9.0/go.mod h1:l5wttcP0jwtdLjqjMMWFVEE7d1zO0jvSPA9OPZxWpEM= go.etcd.io/bbolt v1.3.2/go.mod h1:IbVyRI1SCnLcuJnV2u8VeU0CEYM7e686BmAb1XKL+uU= @@ -979,7 +1377,9 @@ go.opencensus.io v0.22.3/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw= go.opencensus.io v0.22.4/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw= go.opencensus.io v0.22.5/go.mod h1:5pWMHQbX5EPX2/62yrJeAkowc+lfs/XD7Uxpq3pI6kk= go.opencensus.io v0.23.0/go.mod h1:XItmlyltB5F7CS4xOC1DcqMoFqwtC6OG2xF7mCv7P7E= +go.opencensus.io v0.24.0/go.mod h1:vNK8G9p7aAivkbmorf4v+7Hgx+Zs0yY+0fOtgBfjQKo= go.opentelemetry.io/proto/otlp v0.7.0/go.mod h1:PqfVotwruBrMGOCsRd/89rSnXhoiJIqeYNgFYFoEGnI= +go.opentelemetry.io/proto/otlp v0.15.0/go.mod h1:H7XAot3MsfNsj7EXtrA2q5xSNQ10UqI405h3+duxN4U= go.uber.org/atomic v1.3.2/go.mod h1:gD2HeocX3+yG+ygLZcrzQJaqmWj9AIm7n08wl/qW/PE= go.uber.org/atomic v1.4.0/go.mod h1:gD2HeocX3+yG+ygLZcrzQJaqmWj9AIm7n08wl/qW/PE= go.uber.org/atomic v1.5.0/go.mod h1:sABNBOSYdrvTF6hTgEIbc7YasKWGhgEQZyfxyTvoXHQ= @@ -1017,10 +1417,13 @@ golang.org/x/crypto v0.0.0-20201016220609-9e8e0b390897/go.mod h1:LzIPMQfyMNhhGPh golang.org/x/crypto v0.0.0-20201117144127-c1f2f97bffc9/go.mod h1:jdWPYTVW3xRLrWPugEBEK3UY2ZEsg3UU495nc5E+M+I= golang.org/x/crypto v0.0.0-20201221181555-eec23a3978ad/go.mod h1:jdWPYTVW3xRLrWPugEBEK3UY2ZEsg3UU495nc5E+M+I= golang.org/x/crypto v0.0.0-20210322153248-0c34fe9e7dc2/go.mod h1:T9bdIzuCu7OtxOm1hfPfRQxPLYneinmdGuTeoZ9dtd4= +golang.org/x/crypto v0.0.0-20210421170649-83a5a9bb288b/go.mod h1:T9bdIzuCu7OtxOm1hfPfRQxPLYneinmdGuTeoZ9dtd4= golang.org/x/crypto v0.0.0-20210513164829-c07d793c2f9a/go.mod h1:P+XmwS30IXTQdn5tA2iutPOUgjI07+tq3H3K9MVA1s8= golang.org/x/crypto v0.0.0-20210817164053-32db794688a5/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc= -golang.org/x/crypto v0.0.0-20211115234514-b4de73f9ece8 h1:5QRxNnVsaJP6NAse0UdkRgL3zHMvCRRkrDVLNdNpdy4= -golang.org/x/crypto v0.0.0-20211115234514-b4de73f9ece8/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc= +golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc= +golang.org/x/crypto v0.0.0-20211108221036-ceb1ce70b4fa/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-20180321215751-8460e604b9de/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= golang.org/x/exp v0.0.0-20180807140117-3d87b88a115f/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= @@ -1036,6 +1439,8 @@ golang.org/x/exp v0.0.0-20200119233911-0405dc783f0a/go.mod h1:2RIsYlXP63K8oxa1u0 golang.org/x/exp v0.0.0-20200207192155-f17229e696bd/go.mod h1:J/WKrq2StrnmMY6+EHIKF9dgMWnmCNThgcyBT1FY9mM= golang.org/x/exp v0.0.0-20200224162631-6cc2880d07d6/go.mod h1:3jZMyOhIsHpP37uCMkUooju7aAi5cS1Q23tOzKc+0MU= golang.org/x/exp v0.0.0-20200331195152-e8c3332aa8e5/go.mod h1:4M0jN8W1tt0AVLNr8HDosyJCDCDuyL9N9+3m7wDWgKw= +golang.org/x/exp v0.0.0-20230131160201-f062dba9d201 h1:BEABXpNXLEz0WxtA+6CQIz2xkg80e+1zrhWyMcq8VzE= +golang.org/x/exp v0.0.0-20230131160201-f062dba9d201/go.mod h1:CxIveKay+FTh1D0yPZemJVgC/95VzuuOLq5Qi4xnoYc= golang.org/x/image v0.0.0-20180708004352-c73c2afc3b81/go.mod h1:ux5Hcp/YLpHSI86hEcLt0YII63i6oz57MZXIpbrjZUs= golang.org/x/image v0.0.0-20190227222117-0694c2d4d067/go.mod h1:kZ7UVZpmo3dzQBMxlp+ypCbDeSB+sBbTgSJuh5dn5js= golang.org/x/image v0.0.0-20190802002840-cff245a6509b/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0= @@ -1064,6 +1469,11 @@ golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= golang.org/x/mod v0.4.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= golang.org/x/mod v0.4.1/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= +golang.org/x/mod v0.5.0/go.mod h1:5OXOZSfqPIIbmVBIIKWRFfZjPR0E5r58TLhUjH0a2Ro= +golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4= +golang.org/x/mod v0.6.0/go.mod h1:4mET923SAdbXp2ki8ey+zGs1SLqsuM2Y0uvdZR/fUNI= +golang.org/x/mod v0.7.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs= +golang.org/x/mod v0.8.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs= golang.org/x/net v0.0.0-20180719180050-a680a1efc54d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= 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= @@ -1110,6 +1520,7 @@ golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwY golang.org/x/net v0.0.0-20201031054903-ff519b6c9102/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= golang.org/x/net v0.0.0-20201110031124-69a78807bb2b/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= golang.org/x/net v0.0.0-20201209123823-ac852fbbde11/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= +golang.org/x/net v0.0.0-20201224014010-6772e930b67b/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= golang.org/x/net v0.0.0-20210119194325-5f4716e94777/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= golang.org/x/net v0.0.0-20210220033124-5f55cee0dc0d/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= @@ -1119,8 +1530,24 @@ golang.org/x/net v0.0.0-20210428140749-89ef3d95e781/go.mod h1:OJAsFXCWl8Ukc7SiCT golang.org/x/net v0.0.0-20210503060351-7fd8e65b6420/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= golang.org/x/net v0.0.0-20210525063256-abc453219eb5/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= golang.org/x/net v0.0.0-20210805182204-aaa1db679c0d/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= -golang.org/x/net v0.0.0-20211111160137-58aab5ef257a h1:c83jeVQW0KGKNaKBRfelNYNHaev+qawl9yaA825s8XE= -golang.org/x/net v0.0.0-20211111160137-58aab5ef257a/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= +golang.org/x/net v0.0.0-20210813160813-60bc85c4be6d/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= +golang.org/x/net v0.0.0-20220127200216-cd36cc0744dd/go.mod h1:CfG3xpIq0wQ8r1q4Su4UZFWDARRcnwPjda9FqA0JpMk= +golang.org/x/net v0.0.0-20220225172249-27dd8689420f/go.mod h1:CfG3xpIq0wQ8r1q4Su4UZFWDARRcnwPjda9FqA0JpMk= +golang.org/x/net v0.0.0-20220325170049-de3da57026de/go.mod h1:CfG3xpIq0wQ8r1q4Su4UZFWDARRcnwPjda9FqA0JpMk= +golang.org/x/net v0.0.0-20220412020605-290c469a71a5/go.mod h1:CfG3xpIq0wQ8r1q4Su4UZFWDARRcnwPjda9FqA0JpMk= +golang.org/x/net v0.0.0-20220425223048-2871e0cb64e4/go.mod h1:CfG3xpIq0wQ8r1q4Su4UZFWDARRcnwPjda9FqA0JpMk= +golang.org/x/net v0.0.0-20220607020251-c690dde0001d/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c= +golang.org/x/net v0.0.0-20220617184016-355a448f1bc9/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c= +golang.org/x/net v0.0.0-20220624214902-1bab6f366d9e/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c= +golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c= +golang.org/x/net v0.0.0-20220909164309-bea034e7d591/go.mod h1:YDH+HFinaLZZlnHAfSS6ZXJJ9M9t4Dl22yv3iI2vPwk= +golang.org/x/net v0.0.0-20221012135044-0b7e1fb9d458/go.mod h1:YDH+HFinaLZZlnHAfSS6ZXJJ9M9t4Dl22yv3iI2vPwk= +golang.org/x/net v0.0.0-20221014081412-f15817d10f9b/go.mod h1:YDH+HFinaLZZlnHAfSS6ZXJJ9M9t4Dl22yv3iI2vPwk= +golang.org/x/net v0.1.0/go.mod h1:Cx3nUiGt4eDBEyega/BKRp+/AlGL8hYe7U9odMt2Cco= +golang.org/x/net v0.2.0/go.mod h1:KqCZLdyyvdV855qA2rE3GC2aiw5xGR5TEjj8smXukLY= +golang.org/x/net v0.5.0/go.mod h1:DivGGAXEgPSlEBzxGzZI+ZLohi+xUj054jfeKui00ws= +golang.org/x/net v0.6.0 h1:L4ZwwTvKW9gr0ZMS1yrHD9GZhIuVjOBBnaKH+SPQK0Q= +golang.org/x/net v0.6.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs= golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U= golang.org/x/oauth2 v0.0.0-20190226205417-e64efc72b421/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= golang.org/x/oauth2 v0.0.0-20190604053449-0f29369cfe45/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= @@ -1137,6 +1564,17 @@ golang.org/x/oauth2 v0.0.0-20210514164344-f6687ab2804c/go.mod h1:KelEdhl1UZF7XfJ golang.org/x/oauth2 v0.0.0-20210628180205-a41e5a781914/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= golang.org/x/oauth2 v0.0.0-20210805134026-6f1e6394065a/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= golang.org/x/oauth2 v0.0.0-20210819190943-2bc19b11175f/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= +golang.org/x/oauth2 v0.0.0-20211104180415-d3ed0bb246c8/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= +golang.org/x/oauth2 v0.0.0-20220223155221-ee480838109b/go.mod h1:DAh4E804XQdzx2j+YRIaUnCqCV2RuMz24cGBJ5QYIrc= +golang.org/x/oauth2 v0.0.0-20220309155454-6242fa91716a/go.mod h1:DAh4E804XQdzx2j+YRIaUnCqCV2RuMz24cGBJ5QYIrc= +golang.org/x/oauth2 v0.0.0-20220411215720-9780585627b5/go.mod h1:DAh4E804XQdzx2j+YRIaUnCqCV2RuMz24cGBJ5QYIrc= +golang.org/x/oauth2 v0.0.0-20220608161450-d0670ef3b1eb/go.mod h1:jaDAt6Dkxork7LmZnYtzbRWj0W47D86a3TGe0YHBvmE= +golang.org/x/oauth2 v0.0.0-20220622183110-fd043fe589d2/go.mod h1:jaDAt6Dkxork7LmZnYtzbRWj0W47D86a3TGe0YHBvmE= +golang.org/x/oauth2 v0.0.0-20220822191816-0ebed06d0094/go.mod h1:h4gKUeWbJ4rQPri7E0u6Gs4e9Ri2zaLxzw5DI5XGrYg= +golang.org/x/oauth2 v0.0.0-20220909003341-f21342109be1/go.mod h1:h4gKUeWbJ4rQPri7E0u6Gs4e9Ri2zaLxzw5DI5XGrYg= +golang.org/x/oauth2 v0.0.0-20221006150949-b44042a4b9c1/go.mod h1:h4gKUeWbJ4rQPri7E0u6Gs4e9Ri2zaLxzw5DI5XGrYg= +golang.org/x/oauth2 v0.0.0-20221014153046-6fdb5e3db783/go.mod h1:h4gKUeWbJ4rQPri7E0u6Gs4e9Ri2zaLxzw5DI5XGrYg= +golang.org/x/oauth2 v0.4.0/go.mod h1:RznEsdpjGAINPTOF0UH/t+xJ75L18YO3Ho6Pyn+uRec= 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= @@ -1148,6 +1586,10 @@ golang.org/x/sync v0.0.0-20200625203802-6e8e738ad208/go.mod h1:RxMgew5VJxzue5/jJ golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20201207232520-09787c993a3a/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.0.0-20220601150217-0de741cfad7f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20220929204114-8fcdb60fdcc0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sys v0.0.0-20180823144017-11551d06cbcc/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20180905080454-ebe1bf3edb33/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= @@ -1220,6 +1662,7 @@ golang.org/x/sys v0.0.0-20210112080510-489259a85091/go.mod h1:h1NjWce9XRLGQEsW7w golang.org/x/sys v0.0.0-20210119212857-b64e53b001e4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210124154548-22da62e12c0c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210220050731-9a76102bfb43/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210225134936-a50acf3fe073/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210305230114-8fe3ee5dd75b/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210315160823-c6e025ad8005/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210316164454-77fc1eacc6aa/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= @@ -1229,6 +1672,7 @@ golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/go.mod h1:h1NjWce9XRLGQEsW7w golang.org/x/sys v0.0.0-20210403161142-5e06dd20ab57/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210420205809-ac73e9fd8988/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210423185535-09eb48e85fd7/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-20210514084401-e8d321eab015/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20210603081109-ebe580a85c40/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= @@ -1239,11 +1683,36 @@ golang.org/x/sys v0.0.0-20210630005230-0f9fa26af87c/go.mod h1:oPkhp1MJrh7nUepCBc golang.org/x/sys v0.0.0-20210806184541-e5e7981a1069/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20210816183151-1e6c022a8912/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20210823070655-63515b42dcdf/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20211111213525-f221eed1c01e h1:zeJt6jBtVDK23XK9QXcmG0FvO0elikp0dYZQZOeL1y0= -golang.org/x/sys v0.0.0-20211111213525-f221eed1c01e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20210908233432-aa78b53d3365/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20211124211545-fe61309f8881/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20211210111614-af8b64212486/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20211216021012-1d35b9e2eb4e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220128215802-99c3d69c2c27/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220209214540-3681064d5158/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220227234510-4e6760a101f9/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220328115105-d36c6a25d886/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220412211240-33da011f77ad/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220502124256-b6088ccd6cba/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220503163025-988cb79eb6c6/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220610221304-9f5ed59c137d/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220615213510-4f61da869c0c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220624220833-87e55d714810/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220728004956-3c1f35247d10/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.1.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.2.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.4.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.5.0 h1:MUK/U/4lj1t1oPg0HfuXDN/Z1wv31ZJ/YcPiGccS4DU= +golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/term v0.0.0-20201117132131-f5c789dd3221/go.mod h1:Nr5EML6q2oocZ2LXRh80K7BxOlk5/8JxuGnuhpl+muw= -golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1 h1:v+OssWQX+hTHEmOBgwxdZxK4zHq3yOs8F9J7mk0PY8E= golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= +golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8= +golang.org/x/term v0.1.0/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8= +golang.org/x/term v0.2.0/go.mod h1:TVmDHMZPmdnySmBfhjOoOdhjzdE1h4u1VwSiw2l1Nuc= +golang.org/x/term v0.4.0/go.mod h1:9P2UbLfCdcvo3p/nzKvsmas4TnlujnuoV9hGgYzW1lQ= +golang.org/x/term v0.5.0 h1:n2a8QNdAb0sZNpU9R1ALUXBbY+w51fCQDN+7EdxNBsY= +golang.org/x/term v0.5.0/go.mod h1:jMB1sMXY+tzblOD4FWmEbocvup2/aLOaQEp7JmGp78k= golang.org/x/text v0.0.0-20170915032832-14c0d48ead0c/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.1-0.20180807135948-17ff2d5776d2/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= @@ -1252,14 +1721,20 @@ golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= golang.org/x/text v0.3.4/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 h1:olpwvP2KacW1ZWvsR7uQhoyTYvKAupfQrRGBFM352Gk= golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ= +golang.org/x/text v0.3.8/go.mod h1:E6s5w1FMmriuDzIBO73fBruAKo1PCIq6d2Q6DHfQ8WQ= +golang.org/x/text v0.4.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8= +golang.org/x/text v0.6.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8= +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-20180412165947-fbb02b2291d2/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= golang.org/x/time v0.0.0-20181108054448-85acf8d2951c/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= golang.org/x/time v0.0.0-20190308202827-9d24e82272b4/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= golang.org/x/time v0.0.0-20191024005414-555d28b269f0/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= golang.org/x/time v0.0.0-20201208040808-7e3f01d25324/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= golang.org/x/time v0.0.0-20210220033141-f8bda1e9f3ba/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= +golang.org/x/time v0.0.0-20220922220347-f3bd1da661af/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= +golang.org/x/time v0.1.0/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= golang.org/x/tools v0.0.0-20180525024113-a5b4c53f6e8b/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= golang.org/x/tools v0.0.0-20180828015842-6cd1fcedba52/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= @@ -1321,17 +1796,25 @@ golang.org/x/tools v0.0.0-20201201161351-ac6f37ff4c2a/go.mod h1:emZCQorbCU4vsT4f golang.org/x/tools v0.0.0-20201208233053-a543418bbed2/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= golang.org/x/tools v0.0.0-20201224043029-2b0845dc783e/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= golang.org/x/tools v0.0.0-20210105154028-b0ab187a4818/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= +golang.org/x/tools v0.0.0-20210108195828-e2f9c7f1fc8e/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= golang.org/x/tools v0.1.0/go.mod h1:xkSsbof2nBLbhDlRMhhhyNLN/zl3eTqcnHD5viDpcZ0= golang.org/x/tools v0.1.1/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk= golang.org/x/tools v0.1.2/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk= golang.org/x/tools v0.1.3/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk= golang.org/x/tools v0.1.4/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk= golang.org/x/tools v0.1.5/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk= +golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc= +golang.org/x/tools v0.2.0/go.mod h1:y4OqIKeOV/fWJetJ8bXPU1sEVniLMIyDAZWeHdV+NTA= +golang.org/x/tools v0.3.0/go.mod h1:/rWhSS2+zyEVwoJf8YAX6L2f0ntZ7Kn/mGgAWcipA5k= +golang.org/x/tools v0.6.0/go.mod h1:Xwgl3UAJ/d3gWutnCtw505GrjyAbvKui8lOU390QaIU= 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-20220411194840-2f41105eb62f/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +golang.org/x/xerrors v0.0.0-20220517211312-f3a8303e98df/go.mod h1:K8+ghG5WaK9qNqU5K3HdILfMLy1f3aNYFI/wnl100a8= +golang.org/x/xerrors v0.0.0-20220609144429-65e65417b02f/go.mod h1:K8+ghG5WaK9qNqU5K3HdILfMLy1f3aNYFI/wnl100a8= +golang.org/x/xerrors v0.0.0-20220907171357-04be3eba64a2/go.mod h1:K8+ghG5WaK9qNqU5K3HdILfMLy1f3aNYFI/wnl100a8= gonum.org/v1/gonum v0.0.0-20180816165407-929014505bf4/go.mod h1:Y+Yx5eoAFn32cQvJDxZx5Dpnq+c3wtXuadVZAcxbbBo= gonum.org/v1/gonum v0.0.0-20181121035319-3f7ecaa7e8ca/go.mod h1:Y+Yx5eoAFn32cQvJDxZx5Dpnq+c3wtXuadVZAcxbbBo= gonum.org/v1/gonum v0.6.0/go.mod h1:9mxDZsDKxgMAuccQkewq682L+0eCu4dCN2yonUJTCLU= @@ -1366,7 +1849,31 @@ google.golang.org/api v0.48.0/go.mod h1:71Pr1vy+TAZRPkPs/xlCf5SsU8WjuAWv1Pfjbtuk google.golang.org/api v0.50.0/go.mod h1:4bNT5pAuq5ji4SRZm+5QIkjny9JAyVD/3gaSihNefaw= google.golang.org/api v0.51.0/go.mod h1:t4HdrdoNgyN5cbEfm7Lum0lcLDLiise1F8qDKX00sOU= google.golang.org/api v0.54.0/go.mod h1:7C4bFFOvVDGXjfDTAsgGwDgAxRDeQ4X8NvUedIt6z3k= +google.golang.org/api v0.55.0/go.mod h1:38yMfeP1kfjsl8isn0tliTjIb1rJXcQi4UXlbqivdVE= google.golang.org/api v0.56.0/go.mod h1:38yMfeP1kfjsl8isn0tliTjIb1rJXcQi4UXlbqivdVE= +google.golang.org/api v0.57.0/go.mod h1:dVPlbZyBo2/OjBpmvNdpn2GRm6rPy75jyU7bmhdrMgI= +google.golang.org/api v0.61.0/go.mod h1:xQRti5UdCmoCEqFxcz93fTl338AVqDgyaDRuOZ3hg9I= +google.golang.org/api v0.63.0/go.mod h1:gs4ij2ffTRXwuzzgJl/56BdwJaA194ijkfn++9tDuPo= +google.golang.org/api v0.67.0/go.mod h1:ShHKP8E60yPsKNw/w8w+VYaj9H6buA5UqDp8dhbQZ6g= +google.golang.org/api v0.70.0/go.mod h1:Bs4ZM2HGifEvXwd50TtW70ovgJffJYw2oRCOFU/SkfA= +google.golang.org/api v0.71.0/go.mod h1:4PyU6e6JogV1f9eA4voyrTY2batOLdgZ5qZ5HOCc4j8= +google.golang.org/api v0.74.0/go.mod h1:ZpfMZOVRMywNyvJFeqL9HRWBgAuRfSjJFpe9QtRRyDs= +google.golang.org/api v0.75.0/go.mod h1:pU9QmyHLnzlpar1Mjt4IbapUCy8J+6HD6GeELN69ljA= +google.golang.org/api v0.77.0/go.mod h1:pU9QmyHLnzlpar1Mjt4IbapUCy8J+6HD6GeELN69ljA= +google.golang.org/api v0.78.0/go.mod h1:1Sg78yoMLOhlQTeF+ARBoytAcH1NNyyl390YMy6rKmw= +google.golang.org/api v0.80.0/go.mod h1:xY3nI94gbvBrE0J6NHXhxOmW97HG7Khjkku6AFB3Hyg= +google.golang.org/api v0.84.0/go.mod h1:NTsGnUFJMYROtiquksZHBWtHfeMC7iYthki7Eq3pa8o= +google.golang.org/api v0.85.0/go.mod h1:AqZf8Ep9uZ2pyTvgL+x0D3Zt0eoT9b5E8fmzfu6FO2g= +google.golang.org/api v0.90.0/go.mod h1:+Sem1dnrKlrXMR/X0bPnMWyluQe4RsNoYfmNLhOIkzw= +google.golang.org/api v0.93.0/go.mod h1:+Sem1dnrKlrXMR/X0bPnMWyluQe4RsNoYfmNLhOIkzw= +google.golang.org/api v0.95.0/go.mod h1:eADj+UBuxkh5zlrSntJghuNeg8HwQ1w5lTKkuqaETEI= +google.golang.org/api v0.96.0/go.mod h1:w7wJQLTM+wvQpNf5JyEcBoxK0RH7EDrh/L4qfsuJ13s= +google.golang.org/api v0.97.0/go.mod h1:w7wJQLTM+wvQpNf5JyEcBoxK0RH7EDrh/L4qfsuJ13s= +google.golang.org/api v0.98.0/go.mod h1:w7wJQLTM+wvQpNf5JyEcBoxK0RH7EDrh/L4qfsuJ13s= +google.golang.org/api v0.99.0/go.mod h1:1YOf74vkVndF7pG6hIHuINsM7eWwpVTAfNMNiL91A08= +google.golang.org/api v0.100.0/go.mod h1:ZE3Z2+ZOr87Rx7dqFsdRQkRBk36kDtp/h+QpHbB7a70= +google.golang.org/api v0.102.0/go.mod h1:3VFl6/fzoA+qNuS1N1/VfXY4LjoXN/wzeIp7TweWwGo= +google.golang.org/api v0.103.0/go.mod h1:hGtW6nK1AC+d9si/UBhw8Xli+QMOf6xyNAyJw4qU9w0= google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM= google.golang.org/appengine v1.2.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4= google.golang.org/appengine v1.4.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4= @@ -1418,11 +1925,14 @@ google.golang.org/genproto v0.0.0-20201119123407-9b1e624d6bc4/go.mod h1:FWY/as6D google.golang.org/genproto v0.0.0-20201201144952-b05cb90ed32e/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= google.golang.org/genproto v0.0.0-20201210142538-e3217bee35cc/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= google.golang.org/genproto v0.0.0-20201214200347-8c77b98c765d/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= +google.golang.org/genproto v0.0.0-20210108203827-ffc7fda8c3d7/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= google.golang.org/genproto v0.0.0-20210126160654-44e461bb6506/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= google.golang.org/genproto v0.0.0-20210222152913-aa3ee6e6a81c/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= +google.golang.org/genproto v0.0.0-20210226172003-ab064af71705/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= google.golang.org/genproto v0.0.0-20210303154014-9728d6b83eeb/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= google.golang.org/genproto v0.0.0-20210310155132-4ce2db91004e/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= google.golang.org/genproto v0.0.0-20210319143718-93e7006c17a6/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= +google.golang.org/genproto v0.0.0-20210329143202-679c6ae281ee/go.mod h1:9lPAdzaEmUacj36I+k7YKbEc5CXzPIeORRgDAUOu28A= google.golang.org/genproto v0.0.0-20210402141018-6c239bbf2bb1/go.mod h1:9lPAdzaEmUacj36I+k7YKbEc5CXzPIeORRgDAUOu28A= google.golang.org/genproto v0.0.0-20210513213006-bf773b8c8384/go.mod h1:P3QM42oQyzQSnHPnZ/vqoCdDmzH28fzWByN9asMeM8A= google.golang.org/genproto v0.0.0-20210602131652-f16073e35f0c/go.mod h1:UODoCrxHCcBojKKwX1terBiRUaqAsFqJiF615XL43r0= @@ -1436,8 +1946,64 @@ google.golang.org/genproto v0.0.0-20210805201207-89edb61ffb67/go.mod h1:ob2IJxKr google.golang.org/genproto v0.0.0-20210813162853-db860fec028c/go.mod h1:cFeNkxwySK631ADgubI+/XFU/xp8FD5KIVV4rj8UC5w= google.golang.org/genproto v0.0.0-20210821163610-241b8fcbd6c8/go.mod h1:eFjDcFEctNawg4eG61bRv87N7iHBWyVhJu7u1kqDUXY= google.golang.org/genproto v0.0.0-20210828152312-66f60bf46e71/go.mod h1:eFjDcFEctNawg4eG61bRv87N7iHBWyVhJu7u1kqDUXY= -google.golang.org/genproto v0.0.0-20211116182654-e63d96a377c4 h1:nPiLDJ9/wsay2NDshdJ1B24frx+butTxmaVaCxDBChY= -google.golang.org/genproto v0.0.0-20211116182654-e63d96a377c4/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc= +google.golang.org/genproto v0.0.0-20210831024726-fe130286e0e2/go.mod h1:eFjDcFEctNawg4eG61bRv87N7iHBWyVhJu7u1kqDUXY= +google.golang.org/genproto v0.0.0-20210903162649-d08c68adba83/go.mod h1:eFjDcFEctNawg4eG61bRv87N7iHBWyVhJu7u1kqDUXY= +google.golang.org/genproto v0.0.0-20210909211513-a8c4777a87af/go.mod h1:eFjDcFEctNawg4eG61bRv87N7iHBWyVhJu7u1kqDUXY= +google.golang.org/genproto v0.0.0-20210924002016-3dee208752a0/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc= +google.golang.org/genproto v0.0.0-20211118181313-81c1377c94b1/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc= +google.golang.org/genproto v0.0.0-20211206160659-862468c7d6e0/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc= +google.golang.org/genproto v0.0.0-20211208223120-3a66f561d7aa/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc= +google.golang.org/genproto v0.0.0-20211221195035-429b39de9b1c/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc= +google.golang.org/genproto v0.0.0-20220126215142-9970aeb2e350/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc= +google.golang.org/genproto v0.0.0-20220207164111-0872dc986b00/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc= +google.golang.org/genproto v0.0.0-20220218161850-94dd64e39d7c/go.mod h1:kGP+zUP2Ddo0ayMi4YuN7C3WZyJvGLZRh8Z5wnAqvEI= +google.golang.org/genproto v0.0.0-20220222213610-43724f9ea8cf/go.mod h1:kGP+zUP2Ddo0ayMi4YuN7C3WZyJvGLZRh8Z5wnAqvEI= +google.golang.org/genproto v0.0.0-20220304144024-325a89244dc8/go.mod h1:kGP+zUP2Ddo0ayMi4YuN7C3WZyJvGLZRh8Z5wnAqvEI= +google.golang.org/genproto v0.0.0-20220310185008-1973136f34c6/go.mod h1:kGP+zUP2Ddo0ayMi4YuN7C3WZyJvGLZRh8Z5wnAqvEI= +google.golang.org/genproto v0.0.0-20220324131243-acbaeb5b85eb/go.mod h1:hAL49I2IFola2sVEjAn7MEwsja0xp51I0tlGAf9hz4E= +google.golang.org/genproto v0.0.0-20220329172620-7be39ac1afc7/go.mod h1:8w6bsBMX6yCPbAVTeqQHvzxW0EIFigd5lZyahWgyfDo= +google.golang.org/genproto v0.0.0-20220407144326-9054f6ed7bac/go.mod h1:8w6bsBMX6yCPbAVTeqQHvzxW0EIFigd5lZyahWgyfDo= +google.golang.org/genproto v0.0.0-20220413183235-5e96e2839df9/go.mod h1:8w6bsBMX6yCPbAVTeqQHvzxW0EIFigd5lZyahWgyfDo= +google.golang.org/genproto v0.0.0-20220414192740-2d67ff6cf2b4/go.mod h1:8w6bsBMX6yCPbAVTeqQHvzxW0EIFigd5lZyahWgyfDo= +google.golang.org/genproto v0.0.0-20220421151946-72621c1f0bd3/go.mod h1:8w6bsBMX6yCPbAVTeqQHvzxW0EIFigd5lZyahWgyfDo= +google.golang.org/genproto v0.0.0-20220429170224-98d788798c3e/go.mod h1:8w6bsBMX6yCPbAVTeqQHvzxW0EIFigd5lZyahWgyfDo= +google.golang.org/genproto v0.0.0-20220502173005-c8bf987b8c21/go.mod h1:RAyBrSAP7Fh3Nc84ghnVLDPuV51xc9agzmm4Ph6i0Q4= +google.golang.org/genproto v0.0.0-20220505152158-f39f71e6c8f3/go.mod h1:RAyBrSAP7Fh3Nc84ghnVLDPuV51xc9agzmm4Ph6i0Q4= +google.golang.org/genproto v0.0.0-20220518221133-4f43b3371335/go.mod h1:RAyBrSAP7Fh3Nc84ghnVLDPuV51xc9agzmm4Ph6i0Q4= +google.golang.org/genproto v0.0.0-20220523171625-347a074981d8/go.mod h1:RAyBrSAP7Fh3Nc84ghnVLDPuV51xc9agzmm4Ph6i0Q4= +google.golang.org/genproto v0.0.0-20220608133413-ed9918b62aac/go.mod h1:KEWEmljWE5zPzLBa/oHl6DaEt9LmfH6WtH1OHIvleBA= +google.golang.org/genproto v0.0.0-20220616135557-88e70c0c3a90/go.mod h1:KEWEmljWE5zPzLBa/oHl6DaEt9LmfH6WtH1OHIvleBA= +google.golang.org/genproto v0.0.0-20220617124728-180714bec0ad/go.mod h1:KEWEmljWE5zPzLBa/oHl6DaEt9LmfH6WtH1OHIvleBA= +google.golang.org/genproto v0.0.0-20220624142145-8cd45d7dbd1f/go.mod h1:KEWEmljWE5zPzLBa/oHl6DaEt9LmfH6WtH1OHIvleBA= +google.golang.org/genproto v0.0.0-20220628213854-d9e0b6570c03/go.mod h1:KEWEmljWE5zPzLBa/oHl6DaEt9LmfH6WtH1OHIvleBA= +google.golang.org/genproto v0.0.0-20220722212130-b98a9ff5e252/go.mod h1:GkXuJDJ6aQ7lnJcRF+SJVgFdQhypqgl3LB1C9vabdRE= +google.golang.org/genproto v0.0.0-20220801145646-83ce21fca29f/go.mod h1:iHe1svFLAZg9VWz891+QbRMwUv9O/1Ww+/mngYeThbc= +google.golang.org/genproto v0.0.0-20220815135757-37a418bb8959/go.mod h1:dbqgFATTzChvnt+ujMdZwITVAJHFtfyN1qUhDqEiIlk= +google.golang.org/genproto v0.0.0-20220817144833-d7fd3f11b9b1/go.mod h1:dbqgFATTzChvnt+ujMdZwITVAJHFtfyN1qUhDqEiIlk= +google.golang.org/genproto v0.0.0-20220822174746-9e6da59bd2fc/go.mod h1:dbqgFATTzChvnt+ujMdZwITVAJHFtfyN1qUhDqEiIlk= +google.golang.org/genproto v0.0.0-20220829144015-23454907ede3/go.mod h1:dbqgFATTzChvnt+ujMdZwITVAJHFtfyN1qUhDqEiIlk= +google.golang.org/genproto v0.0.0-20220829175752-36a9c930ecbf/go.mod h1:dbqgFATTzChvnt+ujMdZwITVAJHFtfyN1qUhDqEiIlk= +google.golang.org/genproto v0.0.0-20220913154956-18f8339a66a5/go.mod h1:0Nb8Qy+Sk5eDzHnzlStwW3itdNaWoZA5XeSG+R3JHSo= +google.golang.org/genproto v0.0.0-20220914142337-ca0e39ece12f/go.mod h1:0Nb8Qy+Sk5eDzHnzlStwW3itdNaWoZA5XeSG+R3JHSo= +google.golang.org/genproto v0.0.0-20220915135415-7fd63a7952de/go.mod h1:0Nb8Qy+Sk5eDzHnzlStwW3itdNaWoZA5XeSG+R3JHSo= +google.golang.org/genproto v0.0.0-20220916172020-2692e8806bfa/go.mod h1:0Nb8Qy+Sk5eDzHnzlStwW3itdNaWoZA5XeSG+R3JHSo= +google.golang.org/genproto v0.0.0-20220919141832-68c03719ef51/go.mod h1:0Nb8Qy+Sk5eDzHnzlStwW3itdNaWoZA5XeSG+R3JHSo= +google.golang.org/genproto v0.0.0-20220920201722-2b89144ce006/go.mod h1:ht8XFiar2npT/g4vkk7O0WYS1sHOHbdujxbEp7CJWbw= +google.golang.org/genproto v0.0.0-20220926165614-551eb538f295/go.mod h1:woMGP53BroOrRY3xTxlbr8Y3eB/nzAvvFM83q7kG2OI= +google.golang.org/genproto v0.0.0-20220926220553-6981cbe3cfce/go.mod h1:woMGP53BroOrRY3xTxlbr8Y3eB/nzAvvFM83q7kG2OI= +google.golang.org/genproto v0.0.0-20221010155953-15ba04fc1c0e/go.mod h1:3526vdqwhZAwq4wsRUaVG555sVgsNmIjRtO7t/JH29U= +google.golang.org/genproto v0.0.0-20221014173430-6e2ab493f96b/go.mod h1:1vXfmgAz9N9Jx0QA82PqRVauvCz1SGSz739p0f183jM= +google.golang.org/genproto v0.0.0-20221014213838-99cd37c6964a/go.mod h1:1vXfmgAz9N9Jx0QA82PqRVauvCz1SGSz739p0f183jM= +google.golang.org/genproto v0.0.0-20221024153911-1573dae28c9c/go.mod h1:9qHF0xnpdSfF6knlcsnpzUu5y+rpwgbvsyGAZPBMg4s= +google.golang.org/genproto v0.0.0-20221024183307-1bc688fe9f3e/go.mod h1:9qHF0xnpdSfF6knlcsnpzUu5y+rpwgbvsyGAZPBMg4s= +google.golang.org/genproto v0.0.0-20221027153422-115e99e71e1c/go.mod h1:CGI5F/G+E5bKwmfYo09AXuVN4dD894kIKUFmVbP2/Fo= +google.golang.org/genproto v0.0.0-20221114212237-e4508ebdbee1/go.mod h1:rZS5c/ZVYMaOGBfO68GWtjOw/eLaZM1X6iVtgjZ+EWg= +google.golang.org/genproto v0.0.0-20221117204609-8f9c96812029/go.mod h1:rZS5c/ZVYMaOGBfO68GWtjOw/eLaZM1X6iVtgjZ+EWg= +google.golang.org/genproto v0.0.0-20221118155620-16455021b5e6/go.mod h1:rZS5c/ZVYMaOGBfO68GWtjOw/eLaZM1X6iVtgjZ+EWg= +google.golang.org/genproto v0.0.0-20221201164419-0e50fba7f41c/go.mod h1:rZS5c/ZVYMaOGBfO68GWtjOw/eLaZM1X6iVtgjZ+EWg= +google.golang.org/genproto v0.0.0-20221202195650-67e5cbc046fd/go.mod h1:cTsE614GARnxrLsqKREzmNYJACSWWpAWdNMwnD7c2BE= +google.golang.org/genproto v0.0.0-20230110181048-76db0878b65f h1:BWUVssLB0HVOSY78gIdvk1dTVYtT1y8SBWtPYuTJ/6w= +google.golang.org/genproto v0.0.0-20230110181048-76db0878b65f/go.mod h1:RGgjbofJ8xD9Sq1VVhDM1Vok1vRONV+rg+CjzG4SZKM= google.golang.org/grpc v1.17.0/go.mod h1:6QZJwpn2B+Zp71q/5VxRsJ6NXXVCE5NRUHRo+f3cWCs= google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c= google.golang.org/grpc v1.19.1/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c= @@ -1470,8 +2036,20 @@ google.golang.org/grpc v1.38.0/go.mod h1:NREThFqKR1f3iQ6oBuvc5LadQuXVGo9rkm5ZGrQ google.golang.org/grpc v1.39.0/go.mod h1:PImNr+rS9TWYb2O4/emRugxiyHZ5JyHW5F+RPnDzfrE= google.golang.org/grpc v1.39.1/go.mod h1:PImNr+rS9TWYb2O4/emRugxiyHZ5JyHW5F+RPnDzfrE= google.golang.org/grpc v1.40.0/go.mod h1:ogyxbiOoUXAkP+4+xa6PZSE9DZgIHtSpzjDTB9KAK34= -google.golang.org/grpc v1.41.0 h1:f+PlOh7QV4iIJkPrx5NQ7qaNGFQ3OTse67yaDHfju4E= -google.golang.org/grpc v1.41.0/go.mod h1:U3l9uK9J0sini8mHphKoXyaqDA/8VyGnDee1zzIUK6k= +google.golang.org/grpc v1.40.1/go.mod h1:ogyxbiOoUXAkP+4+xa6PZSE9DZgIHtSpzjDTB9KAK34= +google.golang.org/grpc v1.42.0/go.mod h1:k+4IHHFw41K8+bbowsex27ge2rCb65oeWqe4jJ590SU= +google.golang.org/grpc v1.44.0/go.mod h1:k+4IHHFw41K8+bbowsex27ge2rCb65oeWqe4jJ590SU= +google.golang.org/grpc v1.45.0/go.mod h1:lN7owxKUQEqMfSyQikvvk5tf/6zMPsrK+ONuO11+0rQ= +google.golang.org/grpc v1.46.0/go.mod h1:vN9eftEi1UMyUsIF80+uQXhHjbXYbm0uXoFCACuMGWk= +google.golang.org/grpc v1.46.2/go.mod h1:vN9eftEi1UMyUsIF80+uQXhHjbXYbm0uXoFCACuMGWk= +google.golang.org/grpc v1.47.0/go.mod h1:vN9eftEi1UMyUsIF80+uQXhHjbXYbm0uXoFCACuMGWk= +google.golang.org/grpc v1.48.0/go.mod h1:vN9eftEi1UMyUsIF80+uQXhHjbXYbm0uXoFCACuMGWk= +google.golang.org/grpc v1.49.0/go.mod h1:ZgQEeidpAuNRZ8iRrlBKXZQP1ghovWIVhdJRyCDK+GI= +google.golang.org/grpc v1.50.0/go.mod h1:ZgQEeidpAuNRZ8iRrlBKXZQP1ghovWIVhdJRyCDK+GI= +google.golang.org/grpc v1.50.1/go.mod h1:ZgQEeidpAuNRZ8iRrlBKXZQP1ghovWIVhdJRyCDK+GI= +google.golang.org/grpc v1.51.0/go.mod h1:wgNDFcnuBGmxLKI/qn4T+m5BtEBYXJPvibbUPsAIPww= +google.golang.org/grpc v1.53.0 h1:LAv2ds7cmFV/XTS3XG1NneeENYrXGmorPxsBbptIjNc= +google.golang.org/grpc v1.53.0/go.mod h1:OnIrk0ipVdj4N5d9IUoFUx72/VlD7+jUsHwZgwSMQpw= google.golang.org/grpc/cmd/protoc-gen-go-grpc v1.1.0/go.mod h1:6Kw0yEErY5E/yWrBtf03jp27GLLJujG4z/JK95pnjjw= 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= @@ -1486,8 +2064,10 @@ google.golang.org/protobuf v1.25.0/go.mod h1:9JNX74DMeImyA3h4bdi1ymwjUzf21/xIlba google.golang.org/protobuf v1.25.1-0.20200805231151-a709e31e5d12/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.27.1 h1:SnqbnDw1V7RiZcXPx5MEeqPv2s79L9i7BJUlG/+RurQ= google.golang.org/protobuf v1.27.1/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc= +google.golang.org/protobuf v1.28.0/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I= +google.golang.org/protobuf v1.28.1 h1:d0NfwRgPtno5B1Wa6L2DAG+KivqkdutMf1UhdNx175w= +google.golang.org/protobuf v1.28.1/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I= gopkg.in/alecthomas/kingpin.v2 v2.2.6/go.mod h1:FMv+mEhP44yOT+4EoQTLFTRgOQ1FBLkstjWtayDeSgw= 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= @@ -1505,6 +2085,7 @@ gopkg.in/ini.v1 v1.51.0/go.mod h1:pNLf8WUiyNEtQjuu5G5vTm06TEv9tsIgeAvK8hOrP4k= gopkg.in/ini.v1 v1.62.0/go.mod h1:pNLf8WUiyNEtQjuu5G5vTm06TEv9tsIgeAvK8hOrP4k= gopkg.in/ini.v1 v1.63.2 h1:tGK/CyBg7SMzb60vP1M03vNZ3VDu3wGQJwn7Sxi9r3c= gopkg.in/ini.v1 v1.63.2/go.mod h1:pNLf8WUiyNEtQjuu5G5vTm06TEv9tsIgeAvK8hOrP4k= +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/olebedev/go-duktape.v3 v3.0.0-20200619000410-60c24ae608a6/go.mod h1:uAJfkITjFhyEEuUfm7bsmCZRbW5WRq8s9EY8HZ6hCns= gopkg.in/resty.v1 v1.12.0/go.mod h1:mDo4pnntr5jdWRML875a/NmxYqAlA73dVijT2AXvQQo= @@ -1523,8 +2104,9 @@ 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.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ= gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= -gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b h1:h8qDotaEPuJATrMmW04NCwg7v22aHH28wwpauUhK9Oo= gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= +gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= +gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= gotest.tools v2.2.0+incompatible/go.mod h1:DsYFclhRJ6vuDpmuTbkuFWG+y2sxOXAzmJt81HFBacw= honnef.co/go/tools v0.0.0-20180728063816-88497007e858/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= diff --git a/gov/gov.pb.go b/gov/gov.pb.go index 52402ea..e3beb5b 100644 --- a/gov/gov.pb.go +++ b/gov/gov.pb.go @@ -5,9 +5,9 @@ package gov import ( fmt "fmt" + proto "github.com/cosmos/gogoproto/proto" + github_com_cosmos_gogoproto_types "github.com/cosmos/gogoproto/types" _ "github.com/gogo/protobuf/gogoproto" - proto "github.com/gogo/protobuf/proto" - github_com_gogo_protobuf_types "github.com/gogo/protobuf/types" types1 "github.com/irisnet/core-sdk-go/common/codec/types" github_com_irisnet_core_sdk_go_types "github.com/irisnet/core-sdk-go/types" types "github.com/irisnet/core-sdk-go/types" @@ -773,7 +773,7 @@ func (m *Proposal) MarshalToSizedBuffer(dAtA []byte) (int, error) { _ = i var l int _ = l - n1, err1 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.VotingEndTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.VotingEndTime):]) + n1, err1 := github_com_cosmos_gogoproto_types.StdTimeMarshalTo(m.VotingEndTime, dAtA[i-github_com_cosmos_gogoproto_types.SizeOfStdTime(m.VotingEndTime):]) if err1 != nil { return 0, err1 } @@ -781,7 +781,7 @@ func (m *Proposal) MarshalToSizedBuffer(dAtA []byte) (int, error) { i = encodeVarintGov(dAtA, i, uint64(n1)) i-- dAtA[i] = 0x4a - n2, err2 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.VotingStartTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.VotingStartTime):]) + n2, err2 := github_com_cosmos_gogoproto_types.StdTimeMarshalTo(m.VotingStartTime, dAtA[i-github_com_cosmos_gogoproto_types.SizeOfStdTime(m.VotingStartTime):]) if err2 != nil { return 0, err2 } @@ -803,7 +803,7 @@ func (m *Proposal) MarshalToSizedBuffer(dAtA []byte) (int, error) { dAtA[i] = 0x3a } } - n3, err3 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.DepositEndTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.DepositEndTime):]) + n3, err3 := github_com_cosmos_gogoproto_types.StdTimeMarshalTo(m.DepositEndTime, dAtA[i-github_com_cosmos_gogoproto_types.SizeOfStdTime(m.DepositEndTime):]) if err3 != nil { return 0, err3 } @@ -811,7 +811,7 @@ func (m *Proposal) MarshalToSizedBuffer(dAtA []byte) (int, error) { i = encodeVarintGov(dAtA, i, uint64(n3)) i-- dAtA[i] = 0x32 - n4, err4 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.SubmitTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.SubmitTime):]) + n4, err4 := github_com_cosmos_gogoproto_types.StdTimeMarshalTo(m.SubmitTime, dAtA[i-github_com_cosmos_gogoproto_types.SizeOfStdTime(m.SubmitTime):]) if err4 != nil { return 0, err4 } @@ -977,7 +977,7 @@ func (m *DepositParams) MarshalToSizedBuffer(dAtA []byte) (int, error) { _ = i var l int _ = l - n7, err7 := github_com_gogo_protobuf_types.StdDurationMarshalTo(m.MaxDepositPeriod, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdDuration(m.MaxDepositPeriod):]) + n7, err7 := github_com_cosmos_gogoproto_types.StdDurationMarshalTo(m.MaxDepositPeriod, dAtA[i-github_com_cosmos_gogoproto_types.SizeOfStdDuration(m.MaxDepositPeriod):]) if err7 != nil { return 0, err7 } @@ -1022,7 +1022,7 @@ func (m *VotingParams) MarshalToSizedBuffer(dAtA []byte) (int, error) { _ = i var l int _ = l - n8, err8 := github_com_gogo_protobuf_types.StdDurationMarshalTo(m.VotingPeriod, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdDuration(m.VotingPeriod):]) + n8, err8 := github_com_cosmos_gogoproto_types.StdDurationMarshalTo(m.VotingPeriod, dAtA[i-github_com_cosmos_gogoproto_types.SizeOfStdDuration(m.VotingPeriod):]) if err8 != nil { return 0, err8 } @@ -1154,9 +1154,9 @@ func (m *Proposal) Size() (n int) { } l = m.FinalTallyResult.Size() n += 1 + l + sovGov(uint64(l)) - l = github_com_gogo_protobuf_types.SizeOfStdTime(m.SubmitTime) + l = github_com_cosmos_gogoproto_types.SizeOfStdTime(m.SubmitTime) n += 1 + l + sovGov(uint64(l)) - l = github_com_gogo_protobuf_types.SizeOfStdTime(m.DepositEndTime) + l = github_com_cosmos_gogoproto_types.SizeOfStdTime(m.DepositEndTime) n += 1 + l + sovGov(uint64(l)) if len(m.TotalDeposit) > 0 { for _, e := range m.TotalDeposit { @@ -1164,9 +1164,9 @@ func (m *Proposal) Size() (n int) { n += 1 + l + sovGov(uint64(l)) } } - l = github_com_gogo_protobuf_types.SizeOfStdTime(m.VotingStartTime) + l = github_com_cosmos_gogoproto_types.SizeOfStdTime(m.VotingStartTime) n += 1 + l + sovGov(uint64(l)) - l = github_com_gogo_protobuf_types.SizeOfStdTime(m.VotingEndTime) + l = github_com_cosmos_gogoproto_types.SizeOfStdTime(m.VotingEndTime) n += 1 + l + sovGov(uint64(l)) return n } @@ -1219,7 +1219,7 @@ func (m *DepositParams) Size() (n int) { n += 1 + l + sovGov(uint64(l)) } } - l = github_com_gogo_protobuf_types.SizeOfStdDuration(m.MaxDepositPeriod) + l = github_com_cosmos_gogoproto_types.SizeOfStdDuration(m.MaxDepositPeriod) n += 1 + l + sovGov(uint64(l)) return n } @@ -1230,7 +1230,7 @@ func (m *VotingParams) Size() (n int) { } var l int _ = l - l = github_com_gogo_protobuf_types.SizeOfStdDuration(m.VotingPeriod) + l = github_com_cosmos_gogoproto_types.SizeOfStdDuration(m.VotingPeriod) n += 1 + l + sovGov(uint64(l)) return n } @@ -1670,7 +1670,7 @@ func (m *Proposal) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.SubmitTime, dAtA[iNdEx:postIndex]); err != nil { + if err := github_com_cosmos_gogoproto_types.StdTimeUnmarshal(&m.SubmitTime, dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -1703,7 +1703,7 @@ func (m *Proposal) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.DepositEndTime, dAtA[iNdEx:postIndex]); err != nil { + if err := github_com_cosmos_gogoproto_types.StdTimeUnmarshal(&m.DepositEndTime, dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -1770,7 +1770,7 @@ func (m *Proposal) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.VotingStartTime, dAtA[iNdEx:postIndex]); err != nil { + if err := github_com_cosmos_gogoproto_types.StdTimeUnmarshal(&m.VotingStartTime, dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -1803,7 +1803,7 @@ func (m *Proposal) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.VotingEndTime, dAtA[iNdEx:postIndex]); err != nil { + if err := github_com_cosmos_gogoproto_types.StdTimeUnmarshal(&m.VotingEndTime, dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -2226,7 +2226,7 @@ func (m *DepositParams) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if err := github_com_gogo_protobuf_types.StdDurationUnmarshal(&m.MaxDepositPeriod, dAtA[iNdEx:postIndex]); err != nil { + if err := github_com_cosmos_gogoproto_types.StdDurationUnmarshal(&m.MaxDepositPeriod, dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -2309,7 +2309,7 @@ func (m *VotingParams) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if err := github_com_gogo_protobuf_types.StdDurationUnmarshal(&m.VotingPeriod, dAtA[iNdEx:postIndex]); err != nil { + if err := github_com_cosmos_gogoproto_types.StdDurationUnmarshal(&m.VotingPeriod, dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex diff --git a/gov/query.pb.go b/gov/query.pb.go index 8ef050d..ce7e182 100644 --- a/gov/query.pb.go +++ b/gov/query.pb.go @@ -6,9 +6,9 @@ package gov import ( context "context" fmt "fmt" + grpc1 "github.com/cosmos/gogoproto/grpc" + proto "github.com/cosmos/gogoproto/proto" _ "github.com/gogo/protobuf/gogoproto" - grpc1 "github.com/gogo/protobuf/grpc" - proto "github.com/gogo/protobuf/proto" query "github.com/irisnet/core-sdk-go/types/query" _ "google.golang.org/genproto/googleapis/api/annotations" grpc "google.golang.org/grpc" diff --git a/gov/tx.pb.go b/gov/tx.pb.go index eed6cdc..4d17926 100644 --- a/gov/tx.pb.go +++ b/gov/tx.pb.go @@ -6,9 +6,9 @@ package gov import ( context "context" fmt "fmt" + grpc1 "github.com/cosmos/gogoproto/grpc" + proto "github.com/cosmos/gogoproto/proto" _ "github.com/gogo/protobuf/gogoproto" - grpc1 "github.com/gogo/protobuf/grpc" - proto "github.com/gogo/protobuf/proto" types "github.com/irisnet/core-sdk-go/common/codec/types" github_com_irisnet_core_sdk_go_types "github.com/irisnet/core-sdk-go/types" types1 "github.com/irisnet/core-sdk-go/types" diff --git a/ibc/transfer/query.pb.go b/ibc/transfer/query.pb.go index 94ff16a..eeae146 100644 --- a/ibc/transfer/query.pb.go +++ b/ibc/transfer/query.pb.go @@ -6,9 +6,9 @@ package transfer import ( context "context" fmt "fmt" + grpc1 "github.com/cosmos/gogoproto/grpc" + proto "github.com/cosmos/gogoproto/proto" _ "github.com/gogo/protobuf/gogoproto" - grpc1 "github.com/gogo/protobuf/grpc" - proto "github.com/gogo/protobuf/proto" query "github.com/irisnet/core-sdk-go/types/query" _ "google.golang.org/genproto/googleapis/api/annotations" grpc "google.golang.org/grpc" diff --git a/ibc/transfer/tx.pb.go b/ibc/transfer/tx.pb.go index 7d6d683..ae84cec 100644 --- a/ibc/transfer/tx.pb.go +++ b/ibc/transfer/tx.pb.go @@ -6,9 +6,9 @@ package transfer import ( context "context" fmt "fmt" + grpc1 "github.com/cosmos/gogoproto/grpc" + proto "github.com/cosmos/gogoproto/proto" _ "github.com/gogo/protobuf/gogoproto" - grpc1 "github.com/gogo/protobuf/grpc" - proto "github.com/gogo/protobuf/proto" types "github.com/irisnet/core-sdk-go/types" grpc "google.golang.org/grpc" codes "google.golang.org/grpc/codes" diff --git a/proto/ethermint/evm/v1/evm.proto b/proto/ethermint/evm/v1/evm.proto new file mode 100644 index 0000000..4b71518 --- /dev/null +++ b/proto/ethermint/evm/v1/evm.proto @@ -0,0 +1,232 @@ +syntax = "proto3"; +package ethermint.evm.v1; + +import "gogoproto/gogo.proto"; + +option go_package = "github.com/irisnet/core-sdk-go/ethermint/x/evm/types"; + +// Params defines the EVM module parameters +message Params { + // evm denom represents the token denomination used to run the EVM state + // transitions. + string evm_denom = 1 [ (gogoproto.moretags) = "yaml:\"evm_denom\"" ]; + // enable create toggles state transitions that use the vm.Create function + bool enable_create = 2 [ (gogoproto.moretags) = "yaml:\"enable_create\"" ]; + // enable call toggles state transitions that use the vm.Call function + bool enable_call = 3 [ (gogoproto.moretags) = "yaml:\"enable_call\"" ]; + // extra eips defines the additional EIPs for the vm.Config + repeated int64 extra_eips = 4 [ + (gogoproto.customname) = "ExtraEIPs", + (gogoproto.moretags) = "yaml:\"extra_eips\"" + ]; + // chain config defines the EVM chain configuration parameters + ChainConfig chain_config = 5 [ + (gogoproto.moretags) = "yaml:\"chain_config\"", + (gogoproto.nullable) = false + ]; +} + +// ChainConfig defines the Ethereum ChainConfig parameters using *sdk.Int values +// instead of *big.Int. +message ChainConfig { + // Homestead switch block (nil no fork, 0 = already homestead) + string homestead_block = 1 [ + (gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Int", + (gogoproto.moretags) = "yaml:\"homestead_block\"" + ]; + // TheDAO hard-fork switch block (nil no fork) + string dao_fork_block = 2 [ + (gogoproto.customname) = "DAOForkBlock", + (gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Int", + (gogoproto.moretags) = "yaml:\"dao_fork_block\"" + ]; + // Whether the nodes supports or opposes the DAO hard-fork + bool dao_fork_support = 3 [ + (gogoproto.customname) = "DAOForkSupport", + (gogoproto.moretags) = "yaml:\"dao_fork_support\"" + ]; + // EIP150 implements the Gas price changes + // (https://github.com/ethereum/EIPs/issues/150) EIP150 HF block (nil no fork) + string eip150_block = 4 [ + (gogoproto.customname) = "EIP150Block", + (gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Int", + (gogoproto.moretags) = "yaml:\"eip150_block\"" + ]; + // EIP150 HF hash (needed for header only clients as only gas pricing changed) + string eip150_hash = 5 [ + (gogoproto.customname) = "EIP150Hash", + (gogoproto.moretags) = "yaml:\"byzantium_block\"" + ]; + // EIP155Block HF block + string eip155_block = 6 [ + (gogoproto.customname) = "EIP155Block", + (gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Int", + (gogoproto.moretags) = "yaml:\"eip155_block\"" + ]; + // EIP158 HF block + string eip158_block = 7 [ + (gogoproto.customname) = "EIP158Block", + (gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Int", + (gogoproto.moretags) = "yaml:\"eip158_block\"" + ]; + // Byzantium switch block (nil no fork, 0 = already on byzantium) + string byzantium_block = 8 [ + (gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Int", + (gogoproto.moretags) = "yaml:\"byzantium_block\"" + ]; + // Constantinople switch block (nil no fork, 0 = already activated) + string constantinople_block = 9 [ + (gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Int", + (gogoproto.moretags) = "yaml:\"constantinople_block\"" + ]; + // Petersburg switch block (nil same as Constantinople) + string petersburg_block = 10 [ + (gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Int", + (gogoproto.moretags) = "yaml:\"petersburg_block\"" + ]; + // Istanbul switch block (nil no fork, 0 = already on istanbul) + string istanbul_block = 11 [ + (gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Int", + (gogoproto.moretags) = "yaml:\"istanbul_block\"" + ]; + // Eip-2384 (bomb delay) switch block (nil no fork, 0 = already activated) + string muir_glacier_block = 12 [ + (gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Int", + (gogoproto.moretags) = "yaml:\"muir_glacier_block\"" + ]; + // Berlin switch block (nil = no fork, 0 = already on berlin) + string berlin_block = 13 [ + (gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Int", + (gogoproto.moretags) = "yaml:\"berlin_block\"" + ]; + // DEPRECATED: EWASM, YOLOV3 and Catalyst block have been deprecated + reserved 14, 15, 16; + reserved "yolo_v3_block", "ewasm_block", "catalyst_block"; + // London switch block (nil = no fork, 0 = already on london) + string london_block = 17 [ + (gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Int", + (gogoproto.moretags) = "yaml:\"london_block\"" + ]; + // Eip-4345 (bomb delay) switch block (nil = no fork, 0 = already activated) + string arrow_glacier_block = 18 [ + (gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Int", + (gogoproto.moretags) = "yaml:\"arrow_glacier_block\"" + ]; + // EIP-3675 (TheMerge) switch block (nil = no fork, 0 = already in merge proceedings) + string merge_fork_block = 19 [ + (gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Int", + (gogoproto.moretags) = "yaml:\"merge_fork_block\"" + ]; +} + +// State represents a single Storage key value pair item. +message State { + string key = 1; + string value = 2; +} + +// TransactionLogs define the logs generated from a transaction execution +// with a given hash. It it used for import/export data as transactions are not +// persisted on blockchain state after an upgrade. +message TransactionLogs { + string hash = 1; + repeated Log logs = 2; +} + +// Log represents an protobuf compatible Ethereum Log that defines a contract +// log event. These events are generated by the LOG opcode and stored/indexed by +// the node. +message Log { + // Consensus fields: + + // address of the contract that generated the event + string address = 1; + // list of topics provided by the contract. + repeated string topics = 2; + // supplied by the contract, usually ABI-encoded + bytes data = 3; + + // Derived fields. These fields are filled in by the node + // but not secured by consensus. + + // block in which the transaction was included + uint64 block_number = 4 [ (gogoproto.jsontag) = "blockNumber" ]; + // hash of the transaction + string tx_hash = 5 [ (gogoproto.jsontag) = "transactionHash" ]; + // index of the transaction in the block + uint64 tx_index = 6 [ (gogoproto.jsontag) = "transactionIndex" ]; + // hash of the block in which the transaction was included + string block_hash = 7 [ (gogoproto.jsontag) = "blockHash" ]; + // index of the log in the block + uint64 index = 8 [ (gogoproto.jsontag) = "logIndex" ]; + + // The Removed field is true if this log was reverted due to a chain + // reorganisation. You must pay attention to this field if you receive logs + // through a filter query. + bool removed = 9; +} + +// TxResult stores results of Tx execution. +message TxResult { + option (gogoproto.goproto_getters) = false; + + // contract_address contains the ethereum address of the created contract (if + // any). If the state transition is an evm.Call, the contract address will be + // empty. + string contract_address = 1 + [ (gogoproto.moretags) = "yaml:\"contract_address\"" ]; + // bloom represents the bloom filter bytes + bytes bloom = 2; + // tx_logs contains the transaction hash and the proto-compatible ethereum + // logs. + TransactionLogs tx_logs = 3 [ + (gogoproto.moretags) = "yaml:\"tx_logs\"", + (gogoproto.nullable) = false + ]; + // ret defines the bytes from the execution. + bytes ret = 4; + // reverted flag is set to true when the call has been reverted + bool reverted = 5; + // gas_used notes the amount of gas consumed while execution + uint64 gas_used = 6; +} + +// AccessTuple is the element type of an access list. +message AccessTuple { + option (gogoproto.goproto_getters) = false; + + // hex formatted ethereum address + string address = 1; + // hex formatted hashes of the storage keys + repeated string storage_keys = 2 [ (gogoproto.jsontag) = "storageKeys" ]; +} + +// TraceConfig holds extra parameters to trace functions. +message TraceConfig { + // DEPRECATED: DisableMemory and DisableReturnData have been renamed to + // Enable*. + reserved 4, 7; + reserved "disable_memory", "disable_return_data"; + + // custom javascript tracer + string tracer = 1; + // overrides the default timeout of 5 seconds for JavaScript-based tracing + // calls + string timeout = 2; + // number of blocks the tracer is willing to go back + uint64 reexec = 3; + // disable stack capture + bool disable_stack = 5 [ (gogoproto.jsontag) = "disableStack" ]; + // disable storage capture + bool disable_storage = 6 [ (gogoproto.jsontag) = "disableStorage" ]; + // print output during capture end + bool debug = 8; + // maximum length of output, but zero means unlimited + int32 limit = 9; + // Chain overrides, can be used to execute a trace using future fork rules + ChainConfig overrides = 10; + // enable memory capture + bool enable_memory = 11 [ (gogoproto.jsontag) = "enableMemory" ]; + // enable return data capture + bool enable_return_data = 12 [ (gogoproto.jsontag) = "enableReturnData" ]; +} diff --git a/proto/ethermint/evm/v1/query.proto b/proto/ethermint/evm/v1/query.proto new file mode 100644 index 0000000..b684147 --- /dev/null +++ b/proto/ethermint/evm/v1/query.proto @@ -0,0 +1,272 @@ +syntax = "proto3"; +package ethermint.evm.v1; + +import "gogoproto/gogo.proto"; +import "cosmos/base/query/v1beta1/pagination.proto"; +import "google/api/annotations.proto"; +import "ethermint/evm/v1/evm.proto"; +import "ethermint/evm/v1/tx.proto"; +import "google/protobuf/timestamp.proto"; + +option go_package = "github.com/irisnet/core-sdk-go/ethermint/x/evm/types"; + +// Query defines the gRPC querier service. +service Query { + // Account queries an Ethereum account. + rpc Account(QueryAccountRequest) returns (QueryAccountResponse) { + option (google.api.http).get = "/ethermint/evm/v1/account/{address}"; + } + + // CosmosAccount queries an Ethereum account's Cosmos Address. + rpc CosmosAccount(QueryCosmosAccountRequest) + returns (QueryCosmosAccountResponse) { + option (google.api.http).get = "/ethermint/evm/v1/cosmos_account/{address}"; + } + + // ValidatorAccount queries an Ethereum account's from a validator consensus + // Address. + rpc ValidatorAccount(QueryValidatorAccountRequest) + returns (QueryValidatorAccountResponse) { + option (google.api.http).get = + "/ethermint/evm/v1/validator_account/{cons_address}"; + } + + // Balance queries the balance of a the EVM denomination for a single + // EthAccount. + rpc Balance(QueryBalanceRequest) returns (QueryBalanceResponse) { + option (google.api.http).get = "/ethermint/evm/v1/balances/{address}"; + } + + // Storage queries the balance of all coins for a single account. + rpc Storage(QueryStorageRequest) returns (QueryStorageResponse) { + option (google.api.http).get = "/ethermint/evm/v1/storage/{address}/{key}"; + } + + // Code queries the balance of all coins for a single account. + rpc Code(QueryCodeRequest) returns (QueryCodeResponse) { + option (google.api.http).get = "/ethermint/evm/v1/codes/{address}"; + } + + // Params queries the parameters of x/evm module. + rpc Params(QueryParamsRequest) returns (QueryParamsResponse) { + option (google.api.http).get = "/ethermint/evm/v1/params"; + } + + // EthCall implements the `eth_call` rpc api + rpc EthCall(EthCallRequest) returns (MsgEthereumTxResponse) { + option (google.api.http).get = "/ethermint/evm/v1/eth_call"; + } + + // EstimateGas implements the `eth_estimateGas` rpc api + rpc EstimateGas(EthCallRequest) returns (EstimateGasResponse) { + option (google.api.http).get = "/ethermint/evm/v1/estimate_gas"; + } + + // TraceTx implements the `debug_traceTransaction` rpc api + rpc TraceTx(QueryTraceTxRequest) returns (QueryTraceTxResponse) { + option (google.api.http).get = "/ethermint/evm/v1/trace_tx"; + } + + // TraceBlock implements the `debug_traceBlockByNumber` and `debug_traceBlockByHash` rpc api + rpc TraceBlock(QueryTraceBlockRequest) returns (QueryTraceBlockResponse) { + option (google.api.http).get = "/ethermint/evm/v1/trace_block"; + } +} + +// QueryAccountRequest is the request type for the Query/Account RPC method. +message QueryAccountRequest { + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + + // address is the ethereum hex address to query the account for. + string address = 1; +} + +// QueryAccountResponse is the response type for the Query/Account RPC method. +message QueryAccountResponse { + // balance is the balance of the EVM denomination. + string balance = 1; + // code hash is the hex-formatted code bytes from the EOA. + string code_hash = 2; + // nonce is the account's sequence number. + uint64 nonce = 3; +} + +// QueryCosmosAccountRequest is the request type for the Query/CosmosAccount RPC +// method. +message QueryCosmosAccountRequest { + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + + // address is the ethereum hex address to query the account for. + string address = 1; +} + +// QueryCosmosAccountResponse is the response type for the Query/CosmosAccount +// RPC method. +message QueryCosmosAccountResponse { + // cosmos_address is the cosmos address of the account. + string cosmos_address = 1; + // sequence is the account's sequence number. + uint64 sequence = 2; + // account_number is the account numbert + uint64 account_number = 3; +} + +// QueryValidatorAccountRequest is the request type for the +// Query/ValidatorAccount RPC method. +message QueryValidatorAccountRequest { + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + + // cons_address is the validator cons address to query the account for. + string cons_address = 1; +} + +// QueryValidatorAccountResponse is the response type for the +// Query/ValidatorAccount RPC method. +message QueryValidatorAccountResponse { + // account_address is the cosmos address of the account in bech32 format. + string account_address = 1; + // sequence is the account's sequence number. + uint64 sequence = 2; + // account_number is the account number + uint64 account_number = 3; +} + +// QueryBalanceRequest is the request type for the Query/Balance RPC method. +message QueryBalanceRequest { + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + + // address is the ethereum hex address to query the balance for. + string address = 1; +} + +// QueryBalanceResponse is the response type for the Query/Balance RPC method. +message QueryBalanceResponse { + // balance is the balance of the EVM denomination. + string balance = 1; +} + +// QueryStorageRequest is the request type for the Query/Storage RPC method. +message QueryStorageRequest { + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + + /// address is the ethereum hex address to query the storage state for. + string address = 1; + + // key defines the key of the storage state + string key = 2; +} + +// QueryStorageResponse is the response type for the Query/Storage RPC +// method. +message QueryStorageResponse { + // key defines the storage state value hash associated with the given key. + string value = 1; +} + +// QueryCodeRequest is the request type for the Query/Code RPC method. +message QueryCodeRequest { + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + + // address is the ethereum hex address to query the code for. + string address = 1; +} + +// QueryCodeResponse is the response type for the Query/Code RPC +// method. +message QueryCodeResponse { + // code represents the code bytes from an ethereum address. + bytes code = 1; +} + +// QueryTxLogsRequest is the request type for the Query/TxLogs RPC method. +message QueryTxLogsRequest { + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + + // hash is the ethereum transaction hex hash to query the logs for. + string hash = 1; + // pagination defines an optional pagination for the request. + cosmos.base.query.v1beta1.PageRequest pagination = 2; +} + +// QueryTxLogs is the response type for the Query/TxLogs RPC method. +message QueryTxLogsResponse { + // logs represents the ethereum logs generated from the given transaction. + repeated Log logs = 1; + // pagination defines the pagination in the response. + cosmos.base.query.v1beta1.PageResponse pagination = 2; +} + +// QueryParamsRequest defines the request type for querying x/evm parameters. +message QueryParamsRequest {} + +// QueryParamsResponse defines the response type for querying x/evm parameters. +message QueryParamsResponse { + // params define the evm module parameters. + Params params = 1 [ (gogoproto.nullable) = false ]; +} + +// EthCallRequest defines EthCall request +message EthCallRequest { + // same json format as the json rpc api. + bytes args = 1; + // the default gas cap to be used + uint64 gas_cap = 2; +} + +// EstimateGasResponse defines EstimateGas response +message EstimateGasResponse { + // the estimated gas + uint64 gas = 1; +} + +// QueryTraceTxRequest defines TraceTx request +message QueryTraceTxRequest { + // msgEthereumTx for the requested transaction + MsgEthereumTx msg = 1; + // transaction index + uint64 tx_index = 2; + // TraceConfig holds extra parameters to trace functions. + TraceConfig trace_config = 3; + // the predecessor transactions included in the same block + // need to be replayed first to get correct context for tracing. + repeated MsgEthereumTx predecessors = 4; + // block number of requested transaction + int64 block_number = 5; + // block hex hash of requested transaction + string block_hash = 6; + // block time of requested transaction + google.protobuf.Timestamp block_time = 7 [(gogoproto.nullable) = false, (gogoproto.stdtime) = true]; +} + +// QueryTraceTxResponse defines TraceTx response +message QueryTraceTxResponse { + // response serialized in bytes + bytes data = 1; +} + +// QueryTraceBlockRequest defines TraceTx request +message QueryTraceBlockRequest { + // txs messages in the block + repeated MsgEthereumTx txs = 1; + // TraceConfig holds extra parameters to trace functions. + TraceConfig trace_config = 3; + // block number + int64 block_number = 5; + // block hex hash + string block_hash = 6; + // block time + google.protobuf.Timestamp block_time = 7 [(gogoproto.nullable) = false, (gogoproto.stdtime) = true]; +} + +// QueryTraceBlockResponse defines TraceBlock response +message QueryTraceBlockResponse { + bytes data = 1; +} + diff --git a/proto/ethermint/evm/v1/tx.proto b/proto/ethermint/evm/v1/tx.proto new file mode 100644 index 0000000..01743f3 --- /dev/null +++ b/proto/ethermint/evm/v1/tx.proto @@ -0,0 +1,175 @@ +syntax = "proto3"; +package ethermint.evm.v1; + +import "gogoproto/gogo.proto"; +import "google/api/annotations.proto"; +import "google/protobuf/any.proto"; +import "cosmos_proto/cosmos.proto"; +import "ethermint/evm/v1/evm.proto"; + +option go_package = "github.com/irisnet/core-sdk-go/ethermint/x/evm/types"; + +// Msg defines the evm Msg service. +service Msg { + // EthereumTx defines a method submitting Ethereum transactions. + rpc EthereumTx(MsgEthereumTx) returns (MsgEthereumTxResponse) { + option (google.api.http).post = "/ethermint/evm/v1/ethereum_tx"; + }; +} + +// MsgEthereumTx encapsulates an Ethereum transaction as an SDK message. +message MsgEthereumTx { + option (gogoproto.goproto_getters) = false; + + // inner transaction data + google.protobuf.Any data = 1; + // caches + + // encoded storage size of the transaction + double size = 2 [ (gogoproto.jsontag) = "-" ]; + // transaction hash in hex format + string hash = 3 [ (gogoproto.moretags) = "rlp:\"-\"" ]; + // ethereum signer address in hex format. This address value is checked + // against the address derived from the signature (V, R, S) using the + // secp256k1 elliptic curve + string from = 4; + + // feeGranter + string fee_payer = 5; +} + +// LegacyTx is the transaction data of regular Ethereum transactions. +message LegacyTx { + option (gogoproto.goproto_getters) = false; + option (cosmos_proto.implements_interface) = "TxData"; + + // nonce corresponds to the account nonce (transaction sequence). + uint64 nonce = 1; + // gas price defines the value for each gas unit + string gas_price = 2 + [ (gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Int" ]; + // gas defines the gas limit defined for the transaction. + uint64 gas = 3 [ (gogoproto.customname) = "GasLimit" ]; + // hex formatted address of the recipient + string to = 4; + // value defines the unsigned integer value of the transaction amount. + string value = 5 [ + (gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Int", + (gogoproto.customname) = "Amount" + ]; + // input defines the data payload bytes of the transaction. + bytes data = 6; + // v defines the signature value + bytes v = 7; + // r defines the signature value + bytes r = 8; + // s define the signature value + bytes s = 9; +} + +// AccessListTx is the data of EIP-2930 access list transactions. +message AccessListTx { + option (gogoproto.goproto_getters) = false; + option (cosmos_proto.implements_interface) = "TxData"; + + // destination EVM chain ID + string chain_id = 1 [ + (gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Int", + (gogoproto.customname) = "ChainID", + (gogoproto.jsontag) = "chainID" + ]; + // nonce corresponds to the account nonce (transaction sequence). + uint64 nonce = 2; + // gas price defines the value for each gas unit + string gas_price = 3 + [ (gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Int" ]; + // gas defines the gas limit defined for the transaction. + uint64 gas = 4 [ (gogoproto.customname) = "GasLimit" ]; + // hex formatted address of the recipient + string to = 5; + // value defines the unsigned integer value of the transaction amount. + string value = 6 [ + (gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Int", + (gogoproto.customname) = "Amount" + ]; + // input defines the data payload bytes of the transaction. + bytes data = 7; + repeated AccessTuple accesses = 8 [ + (gogoproto.castrepeated) = "AccessList", + (gogoproto.jsontag) = "accessList", + (gogoproto.nullable) = false + ]; + // v defines the signature value + bytes v = 9; + // r defines the signature value + bytes r = 10; + // s define the signature value + bytes s = 11; +} + +// DynamicFeeTx is the data of EIP-1559 dinamic fee transactions. +message DynamicFeeTx { + option (gogoproto.goproto_getters) = false; + option (cosmos_proto.implements_interface) = "TxData"; + + // destination EVM chain ID + string chain_id = 1 [ + (gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Int", + (gogoproto.customname) = "ChainID", + (gogoproto.jsontag) = "chainID" + ]; + // nonce corresponds to the account nonce (transaction sequence). + uint64 nonce = 2; + // gas tip cap defines the max value for the gas tip + string gas_tip_cap = 3 + [ (gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Int" ]; + // gas fee cap defines the max value for the gas fee + string gas_fee_cap = 4 + [ (gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Int" ]; + // gas defines the gas limit defined for the transaction. + uint64 gas = 5 [ (gogoproto.customname) = "GasLimit" ]; + // hex formatted address of the recipient + string to = 6; + // value defines the the transaction amount. + string value = 7 [ + (gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Int", + (gogoproto.customname) = "Amount" + ]; + // input defines the data payload bytes of the transaction. + bytes data = 8; + repeated AccessTuple accesses = 9 [ + (gogoproto.castrepeated) = "AccessList", + (gogoproto.jsontag) = "accessList", + (gogoproto.nullable) = false + ]; + // v defines the signature value + bytes v = 10; + // r defines the signature value + bytes r = 11; + // s define the signature value + bytes s = 12; +} + +message ExtensionOptionsEthereumTx { + option (gogoproto.goproto_getters) = false; +} + +// MsgEthereumTxResponse defines the Msg/EthereumTx response type. +message MsgEthereumTxResponse { + option (gogoproto.goproto_getters) = false; + + // ethereum transaction hash in hex format. This hash differs from the + // Tendermint sha256 hash of the transaction bytes. See + // https://github.com/tendermint/tendermint/issues/6539 for reference + string hash = 1; + // logs contains the transaction hash and the proto-compatible ethereum + // logs. + repeated Log logs = 2; + // returned data from evm function (result or data supplied with revert + // opcode) + bytes ret = 3; + // vm error is the error returned by vm execution + string vm_error = 4; + // gas consumed by the transaction + uint64 gas_used = 5; +} diff --git a/staking/query.pb.go b/staking/query.pb.go index 8754dd4..814a56d 100644 --- a/staking/query.pb.go +++ b/staking/query.pb.go @@ -6,9 +6,9 @@ package staking import ( context "context" fmt "fmt" + grpc1 "github.com/cosmos/gogoproto/grpc" + proto "github.com/cosmos/gogoproto/proto" _ "github.com/gogo/protobuf/gogoproto" - grpc1 "github.com/gogo/protobuf/grpc" - proto "github.com/gogo/protobuf/proto" query "github.com/irisnet/core-sdk-go/types/query" _ "google.golang.org/genproto/googleapis/api/annotations" grpc "google.golang.org/grpc" diff --git a/staking/staking.pb.go b/staking/staking.pb.go index 2b3de52..e8cc2bb 100644 --- a/staking/staking.pb.go +++ b/staking/staking.pb.go @@ -7,11 +7,11 @@ import ( bytes "bytes" compress_gzip "compress/gzip" fmt "fmt" + github_com_cosmos_gogoproto_proto "github.com/cosmos/gogoproto/proto" + proto "github.com/cosmos/gogoproto/proto" + github_com_cosmos_gogoproto_protoc_gen_gogo_descriptor "github.com/cosmos/gogoproto/protoc-gen-gogo/descriptor" + github_com_cosmos_gogoproto_types "github.com/cosmos/gogoproto/types" _ "github.com/gogo/protobuf/gogoproto" - github_com_gogo_protobuf_proto "github.com/gogo/protobuf/proto" - proto "github.com/gogo/protobuf/proto" - github_com_gogo_protobuf_protoc_gen_gogo_descriptor "github.com/gogo/protobuf/protoc-gen-gogo/descriptor" - github_com_gogo_protobuf_types "github.com/gogo/protobuf/types" types1 "github.com/irisnet/core-sdk-go/common/codec/types" github_com_irisnet_core_sdk_go_types "github.com/irisnet/core-sdk-go/types" types2 "github.com/irisnet/core-sdk-go/types" @@ -1210,609 +1210,608 @@ var fileDescriptor_64c30c6cf92913c9 = []byte{ 0x00, 0x00, 0xff, 0xff, 0x0f, 0x95, 0xb2, 0x5b, 0x09, 0x17, 0x00, 0x00, } -func (this *Pool) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) { +func (this *Pool) Description() (desc *github_com_cosmos_gogoproto_protoc_gen_gogo_descriptor.FileDescriptorSet) { return StakingDescription() } -func StakingDescription() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) { - d := &github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet{} +func StakingDescription() (desc *github_com_cosmos_gogoproto_protoc_gen_gogo_descriptor.FileDescriptorSet) { + d := &github_com_cosmos_gogoproto_protoc_gen_gogo_descriptor.FileDescriptorSet{} var gzipped = []byte{ - // 9527 bytes of a gzipped FileDescriptorSet + // 9513 bytes of a gzipped FileDescriptorSet 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x7d, 0x6d, 0x70, 0x1c, 0xd9, - 0x71, 0x18, 0x66, 0x77, 0x01, 0xec, 0x36, 0xbe, 0x16, 0x0f, 0x20, 0xb9, 0xdc, 0xe3, 0x01, 0xb8, - 0xb9, 0x2f, 0x1e, 0xef, 0x6e, 0x71, 0xc7, 0x3b, 0xf2, 0x78, 0x4b, 0x49, 0x27, 0x2c, 0xb0, 0x04, - 0x41, 0xe2, 0xeb, 0x06, 0x00, 0xa5, 0x93, 0x6c, 0x4f, 0x0d, 0x66, 0x1f, 0x16, 0x73, 0xd8, 0x9d, - 0x99, 0x9b, 0x99, 0x25, 0x89, 0x53, 0xa4, 0x3a, 0x4b, 0x89, 0x22, 0xd1, 0x95, 0x44, 0x67, 0xa5, - 0x22, 0xe9, 0x24, 0x2a, 0x92, 0xe5, 0x44, 0x8e, 0xec, 0x24, 0xb6, 0x24, 0x2b, 0x71, 0x92, 0xaa, - 0x48, 0xa9, 0xb2, 0x2d, 0xa9, 0xca, 0x8e, 0x54, 0x49, 0x25, 0x8e, 0x2b, 0xa6, 0x1d, 0x49, 0xe5, - 0x5c, 0x14, 0x25, 0x51, 0x68, 0xd9, 0xf9, 0xd0, 0x9f, 0xd4, 0xfb, 0x9a, 0xaf, 0xfd, 0x04, 0x44, - 0xea, 0xe4, 0xd8, 0xbf, 0xb0, 0xaf, 0x5f, 0x77, 0xbf, 0xee, 0x7e, 0xfd, 0xfa, 0xf5, 0xfb, 0x1a, - 0xc0, 0x6f, 0x25, 0xe0, 0x94, 0x6e, 0xb9, 0x75, 0xcb, 0x9d, 0xdd, 0xd6, 0x5c, 0x3c, 0xfb, 0x52, - 0x03, 0x3b, 0xfb, 0xb3, 0x57, 0x9f, 0xdc, 0xc6, 0x9e, 0xf6, 0xe4, 0xac, 0xad, 0x55, 0x0d, 0x53, - 0xf3, 0x0c, 0xcb, 0x2c, 0xd8, 0x8e, 0xe5, 0x59, 0xe8, 0x38, 0xc3, 0x2d, 0x10, 0xdc, 0x02, 0xc5, - 0x2d, 0x70, 0x5c, 0xd9, 0x84, 0xa1, 0x75, 0xad, 0x8a, 0x15, 0xfc, 0x52, 0x03, 0xbb, 0x1e, 0xca, - 0x42, 0x72, 0x0f, 0xef, 0xe7, 0xa4, 0x19, 0xe9, 0xe4, 0xb0, 0x42, 0x7e, 0xa2, 0xa3, 0x30, 0x60, - 0xed, 0xec, 0xb8, 0xd8, 0xcb, 0x25, 0x66, 0xa4, 0x93, 0x29, 0x85, 0x97, 0xd0, 0x24, 0xf4, 0xd7, - 0x8c, 0xba, 0xe1, 0xe5, 0x92, 0x14, 0xcc, 0x0a, 0x68, 0x1a, 0x86, 0x74, 0xab, 0x61, 0x7a, 0xaa, - 0x67, 0x79, 0x5a, 0x2d, 0x97, 0x9a, 0x91, 0x4e, 0xa6, 0x15, 0xa0, 0xa0, 0x4d, 0x02, 0x91, 0x9f, - 0x83, 0x61, 0xd6, 0x9e, 0x6b, 0x5b, 0xa6, 0x8b, 0xd1, 0x71, 0x48, 0x9b, 0xf8, 0xba, 0xa7, 0x06, - 0xad, 0x0e, 0x92, 0xf2, 0x65, 0xbc, 0x4f, 0x5a, 0x60, 0x5c, 0x58, 0xc3, 0xac, 0x50, 0x5a, 0xf8, - 0xea, 0xb7, 0xa6, 0xa4, 0x6f, 0x7c, 0x6b, 0x4a, 0xfa, 0xa3, 0x6f, 0x4d, 0x49, 0x1f, 0xfa, 0xf6, - 0x54, 0xdf, 0x37, 0xbe, 0x3d, 0xd5, 0xf7, 0x7b, 0xdf, 0x9e, 0xea, 0x7b, 0xc7, 0xa9, 0xaa, 0xe1, - 0xed, 0x36, 0xb6, 0x0b, 0xba, 0x55, 0x9f, 0x35, 0x1c, 0xc3, 0x35, 0xb1, 0x37, 0xab, 0x5b, 0x0e, - 0x7e, 0xdc, 0xad, 0xec, 0x3d, 0x5e, 0xb5, 0x66, 0xbd, 0x7d, 0x1b, 0xbb, 0xcc, 0x54, 0xdb, 0x03, - 0xd4, 0x30, 0x4f, 0xc1, 0x9f, 0x9c, 0x87, 0x99, 0xaa, 0x65, 0x55, 0x6b, 0x78, 0x96, 0x42, 0xb6, - 0x1b, 0x3b, 0xb3, 0x15, 0xec, 0xea, 0x8e, 0x61, 0x7b, 0x96, 0xc3, 0xcd, 0x37, 0xc6, 0x30, 0x0a, - 0x02, 0x43, 0x5e, 0x81, 0xf1, 0x0b, 0x46, 0x0d, 0x2f, 0xf8, 0x88, 0x1b, 0xd8, 0x43, 0xe7, 0x20, - 0xb5, 0x63, 0xd4, 0x70, 0x4e, 0x9a, 0x49, 0x9e, 0x1c, 0x3a, 0xfd, 0x40, 0x21, 0x46, 0x54, 0x88, - 0x52, 0xac, 0x13, 0xb0, 0x42, 0x29, 0xe4, 0xef, 0xa4, 0x60, 0xa2, 0x45, 0x2d, 0x42, 0x90, 0x32, - 0xb5, 0x3a, 0xa6, 0x76, 0xc9, 0x28, 0xf4, 0x37, 0xca, 0xc1, 0xa0, 0xad, 0xe9, 0x7b, 0x5a, 0x15, - 0x53, 0xb3, 0x64, 0x14, 0x51, 0x44, 0x53, 0x00, 0x15, 0x6c, 0x63, 0xb3, 0x82, 0x4d, 0x7d, 0x3f, - 0x97, 0x9c, 0x49, 0x9e, 0xcc, 0x28, 0x21, 0x08, 0x7a, 0x14, 0xc6, 0xed, 0xc6, 0x76, 0xcd, 0xd0, - 0xd5, 0x10, 0x1a, 0xcc, 0x24, 0x4f, 0xf6, 0x2b, 0x59, 0x56, 0xb1, 0x10, 0x20, 0x3f, 0x0c, 0x63, - 0xd7, 0xb0, 0xb6, 0x17, 0x46, 0x1d, 0xa2, 0xa8, 0xa3, 0x04, 0x1c, 0x42, 0x9c, 0x87, 0xe1, 0x3a, - 0x76, 0x5d, 0xad, 0x8a, 0x55, 0x62, 0xdf, 0x5c, 0x8a, 0x6a, 0x3f, 0xd3, 0xa4, 0x7d, 0x5c, 0xf3, - 0x21, 0x4e, 0xb5, 0xb9, 0x6f, 0x63, 0x34, 0x07, 0x19, 0x6c, 0x36, 0xea, 0x8c, 0x43, 0x7f, 0x1b, - 0xfb, 0x95, 0xcd, 0x46, 0x3d, 0xce, 0x25, 0x4d, 0xc8, 0x38, 0x8b, 0x41, 0x17, 0x3b, 0x57, 0x0d, - 0x1d, 0xe7, 0x06, 0x28, 0x83, 0x87, 0x9b, 0x18, 0x6c, 0xb0, 0xfa, 0x38, 0x0f, 0x41, 0x87, 0xe6, - 0x21, 0x83, 0xaf, 0x7b, 0xd8, 0x74, 0x0d, 0xcb, 0xcc, 0x0d, 0x52, 0x26, 0x0f, 0xb6, 0xe8, 0x45, - 0x5c, 0xab, 0xc4, 0x59, 0x04, 0x74, 0xe8, 0x2c, 0x0c, 0x5a, 0x36, 0x19, 0x7a, 0x6e, 0x2e, 0x3d, - 0x23, 0x9d, 0x1c, 0x3a, 0x7d, 0xa2, 0xa5, 0x23, 0xac, 0x31, 0x1c, 0x45, 0x20, 0xa3, 0x25, 0xc8, - 0xba, 0x56, 0xc3, 0xd1, 0xb1, 0xaa, 0x5b, 0x15, 0xac, 0x1a, 0xe6, 0x8e, 0x95, 0xcb, 0x50, 0x06, - 0xd3, 0xcd, 0x8a, 0x50, 0xc4, 0x79, 0xab, 0x82, 0x97, 0xcc, 0x1d, 0x4b, 0x19, 0x75, 0x23, 0x65, - 0x32, 0x62, 0xdd, 0x7d, 0xd3, 0xd3, 0xae, 0xe7, 0x86, 0xa9, 0x87, 0xf0, 0x92, 0xfc, 0x1b, 0x03, - 0x30, 0xd6, 0x8b, 0x8b, 0x9d, 0x87, 0xfe, 0x1d, 0xa2, 0x65, 0x2e, 0x71, 0x10, 0x1b, 0x30, 0x9a, - 0xa8, 0x11, 0x07, 0x0e, 0x69, 0xc4, 0x39, 0x18, 0x32, 0xb1, 0xeb, 0xe1, 0x0a, 0xf3, 0x88, 0x64, - 0x8f, 0x3e, 0x05, 0x8c, 0xa8, 0xd9, 0xa5, 0x52, 0x87, 0x72, 0xa9, 0xb7, 0xc3, 0x98, 0x2f, 0x92, - 0xea, 0x68, 0x66, 0x55, 0xf8, 0xe6, 0x6c, 0x37, 0x49, 0x0a, 0x65, 0x41, 0xa7, 0x10, 0x32, 0x65, - 0x14, 0x47, 0xca, 0x68, 0x01, 0xc0, 0x32, 0xb1, 0xb5, 0xa3, 0x56, 0xb0, 0x5e, 0xcb, 0xa5, 0xdb, - 0x58, 0x69, 0x8d, 0xa0, 0x34, 0x59, 0xc9, 0x62, 0x50, 0xbd, 0x86, 0x9e, 0x0d, 0x5c, 0x6d, 0xb0, - 0x8d, 0xa7, 0xac, 0xb0, 0x41, 0xd6, 0xe4, 0x6d, 0x5b, 0x30, 0xea, 0x60, 0xe2, 0xf7, 0xb8, 0xc2, - 0x35, 0xcb, 0x50, 0x21, 0x0a, 0x5d, 0x35, 0x53, 0x38, 0x19, 0x53, 0x6c, 0xc4, 0x09, 0x17, 0xd1, - 0xfd, 0xe0, 0x03, 0x54, 0xea, 0x56, 0x40, 0xa3, 0xd0, 0xb0, 0x00, 0xae, 0x6a, 0x75, 0x9c, 0x7f, - 0x19, 0x46, 0xa3, 0xe6, 0x21, 0x81, 0xde, 0xf5, 0x34, 0xc7, 0xa3, 0x5e, 0xd8, 0xaf, 0xb0, 0x02, - 0x99, 0x8a, 0xb0, 0x59, 0xa1, 0x51, 0xae, 0x5f, 0x21, 0x3f, 0xd1, 0x5b, 0x03, 0x85, 0x93, 0x54, - 0xe1, 0x87, 0x9a, 0x7b, 0x34, 0xc2, 0x39, 0xae, 0x77, 0xfe, 0x19, 0x18, 0x89, 0x28, 0xd0, 0x6b, - 0xd3, 0xf2, 0x5f, 0x81, 0x23, 0x2d, 0x59, 0xa3, 0xb7, 0xc3, 0x64, 0xc3, 0x34, 0x4c, 0x0f, 0x3b, - 0xb6, 0x83, 0x89, 0xc7, 0xb2, 0xa6, 0x72, 0xff, 0x79, 0xb0, 0x8d, 0xcf, 0x6d, 0x85, 0xb1, 0x19, - 0x17, 0x65, 0xa2, 0xd1, 0x0c, 0x3c, 0x95, 0x49, 0xbf, 0x3e, 0x98, 0x7d, 0xe5, 0x95, 0x57, 0x5e, - 0x49, 0xc8, 0x5f, 0x19, 0x80, 0xc9, 0x56, 0x63, 0xa6, 0xe5, 0xf0, 0x3d, 0x0a, 0x03, 0x66, 0xa3, - 0xbe, 0x8d, 0x1d, 0x6a, 0xa4, 0x7e, 0x85, 0x97, 0xd0, 0x1c, 0xf4, 0xd7, 0xb4, 0x6d, 0xcc, 0x26, - 0xe5, 0xd1, 0xd3, 0x8f, 0xf6, 0x34, 0x2a, 0x0b, 0xcb, 0x84, 0x44, 0x61, 0x94, 0xe8, 0x2d, 0x90, - 0xe2, 0x21, 0x9a, 0x70, 0x38, 0xd5, 0x1b, 0x07, 0x32, 0x96, 0x14, 0x4a, 0x87, 0xee, 0x81, 0x0c, - 0xf9, 0xcb, 0x7c, 0x63, 0x80, 0xca, 0x9c, 0x26, 0x00, 0xe2, 0x17, 0x28, 0x0f, 0x69, 0x3a, 0x4c, - 0x2a, 0x58, 0x4c, 0x6d, 0x7e, 0x99, 0x38, 0x56, 0x05, 0xef, 0x68, 0x8d, 0x9a, 0xa7, 0x5e, 0xd5, - 0x6a, 0x0d, 0x4c, 0x1d, 0x3e, 0xa3, 0x0c, 0x73, 0xe0, 0x15, 0x02, 0x23, 0xb9, 0x07, 0x1b, 0x55, - 0x86, 0x59, 0xc1, 0xd7, 0x69, 0xf4, 0xec, 0x57, 0xd8, 0x40, 0x5b, 0x22, 0x10, 0xd2, 0xfc, 0x8b, - 0xae, 0x65, 0x0a, 0xd7, 0xa4, 0x4d, 0x10, 0x00, 0x6d, 0xfe, 0x99, 0x78, 0xe0, 0xbe, 0xb7, 0xb5, - 0x7a, 0x4d, 0x63, 0xe9, 0x61, 0x18, 0x63, 0xc9, 0x04, 0xef, 0x7a, 0xad, 0x96, 0x1b, 0xa7, 0x69, - 0xcf, 0x28, 0x03, 0xaf, 0x71, 0xa8, 0xfc, 0xa5, 0x04, 0xa4, 0x68, 0x60, 0x19, 0x83, 0xa1, 0xcd, - 0x17, 0xd6, 0xcb, 0xea, 0xc2, 0xda, 0x56, 0x69, 0xb9, 0x9c, 0x95, 0xd0, 0x28, 0x00, 0x05, 0x5c, - 0x58, 0x5e, 0x9b, 0xdb, 0xcc, 0x26, 0xfc, 0xf2, 0xd2, 0xea, 0xe6, 0xd9, 0xa7, 0xb3, 0x49, 0x9f, - 0x60, 0x8b, 0x01, 0x52, 0x61, 0x84, 0xa7, 0x4e, 0x67, 0xfb, 0x51, 0x16, 0x86, 0x19, 0x83, 0xa5, - 0xb7, 0x97, 0x17, 0xce, 0x3e, 0x9d, 0x1d, 0x88, 0x42, 0x9e, 0x3a, 0x9d, 0x1d, 0x44, 0x23, 0x90, - 0xa1, 0x90, 0xd2, 0xda, 0xda, 0x72, 0x36, 0xed, 0xf3, 0xdc, 0xd8, 0x54, 0x96, 0x56, 0x17, 0xb3, - 0x19, 0x9f, 0xe7, 0xa2, 0xb2, 0xb6, 0xb5, 0x9e, 0x05, 0x9f, 0xc3, 0x4a, 0x79, 0x63, 0x63, 0x6e, - 0xb1, 0x9c, 0x1d, 0xf2, 0x31, 0x4a, 0x2f, 0x6c, 0x96, 0x37, 0xb2, 0xc3, 0x11, 0xb1, 0x9e, 0x3a, - 0x9d, 0x1d, 0xf1, 0x9b, 0x28, 0xaf, 0x6e, 0xad, 0x64, 0x47, 0xd1, 0x38, 0x8c, 0xb0, 0x26, 0x84, - 0x10, 0x63, 0x31, 0xd0, 0xd9, 0xa7, 0xb3, 0xd9, 0x40, 0x10, 0xc6, 0x65, 0x3c, 0x02, 0x38, 0xfb, - 0x74, 0x16, 0xc9, 0xf3, 0xd0, 0x4f, 0xdd, 0x10, 0x21, 0x18, 0x5d, 0x9e, 0x2b, 0x95, 0x97, 0xd5, - 0xb5, 0xf5, 0xcd, 0xa5, 0xb5, 0xd5, 0xb9, 0xe5, 0xac, 0x14, 0xc0, 0x94, 0xf2, 0xf3, 0x5b, 0x4b, - 0x4a, 0x79, 0x21, 0x9b, 0x08, 0xc3, 0xd6, 0xcb, 0x73, 0x9b, 0xe5, 0x85, 0x6c, 0x52, 0xd6, 0x61, - 0xb2, 0x55, 0x40, 0x6d, 0x39, 0x84, 0x42, 0xbe, 0x90, 0x68, 0xe3, 0x0b, 0x94, 0x57, 0xdc, 0x17, - 0xe4, 0x6f, 0x27, 0x60, 0xa2, 0xc5, 0xa4, 0xd2, 0xb2, 0x91, 0xe7, 0xa0, 0x9f, 0xf9, 0x32, 0x9b, - 0x66, 0x1f, 0x69, 0x39, 0x3b, 0x51, 0xcf, 0x6e, 0x9a, 0x6a, 0x29, 0x5d, 0x38, 0xd5, 0x48, 0xb6, - 0x49, 0x35, 0x08, 0x8b, 0x26, 0x87, 0xfd, 0xe9, 0xa6, 0xe0, 0xcf, 0xe6, 0xc7, 0xb3, 0xbd, 0xcc, - 0x8f, 0x14, 0x76, 0xb0, 0x49, 0xa0, 0xbf, 0xc5, 0x24, 0x70, 0x1e, 0xc6, 0x9b, 0x18, 0xf5, 0x1c, - 0x8c, 0xdf, 0x27, 0x41, 0xae, 0x9d, 0x71, 0xba, 0x84, 0xc4, 0x44, 0x24, 0x24, 0x9e, 0x8f, 0x5b, - 0xf0, 0xbe, 0xf6, 0x9d, 0xd0, 0xd4, 0xd7, 0x9f, 0x95, 0xe0, 0x68, 0xeb, 0x94, 0xb2, 0xa5, 0x0c, - 0x6f, 0x81, 0x81, 0x3a, 0xf6, 0x76, 0x2d, 0x91, 0x56, 0x3d, 0xd4, 0x62, 0xb2, 0x26, 0xd5, 0xf1, - 0xce, 0xe6, 0x54, 0xe1, 0xd9, 0x3e, 0xd9, 0x2e, 0x2f, 0x64, 0xd2, 0x34, 0x49, 0xfa, 0xc1, 0x04, - 0x1c, 0x69, 0xc9, 0xbc, 0xa5, 0xa0, 0xf7, 0x02, 0x18, 0xa6, 0xdd, 0xf0, 0x58, 0xea, 0xc4, 0x22, - 0x71, 0x86, 0x42, 0x68, 0xf0, 0x22, 0x51, 0xb6, 0xe1, 0xf9, 0xf5, 0x49, 0x5a, 0x0f, 0x0c, 0x44, - 0x11, 0xce, 0x05, 0x82, 0xa6, 0xa8, 0xa0, 0x53, 0x6d, 0x34, 0x6d, 0x72, 0xcc, 0x27, 0x20, 0xab, - 0xd7, 0x0c, 0x6c, 0x7a, 0xaa, 0xeb, 0x39, 0x58, 0xab, 0x1b, 0x66, 0x95, 0x4e, 0x35, 0xe9, 0x62, - 0xff, 0x8e, 0x56, 0x73, 0xb1, 0x32, 0xc6, 0xaa, 0x37, 0x44, 0x2d, 0xa1, 0xa0, 0x0e, 0xe4, 0x84, - 0x28, 0x06, 0x22, 0x14, 0xac, 0xda, 0xa7, 0x90, 0x5f, 0xcd, 0xc0, 0x50, 0x28, 0x01, 0x47, 0xf7, - 0xc1, 0xf0, 0x8b, 0xda, 0x55, 0x4d, 0x15, 0x8b, 0x2a, 0x66, 0x89, 0x21, 0x02, 0x5b, 0xe7, 0x0b, - 0xab, 0x27, 0x60, 0x92, 0xa2, 0x58, 0x0d, 0x0f, 0x3b, 0xaa, 0x5e, 0xd3, 0x5c, 0x97, 0x1a, 0x2d, - 0x4d, 0x51, 0x11, 0xa9, 0x5b, 0x23, 0x55, 0xf3, 0xa2, 0x06, 0x9d, 0x81, 0x09, 0x4a, 0x51, 0x6f, - 0xd4, 0x3c, 0xc3, 0xae, 0x61, 0x95, 0x2c, 0xf3, 0x5c, 0x3a, 0xe5, 0xf8, 0x92, 0x8d, 0x13, 0x8c, - 0x15, 0x8e, 0x40, 0x24, 0x72, 0xd1, 0x02, 0xdc, 0x4b, 0xc9, 0xaa, 0xd8, 0xc4, 0x8e, 0xe6, 0x61, - 0x15, 0xbf, 0xd4, 0xd0, 0x6a, 0xae, 0xaa, 0x99, 0x15, 0x75, 0x57, 0x73, 0x77, 0x73, 0x93, 0x84, - 0x41, 0x29, 0x91, 0x93, 0x94, 0xe3, 0x04, 0x71, 0x91, 0xe3, 0x95, 0x29, 0xda, 0x9c, 0x59, 0xb9, - 0xa8, 0xb9, 0xbb, 0xa8, 0x08, 0x47, 0x29, 0x17, 0xd7, 0x73, 0x0c, 0xb3, 0xaa, 0xea, 0xbb, 0x58, - 0xdf, 0x53, 0x1b, 0xde, 0xce, 0xb9, 0xdc, 0x3d, 0xe1, 0xf6, 0xa9, 0x84, 0x1b, 0x14, 0x67, 0x9e, - 0xa0, 0x6c, 0x79, 0x3b, 0xe7, 0xd0, 0x06, 0x0c, 0x93, 0xce, 0xa8, 0x1b, 0x2f, 0x63, 0x75, 0xc7, - 0x72, 0xe8, 0x1c, 0x3a, 0xda, 0x22, 0x34, 0x85, 0x2c, 0x58, 0x58, 0xe3, 0x04, 0x2b, 0x56, 0x05, - 0x17, 0xfb, 0x37, 0xd6, 0xcb, 0xe5, 0x05, 0x65, 0x48, 0x70, 0xb9, 0x60, 0x39, 0xc4, 0xa1, 0xaa, - 0x96, 0x6f, 0xe0, 0x21, 0xe6, 0x50, 0x55, 0x4b, 0x98, 0xf7, 0x0c, 0x4c, 0xe8, 0x3a, 0xd3, 0xd9, - 0xd0, 0x55, 0xbe, 0x18, 0x73, 0x73, 0xd9, 0x88, 0xb1, 0x74, 0x7d, 0x91, 0x21, 0x70, 0x1f, 0x77, - 0xd1, 0xb3, 0x70, 0x24, 0x30, 0x56, 0x98, 0x70, 0xbc, 0x49, 0xcb, 0x38, 0xe9, 0x19, 0x98, 0xb0, - 0xf7, 0x9b, 0x09, 0x51, 0xa4, 0x45, 0x7b, 0x3f, 0x4e, 0xf6, 0x0c, 0x4c, 0xda, 0xbb, 0x76, 0x33, - 0xdd, 0xa9, 0x30, 0x1d, 0xb2, 0x77, 0xed, 0x38, 0xe1, 0x83, 0x74, 0x65, 0xee, 0x60, 0x5d, 0xf3, - 0x70, 0x25, 0x77, 0x2c, 0x8c, 0x1e, 0xaa, 0x40, 0x05, 0xc8, 0xea, 0xba, 0x8a, 0x4d, 0x6d, 0xbb, - 0x86, 0x55, 0xcd, 0xc1, 0xa6, 0xe6, 0xe6, 0xa6, 0x29, 0x72, 0xca, 0x73, 0x1a, 0x58, 0x19, 0xd5, - 0xf5, 0x32, 0xad, 0x9c, 0xa3, 0x75, 0xe8, 0x14, 0x8c, 0x5b, 0xdb, 0x2f, 0xea, 0xcc, 0x23, 0x55, - 0xdb, 0xc1, 0x3b, 0xc6, 0xf5, 0xdc, 0x03, 0xd4, 0xbc, 0x63, 0xa4, 0x82, 0xfa, 0xe3, 0x3a, 0x05, - 0xa3, 0x47, 0x20, 0xab, 0xbb, 0xbb, 0x9a, 0x63, 0xd3, 0x90, 0xec, 0xda, 0x9a, 0x8e, 0x73, 0x0f, - 0x32, 0x54, 0x06, 0x5f, 0x15, 0x60, 0x32, 0x22, 0xdc, 0x6b, 0xc6, 0x8e, 0x27, 0x38, 0x3e, 0xcc, - 0x46, 0x04, 0x85, 0x71, 0x6e, 0x27, 0x21, 0x4b, 0x2c, 0x11, 0x69, 0xf8, 0x24, 0x45, 0x1b, 0xb5, - 0x77, 0xed, 0x70, 0xbb, 0xf7, 0xc3, 0x08, 0xc1, 0x0c, 0x1a, 0x7d, 0x84, 0x25, 0x6e, 0xf6, 0x6e, - 0xa8, 0xc5, 0xa7, 0xe1, 0x28, 0x41, 0xaa, 0x63, 0x4f, 0xab, 0x68, 0x9e, 0x16, 0xc2, 0x7e, 0x8c, - 0x62, 0x13, 0xb3, 0xaf, 0xf0, 0xca, 0x88, 0x9c, 0x4e, 0x63, 0x7b, 0xdf, 0x77, 0xac, 0xc7, 0x99, - 0x9c, 0x04, 0x26, 0x5c, 0xeb, 0xae, 0x25, 0xe7, 0x72, 0x11, 0x86, 0xc3, 0x7e, 0x8f, 0x32, 0xc0, - 0x3c, 0x3f, 0x2b, 0x91, 0x24, 0x68, 0x7e, 0x6d, 0x81, 0xa4, 0x2f, 0xef, 0x28, 0x67, 0x13, 0x24, - 0x8d, 0x5a, 0x5e, 0xda, 0x2c, 0xab, 0xca, 0xd6, 0xea, 0xe6, 0xd2, 0x4a, 0x39, 0x9b, 0x0c, 0x25, - 0xf6, 0x97, 0x52, 0xe9, 0x87, 0xb2, 0x0f, 0x93, 0xac, 0x61, 0x34, 0xba, 0x52, 0x43, 0x6f, 0x82, - 0x63, 0x62, 0x5b, 0xc5, 0xc5, 0x9e, 0x7a, 0xcd, 0x70, 0xe8, 0x80, 0xac, 0x6b, 0x6c, 0x72, 0xf4, - 0xfd, 0x67, 0x92, 0x63, 0x6d, 0x60, 0xef, 0x6d, 0x86, 0x43, 0x86, 0x5b, 0x5d, 0xf3, 0xd0, 0x32, - 0x4c, 0x9b, 0x96, 0xea, 0x7a, 0x9a, 0x59, 0xd1, 0x9c, 0x8a, 0x1a, 0x6c, 0x68, 0xa9, 0x9a, 0xae, - 0x63, 0xd7, 0xb5, 0xd8, 0x44, 0xe8, 0x73, 0x39, 0x61, 0x5a, 0x1b, 0x1c, 0x39, 0x98, 0x21, 0xe6, - 0x38, 0x6a, 0xcc, 0x7d, 0x93, 0xed, 0xdc, 0xf7, 0x1e, 0xc8, 0xd4, 0x35, 0x5b, 0xc5, 0xa6, 0xe7, - 0xec, 0xd3, 0xfc, 0x3c, 0xad, 0xa4, 0xeb, 0x9a, 0x5d, 0x26, 0xe5, 0x1f, 0xcb, 0x32, 0xe9, 0x52, - 0x2a, 0x9d, 0xca, 0xf6, 0x5f, 0x4a, 0xa5, 0xfb, 0xb3, 0x03, 0x97, 0x52, 0xe9, 0x81, 0xec, 0xe0, - 0xa5, 0x54, 0x3a, 0x9d, 0xcd, 0x5c, 0x4a, 0xa5, 0x33, 0x59, 0x90, 0x7f, 0x3e, 0x05, 0xc3, 0xe1, - 0x0c, 0x9e, 0x2c, 0x88, 0x74, 0x3a, 0x87, 0x49, 0x34, 0xca, 0xdd, 0xdf, 0x31, 0xdf, 0x2f, 0xcc, - 0x93, 0xc9, 0xad, 0x38, 0xc0, 0xd2, 0x65, 0x85, 0x51, 0x92, 0xc4, 0x82, 0xb8, 0x1f, 0x66, 0xe9, - 0x49, 0x5a, 0xe1, 0x25, 0xb4, 0x08, 0x03, 0x2f, 0xba, 0x94, 0xf7, 0x00, 0xe5, 0xfd, 0x40, 0x67, - 0xde, 0x97, 0x36, 0x28, 0xf3, 0xcc, 0xa5, 0x0d, 0x75, 0x75, 0x4d, 0x59, 0x99, 0x5b, 0x56, 0x38, - 0x39, 0x3a, 0x0e, 0xa9, 0x9a, 0xf6, 0xf2, 0x7e, 0x74, 0x1a, 0xa4, 0x20, 0x54, 0x80, 0xb1, 0x86, - 0x79, 0x15, 0x3b, 0xc6, 0x8e, 0x81, 0x2b, 0x2a, 0xc5, 0x1a, 0x0b, 0x63, 0x8d, 0x06, 0xb5, 0xcb, - 0x04, 0xbf, 0xc7, 0x6e, 0x3c, 0x0e, 0xa9, 0x6b, 0x58, 0xdb, 0x8b, 0x4e, 0x56, 0x14, 0x74, 0x17, - 0x87, 0xd3, 0x2c, 0xf4, 0x53, 0xfb, 0x22, 0x00, 0x6e, 0xe1, 0x6c, 0x1f, 0x4a, 0x43, 0x6a, 0x7e, - 0x4d, 0x21, 0x43, 0x2a, 0x0b, 0xc3, 0x0c, 0xaa, 0xae, 0x2f, 0x95, 0xe7, 0xcb, 0xd9, 0x84, 0x7c, - 0x06, 0x06, 0x98, 0xd1, 0xc8, 0x70, 0xf3, 0xcd, 0x96, 0xed, 0xe3, 0x45, 0xce, 0x43, 0x12, 0xb5, - 0x5b, 0x2b, 0xa5, 0xb2, 0x92, 0x4d, 0x34, 0x39, 0x8b, 0xec, 0xc2, 0x70, 0x38, 0x93, 0xff, 0xf1, - 0x2c, 0xe7, 0xbf, 0x2c, 0xc1, 0x50, 0x28, 0x33, 0x27, 0x29, 0x95, 0x56, 0xab, 0x59, 0xd7, 0x54, - 0xad, 0x66, 0x68, 0x2e, 0x77, 0x25, 0xa0, 0xa0, 0x39, 0x02, 0xe9, 0xb5, 0xeb, 0x7e, 0x4c, 0x83, - 0xac, 0x3f, 0x3b, 0x20, 0x7f, 0x52, 0x82, 0x6c, 0x3c, 0x35, 0x8e, 0x89, 0x29, 0xbd, 0x91, 0x62, - 0xca, 0x9f, 0x90, 0x60, 0x34, 0x9a, 0x0f, 0xc7, 0xc4, 0xbb, 0xef, 0x0d, 0x15, 0xef, 0x8f, 0x12, - 0x30, 0x12, 0xc9, 0x82, 0x7b, 0x95, 0xee, 0x25, 0x18, 0x37, 0x2a, 0xb8, 0x6e, 0x5b, 0x1e, 0x36, - 0xf5, 0x7d, 0xb5, 0x86, 0xaf, 0xe2, 0x5a, 0x4e, 0xa6, 0x41, 0x66, 0xb6, 0x73, 0x9e, 0x5d, 0x58, - 0x0a, 0xe8, 0x96, 0x09, 0x59, 0x71, 0x62, 0x69, 0xa1, 0xbc, 0xb2, 0xbe, 0xb6, 0x59, 0x5e, 0x9d, - 0x7f, 0x41, 0xdd, 0x5a, 0xbd, 0xbc, 0xba, 0xf6, 0xb6, 0x55, 0x25, 0x6b, 0xc4, 0xd0, 0xee, 0xe2, - 0xb0, 0x5f, 0x87, 0x6c, 0x5c, 0x28, 0x74, 0x0c, 0x5a, 0x89, 0x95, 0xed, 0x43, 0x13, 0x30, 0xb6, - 0xba, 0xa6, 0x6e, 0x2c, 0x2d, 0x94, 0xd5, 0xf2, 0x85, 0x0b, 0xe5, 0xf9, 0xcd, 0x0d, 0xb6, 0x73, - 0xe2, 0x63, 0x6f, 0x46, 0x06, 0xb8, 0xfc, 0x5a, 0x12, 0x26, 0x5a, 0x48, 0x82, 0xe6, 0xf8, 0x9a, - 0x87, 0x2d, 0xc3, 0x1e, 0xef, 0x45, 0xfa, 0x02, 0xc9, 0x3a, 0xd6, 0x35, 0xc7, 0xe3, 0x4b, 0xa4, - 0x47, 0x80, 0x58, 0xc9, 0xf4, 0x48, 0x70, 0x75, 0xf8, 0x8e, 0x14, 0x5b, 0x08, 0x8d, 0x05, 0x70, - 0xb6, 0x29, 0xf5, 0x18, 0x20, 0xdb, 0x72, 0x0d, 0xcf, 0xb8, 0x8a, 0x55, 0xc3, 0x14, 0xdb, 0x57, - 0x29, 0x7a, 0xa2, 0x95, 0x15, 0x35, 0x4b, 0xa6, 0xe7, 0x63, 0x9b, 0xb8, 0xaa, 0xc5, 0xb0, 0x49, - 0xf0, 0x4f, 0x2a, 0x59, 0x51, 0xe3, 0x63, 0xdf, 0x07, 0xc3, 0x15, 0xab, 0x41, 0xb2, 0x45, 0x86, - 0x47, 0xe6, 0x1a, 0x49, 0x19, 0x62, 0x30, 0x1f, 0x85, 0xaf, 0x03, 0x82, 0x7d, 0xb3, 0x61, 0x65, - 0x88, 0xc1, 0x18, 0xca, 0xc3, 0x30, 0xa6, 0x55, 0xab, 0x0e, 0x61, 0x2e, 0x18, 0xb1, 0x95, 0xcd, - 0xa8, 0x0f, 0xa6, 0x88, 0xf9, 0x4b, 0x90, 0x16, 0x76, 0x20, 0x93, 0x3d, 0xb1, 0x84, 0x6a, 0xb3, - 0xe5, 0x7a, 0xe2, 0x64, 0x46, 0x49, 0x9b, 0xa2, 0xf2, 0x3e, 0x18, 0x36, 0x5c, 0x35, 0x38, 0x06, - 0x48, 0xcc, 0x24, 0x4e, 0xa6, 0x95, 0x21, 0xc3, 0xf5, 0xb7, 0x50, 0xe5, 0xcf, 0x26, 0x60, 0x34, - 0x7a, 0x8c, 0x81, 0x16, 0x20, 0x5d, 0xb3, 0x74, 0x7a, 0x6c, 0xc9, 0xcf, 0xd0, 0x4e, 0x76, 0x39, - 0xf9, 0x28, 0x2c, 0x73, 0x7c, 0xc5, 0xa7, 0xcc, 0xff, 0xae, 0x04, 0x69, 0x01, 0x46, 0x47, 0x21, - 0x65, 0x6b, 0xde, 0x2e, 0x65, 0xd7, 0x5f, 0x4a, 0x64, 0x25, 0x85, 0x96, 0x09, 0xdc, 0xb5, 0x35, - 0x93, 0xba, 0x00, 0x87, 0x93, 0x32, 0xe9, 0xd7, 0x1a, 0xd6, 0x2a, 0x74, 0xd9, 0x64, 0xd5, 0xeb, - 0xd8, 0xf4, 0x5c, 0xd1, 0xaf, 0x1c, 0x3e, 0xcf, 0xc1, 0xe8, 0x51, 0x18, 0xf7, 0x1c, 0xcd, 0xa8, - 0x45, 0x70, 0x53, 0x14, 0x37, 0x2b, 0x2a, 0x7c, 0xe4, 0x22, 0x1c, 0x17, 0x7c, 0x2b, 0xd8, 0xd3, - 0xf4, 0x5d, 0x5c, 0x09, 0x88, 0x06, 0xe8, 0xf6, 0xc8, 0x31, 0x8e, 0xb0, 0xc0, 0xeb, 0x05, 0xad, - 0xfc, 0x4d, 0x09, 0xc6, 0xc5, 0x42, 0xaf, 0xe2, 0x1b, 0x6b, 0x05, 0x40, 0x33, 0x4d, 0xcb, 0x0b, - 0x9b, 0xab, 0xd9, 0x95, 0x9b, 0xe8, 0x0a, 0x73, 0x3e, 0x91, 0x12, 0x62, 0x90, 0xaf, 0x03, 0x04, - 0x35, 0x6d, 0xcd, 0x36, 0x0d, 0x43, 0xfc, 0x8c, 0x8a, 0x1e, 0x74, 0xb2, 0xad, 0x01, 0x60, 0x20, - 0xb2, 0x22, 0x44, 0x93, 0xd0, 0xbf, 0x8d, 0xab, 0x86, 0xc9, 0x77, 0x9e, 0x59, 0x41, 0x6c, 0xe0, - 0xa4, 0xfc, 0x0d, 0x9c, 0xd2, 0x7b, 0x60, 0x42, 0xb7, 0xea, 0x71, 0x71, 0x4b, 0xd9, 0xd8, 0xf6, - 0x84, 0x7b, 0x51, 0x7a, 0xc7, 0xe3, 0x1c, 0xa9, 0x6a, 0xd5, 0x34, 0xb3, 0x5a, 0xb0, 0x9c, 0x6a, - 0x70, 0x50, 0xcb, 0x0e, 0x74, 0x83, 0xec, 0xd6, 0xde, 0xfe, 0xdf, 0x92, 0xf4, 0x0b, 0x89, 0xe4, - 0xe2, 0x7a, 0xe9, 0x73, 0x89, 0xfc, 0x22, 0x23, 0x5c, 0x17, 0xc6, 0x50, 0xf0, 0x4e, 0x0d, 0xeb, - 0x44, 0x41, 0xf8, 0xee, 0xa3, 0x30, 0x59, 0xb5, 0xaa, 0x16, 0xe5, 0x34, 0x4b, 0x7e, 0xf1, 0x93, - 0xde, 0x8c, 0x0f, 0xcd, 0x77, 0x3d, 0x16, 0x2e, 0xae, 0xc2, 0x04, 0x47, 0x56, 0xe9, 0x51, 0x13, - 0x5b, 0x08, 0xa1, 0x8e, 0xbb, 0x70, 0xb9, 0x5f, 0xfb, 0x0e, 0x9d, 0xbe, 0x95, 0x71, 0x4e, 0x4a, - 0xea, 0xd8, 0x5a, 0xa9, 0xa8, 0xc0, 0x91, 0x08, 0x3f, 0x36, 0x48, 0xb1, 0xd3, 0x85, 0xe3, 0x6f, - 0x72, 0x8e, 0x13, 0x21, 0x8e, 0x1b, 0x9c, 0xb4, 0x38, 0x0f, 0x23, 0x07, 0xe1, 0xf5, 0x5b, 0x9c, - 0xd7, 0x30, 0x0e, 0x33, 0x59, 0x84, 0x31, 0xca, 0x44, 0x6f, 0xb8, 0x9e, 0x55, 0xa7, 0x11, 0xb0, - 0x33, 0x9b, 0xdf, 0xfe, 0x0e, 0x1b, 0x35, 0xa3, 0x84, 0x6c, 0xde, 0xa7, 0x2a, 0x16, 0x81, 0x9e, - 0xae, 0x55, 0xb0, 0x5e, 0xeb, 0xc2, 0xe1, 0xab, 0x5c, 0x10, 0x1f, 0xbf, 0x78, 0x05, 0x26, 0xc9, - 0x6f, 0x1a, 0xa0, 0xc2, 0x92, 0x74, 0xdf, 0xb2, 0xcb, 0x7d, 0xf3, 0x7d, 0x6c, 0x60, 0x4e, 0xf8, - 0x0c, 0x42, 0x32, 0x85, 0x7a, 0xb1, 0x8a, 0x3d, 0x0f, 0x3b, 0xae, 0xaa, 0xd5, 0x5a, 0x89, 0x17, - 0xda, 0xf3, 0xc8, 0x7d, 0xec, 0x7b, 0xd1, 0x5e, 0x5c, 0x64, 0x94, 0x73, 0xb5, 0x5a, 0x71, 0x0b, - 0x8e, 0xb5, 0xf0, 0x8a, 0x1e, 0x78, 0xbe, 0xc6, 0x79, 0x4e, 0x36, 0x79, 0x06, 0x61, 0xbb, 0x0e, - 0x02, 0xee, 0xf7, 0x65, 0x0f, 0x3c, 0x3f, 0xce, 0x79, 0x22, 0x4e, 0x2b, 0xba, 0x94, 0x70, 0xbc, - 0x04, 0xe3, 0x57, 0xb1, 0xb3, 0x6d, 0xb9, 0x7c, 0x9f, 0xa9, 0x07, 0x76, 0x9f, 0xe0, 0xec, 0xc6, - 0x38, 0x21, 0xdd, 0x78, 0x22, 0xbc, 0x9e, 0x85, 0xf4, 0x8e, 0xa6, 0xe3, 0x1e, 0x58, 0xdc, 0xe4, - 0x2c, 0x06, 0x09, 0x3e, 0x21, 0x9d, 0x83, 0xe1, 0xaa, 0xc5, 0xe7, 0xa8, 0xee, 0xe4, 0x9f, 0xe4, - 0xe4, 0x43, 0x82, 0x86, 0xb3, 0xb0, 0x2d, 0xbb, 0x51, 0x23, 0x13, 0x58, 0x77, 0x16, 0x7f, 0x57, - 0xb0, 0x10, 0x34, 0x9c, 0xc5, 0x01, 0xcc, 0xfa, 0x29, 0xc1, 0xc2, 0x0d, 0xd9, 0xf3, 0x39, 0x18, - 0xb2, 0xcc, 0xda, 0xbe, 0x65, 0xf6, 0x22, 0xc4, 0xa7, 0x39, 0x07, 0xe0, 0x24, 0x84, 0xc1, 0x79, - 0xc8, 0xf4, 0xda, 0x11, 0x7f, 0xef, 0x7b, 0x62, 0x78, 0x88, 0x1e, 0x58, 0x84, 0x31, 0x11, 0xa0, - 0x0c, 0xcb, 0xec, 0x81, 0xc5, 0xdf, 0xe7, 0x2c, 0x46, 0x43, 0x64, 0x5c, 0x0d, 0x0f, 0xbb, 0x5e, - 0x15, 0xf7, 0xc2, 0xe4, 0xb3, 0x42, 0x0d, 0x4e, 0xc2, 0x4d, 0xb9, 0x8d, 0x4d, 0x7d, 0xb7, 0x37, - 0x0e, 0xbf, 0x24, 0x4c, 0x29, 0x68, 0x08, 0x8b, 0x79, 0x18, 0xa9, 0x6b, 0x8e, 0xbb, 0xab, 0xd5, - 0x7a, 0xea, 0x8e, 0x7f, 0xc0, 0x79, 0x0c, 0xfb, 0x44, 0xdc, 0x22, 0x0d, 0xf3, 0x20, 0x6c, 0x3e, - 0x27, 0x2c, 0x12, 0x22, 0xe3, 0x43, 0xcf, 0xf5, 0xe8, 0xa6, 0xdc, 0x41, 0xb8, 0xfd, 0xb2, 0x18, - 0x7a, 0x8c, 0x76, 0x25, 0xcc, 0xf1, 0x3c, 0x64, 0x5c, 0xe3, 0xe5, 0x9e, 0xd8, 0xfc, 0x8a, 0xe8, - 0x69, 0x4a, 0x40, 0x88, 0x5f, 0x80, 0xe3, 0x2d, 0xa7, 0x89, 0x1e, 0x98, 0xfd, 0x43, 0xce, 0xec, - 0x68, 0x8b, 0xa9, 0x82, 0x87, 0x84, 0x83, 0xb2, 0xfc, 0x47, 0x22, 0x24, 0xe0, 0x18, 0xaf, 0x75, - 0xb2, 0x6a, 0x70, 0xb5, 0x9d, 0x83, 0x59, 0xed, 0x1f, 0x0b, 0xab, 0x31, 0xda, 0x88, 0xd5, 0x36, - 0xe1, 0x28, 0xe7, 0x78, 0xb0, 0x7e, 0xfd, 0x55, 0x11, 0x58, 0x19, 0xf5, 0x56, 0xb4, 0x77, 0xdf, - 0x09, 0x79, 0xdf, 0x9c, 0x22, 0x3d, 0x75, 0xd5, 0xba, 0x66, 0xf7, 0xc0, 0xf9, 0xd7, 0x38, 0x67, - 0x11, 0xf1, 0xfd, 0xfc, 0xd6, 0x5d, 0xd1, 0x6c, 0xc2, 0xfc, 0xed, 0x90, 0x13, 0xcc, 0x1b, 0xa6, - 0x83, 0x75, 0xab, 0x6a, 0x1a, 0x2f, 0xe3, 0x4a, 0x0f, 0xac, 0x3f, 0x1f, 0xeb, 0xaa, 0xad, 0x10, - 0x39, 0xe1, 0xbc, 0x04, 0x59, 0x3f, 0x57, 0x51, 0x8d, 0xba, 0x6d, 0x39, 0x5e, 0x17, 0x8e, 0x5f, - 0x10, 0x3d, 0xe5, 0xd3, 0x2d, 0x51, 0xb2, 0x62, 0x19, 0xd8, 0x49, 0x75, 0xaf, 0x2e, 0xf9, 0x45, - 0xce, 0x68, 0x24, 0xa0, 0xe2, 0x81, 0x43, 0xb7, 0xea, 0xb6, 0xe6, 0xf4, 0x12, 0xff, 0x7e, 0x5d, - 0x04, 0x0e, 0x4e, 0xc2, 0x03, 0x07, 0xc9, 0xe8, 0xc8, 0x6c, 0xdf, 0x03, 0x87, 0x2f, 0x89, 0xc0, - 0x21, 0x68, 0x38, 0x0b, 0x91, 0x30, 0xf4, 0xc0, 0xe2, 0x9f, 0x08, 0x16, 0x82, 0x86, 0xb0, 0x78, - 0x3e, 0x98, 0x68, 0x1d, 0x5c, 0x35, 0x5c, 0xcf, 0x61, 0x49, 0x71, 0x67, 0x56, 0xff, 0xf4, 0x7b, - 0xd1, 0x24, 0x4c, 0x09, 0x91, 0x92, 0x48, 0xc4, 0xb7, 0x69, 0xe9, 0x9a, 0xa9, 0xbb, 0x60, 0xbf, - 0x21, 0x22, 0x51, 0x88, 0x8c, 0xc8, 0x16, 0xca, 0x10, 0x89, 0xd9, 0x75, 0xb2, 0x52, 0xe8, 0x81, - 0xdd, 0x3f, 0x8b, 0x09, 0xb7, 0x21, 0x68, 0x09, 0xcf, 0x50, 0xfe, 0xd3, 0x30, 0xf7, 0xf0, 0x7e, - 0x4f, 0xde, 0xf9, 0xcf, 0x63, 0xf9, 0xcf, 0x16, 0xa3, 0x64, 0x31, 0x64, 0x2c, 0x96, 0x4f, 0xa1, - 0x6e, 0xf7, 0x92, 0x72, 0x3f, 0xfb, 0x03, 0xae, 0x6f, 0x34, 0x9d, 0x2a, 0x2e, 0x13, 0x27, 0x8f, - 0x26, 0x3d, 0xdd, 0x99, 0xbd, 0xef, 0x07, 0xbe, 0x9f, 0x47, 0x72, 0x9e, 0xe2, 0x05, 0x18, 0x89, - 0x24, 0x3c, 0xdd, 0x59, 0xfd, 0x55, 0xce, 0x6a, 0x38, 0x9c, 0xef, 0x14, 0xcf, 0x40, 0x8a, 0x24, - 0x2f, 0xdd, 0xc9, 0xff, 0x1a, 0x27, 0xa7, 0xe8, 0xc5, 0x37, 0x43, 0x5a, 0x24, 0x2d, 0xdd, 0x49, - 0xdf, 0xcf, 0x49, 0x7d, 0x12, 0x42, 0x2e, 0x12, 0x96, 0xee, 0xe4, 0x7f, 0x5d, 0x90, 0x0b, 0x12, - 0x42, 0xde, 0xbb, 0x09, 0xbf, 0xfc, 0x73, 0x29, 0x3e, 0xe9, 0x08, 0xdb, 0x9d, 0x87, 0x41, 0x9e, - 0xa9, 0x74, 0xa7, 0xfe, 0x20, 0x6f, 0x5c, 0x50, 0x14, 0x9f, 0x81, 0xfe, 0x1e, 0x0d, 0xfe, 0x37, - 0x38, 0x29, 0xc3, 0x2f, 0xce, 0xc3, 0x50, 0x28, 0x3b, 0xe9, 0x4e, 0xfe, 0x37, 0x39, 0x79, 0x98, - 0x8a, 0x88, 0xce, 0xb3, 0x93, 0xee, 0x0c, 0xfe, 0x96, 0x10, 0x9d, 0x53, 0x10, 0xb3, 0x89, 0xc4, - 0xa4, 0x3b, 0xf5, 0x87, 0x84, 0xd5, 0x05, 0x49, 0xf1, 0x39, 0xc8, 0xf8, 0x93, 0x4d, 0x77, 0xfa, - 0x57, 0x39, 0x7d, 0x40, 0x43, 0x2c, 0x10, 0x9a, 0xec, 0xba, 0xb3, 0xf8, 0x79, 0x61, 0x81, 0x10, - 0x15, 0x19, 0x46, 0xf1, 0x04, 0xa6, 0x3b, 0xa7, 0x0f, 0x8b, 0x61, 0x14, 0xcb, 0x5f, 0x48, 0x6f, - 0xd2, 0x98, 0xdf, 0x9d, 0xc5, 0xdf, 0x16, 0xbd, 0x49, 0xf1, 0x89, 0x18, 0xf1, 0x8c, 0xa0, 0x3b, - 0x8f, 0x8f, 0x08, 0x31, 0x62, 0x09, 0x41, 0x71, 0x1d, 0x50, 0x73, 0x36, 0xd0, 0x9d, 0xdf, 0x47, - 0x39, 0xbf, 0xf1, 0xa6, 0x64, 0xa0, 0xf8, 0x36, 0x38, 0xda, 0x3a, 0x13, 0xe8, 0xce, 0xf5, 0x63, - 0x3f, 0x88, 0xad, 0xdd, 0xc2, 0x89, 0x40, 0x71, 0x33, 0x98, 0x52, 0xc2, 0x59, 0x40, 0x77, 0xb6, - 0xaf, 0xfd, 0x20, 0x1a, 0xb8, 0xc3, 0x49, 0x40, 0x71, 0x0e, 0x20, 0x98, 0x80, 0xbb, 0xf3, 0xfa, - 0x04, 0xe7, 0x15, 0x22, 0x22, 0x43, 0x83, 0xcf, 0xbf, 0xdd, 0xe9, 0x6f, 0x8a, 0xa1, 0xc1, 0x29, - 0xc8, 0xd0, 0x10, 0x53, 0x6f, 0x77, 0xea, 0x4f, 0x8a, 0xa1, 0x21, 0x48, 0x88, 0x67, 0x87, 0x66, - 0xb7, 0xee, 0x1c, 0x3e, 0x2d, 0x3c, 0x3b, 0x44, 0x55, 0x5c, 0x85, 0xf1, 0xa6, 0x09, 0xb1, 0x3b, - 0xab, 0x5f, 0xe0, 0xac, 0xb2, 0xf1, 0xf9, 0x30, 0x3c, 0x79, 0xf1, 0xc9, 0xb0, 0x3b, 0xb7, 0xcf, - 0xc4, 0x26, 0x2f, 0x3e, 0x17, 0x16, 0xcf, 0x43, 0xda, 0x6c, 0xd4, 0x6a, 0x64, 0xf0, 0xa0, 0xce, - 0x77, 0x09, 0x73, 0xff, 0xe5, 0x87, 0xdc, 0x3a, 0x82, 0xa0, 0x78, 0x06, 0xfa, 0x71, 0x7d, 0x1b, - 0x57, 0xba, 0x51, 0x7e, 0xf7, 0x87, 0x22, 0x60, 0x12, 0xec, 0xe2, 0x73, 0x00, 0x6c, 0x6b, 0x84, - 0x1e, 0x1e, 0x76, 0xa1, 0xfd, 0xaf, 0x3f, 0xe4, 0x97, 0x77, 0x02, 0x92, 0x80, 0x01, 0xbb, 0x0a, - 0xd4, 0x99, 0xc1, 0xf7, 0xa2, 0x0c, 0x68, 0x8f, 0x3c, 0x0b, 0x83, 0x2f, 0xba, 0x96, 0xe9, 0x69, - 0xd5, 0x6e, 0xd4, 0xff, 0x8d, 0x53, 0x0b, 0x7c, 0x62, 0xb0, 0xba, 0xe5, 0x60, 0x4f, 0xab, 0xba, - 0xdd, 0x68, 0xff, 0x3b, 0xa7, 0xf5, 0x09, 0x08, 0xb1, 0xae, 0xb9, 0x5e, 0x2f, 0x7a, 0xff, 0x0f, - 0x41, 0x2c, 0x08, 0x88, 0xd0, 0xe4, 0xf7, 0x1e, 0xde, 0xef, 0x46, 0xfb, 0x7d, 0x21, 0x34, 0xc7, - 0x2f, 0xbe, 0x19, 0x32, 0xe4, 0x27, 0xbb, 0x91, 0xd7, 0x85, 0xf8, 0x7f, 0x72, 0xe2, 0x80, 0x82, - 0xb4, 0xec, 0x7a, 0x15, 0xcf, 0xe8, 0x6e, 0xec, 0xdb, 0xbc, 0xa7, 0x05, 0x7e, 0x71, 0x0e, 0x86, - 0x5c, 0xaf, 0x52, 0x69, 0xf0, 0xfc, 0xb4, 0x0b, 0xf9, 0x9f, 0xfc, 0xd0, 0xdf, 0xb2, 0xf0, 0x69, - 0x48, 0x6f, 0x5f, 0xdb, 0xf3, 0x6c, 0x8b, 0x1e, 0x78, 0x74, 0xe3, 0xf0, 0x03, 0xce, 0x21, 0x44, - 0x52, 0x9c, 0x87, 0x61, 0xa2, 0x8b, 0x83, 0x6d, 0x4c, 0x4f, 0xa7, 0xba, 0xb0, 0xf8, 0x53, 0x6e, - 0x80, 0x08, 0x51, 0xe9, 0xa7, 0xdb, 0xbd, 0xe8, 0x69, 0xbd, 0x4b, 0x0c, 0x8b, 0xd6, 0xa2, 0xc5, - 0xf6, 0x87, 0xdf, 0x21, 0x87, 0x9e, 0xfc, 0x90, 0x65, 0x4d, 0xb0, 0x5b, 0xeb, 0x2f, 0x72, 0xe0, - 0x37, 0xfb, 0x49, 0xd6, 0x4c, 0xf7, 0x72, 0x35, 0xdb, 0x98, 0xdd, 0xf5, 0x3c, 0x9b, 0xef, 0xf6, - 0x02, 0x67, 0xad, 0xd9, 0x86, 0xbc, 0x0f, 0xa9, 0x8b, 0x9e, 0x67, 0xa3, 0x53, 0xd0, 0xef, 0x34, - 0x6a, 0xd8, 0xe5, 0x7b, 0xea, 0x93, 0x85, 0x00, 0xa7, 0x40, 0x10, 0x94, 0x46, 0x0d, 0x2b, 0x0c, - 0x05, 0x95, 0x61, 0x7a, 0xa7, 0x51, 0xab, 0xed, 0xab, 0x15, 0x4c, 0x1f, 0x6d, 0xf8, 0xd7, 0x1e, - 0xf1, 0x75, 0x5b, 0x13, 0x47, 0x1f, 0xc4, 0x64, 0x27, 0x28, 0xda, 0x02, 0xc5, 0x12, 0x57, 0x1e, - 0xcb, 0x02, 0x47, 0xfe, 0xfd, 0x04, 0xa4, 0x05, 0x6b, 0x94, 0x87, 0xb4, 0x8b, 0x6b, 0x58, 0xf7, - 0x2c, 0x87, 0xdf, 0x45, 0xf3, 0xcb, 0x08, 0x41, 0xb2, 0xca, 0xdf, 0x61, 0x65, 0x2e, 0xf6, 0x29, - 0xa4, 0x40, 0x60, 0x76, 0x83, 0x3d, 0xc2, 0xa2, 0x30, 0xbb, 0xe1, 0xa1, 0x49, 0x48, 0xd9, 0x96, - 0xeb, 0xb1, 0xe3, 0x88, 0x8b, 0x7d, 0x0a, 0x2d, 0xa1, 0x1c, 0x0c, 0x54, 0x70, 0x0d, 0x7b, 0xec, - 0x3c, 0x89, 0xc0, 0x79, 0x19, 0x1d, 0x85, 0x7e, 0x5b, 0xf3, 0xf4, 0x5d, 0x76, 0x25, 0xfb, 0x62, - 0x9f, 0xc2, 0x8a, 0x08, 0x41, 0x6a, 0xdb, 0xaa, 0xec, 0xf3, 0xcb, 0xd6, 0xf4, 0x37, 0x7a, 0x06, - 0x06, 0xd8, 0x68, 0x8f, 0xdf, 0x92, 0x26, 0x06, 0x62, 0xdb, 0xaa, 0x44, 0x97, 0x75, 0x8d, 0x64, - 0xf0, 0x26, 0x69, 0x84, 0xa1, 0xa3, 0x32, 0x4c, 0x68, 0x95, 0x8a, 0xc1, 0xee, 0x42, 0xab, 0xdb, - 0x86, 0x59, 0x31, 0xcc, 0xaa, 0x4b, 0x5f, 0x15, 0xb5, 0x33, 0x33, 0x0a, 0x08, 0x4a, 0x1c, 0x9f, - 0xdf, 0x2e, 0xa5, 0x6f, 0xc7, 0x54, 0x2a, 0x1c, 0x7b, 0xe3, 0x32, 0x2c, 0x80, 0x25, 0xab, 0xb2, - 0x5f, 0xca, 0xc0, 0xa0, 0xcd, 0x04, 0x90, 0xcf, 0xc3, 0x78, 0x93, 0x54, 0x44, 0xb1, 0x3d, 0xc3, - 0xac, 0x88, 0x6b, 0x8f, 0xe4, 0x37, 0x81, 0xd1, 0x43, 0x0f, 0x76, 0xaa, 0x41, 0x7f, 0x97, 0xde, - 0x2b, 0xb5, 0x75, 0xcd, 0xd1, 0x90, 0x6b, 0x6a, 0xb6, 0x51, 0xca, 0x50, 0xfe, 0xc4, 0xad, 0xd6, - 0xa5, 0x77, 0xcc, 0x35, 0x1f, 0x5a, 0x54, 0xb1, 0x29, 0x4e, 0x1b, 0x48, 0x95, 0x66, 0x1b, 0x2e, - 0x75, 0xc7, 0xe0, 0x10, 0xc6, 0x3d, 0x1f, 0xfa, 0x4d, 0x0f, 0x32, 0x52, 0x8b, 0x73, 0xeb, 0x4b, - 0xfe, 0x53, 0xb5, 0xaf, 0x24, 0xe0, 0x44, 0xc8, 0x8f, 0x43, 0xc8, 0xcd, 0xee, 0x9c, 0x6f, 0xed, - 0xf1, 0x3d, 0x1c, 0x6a, 0x5c, 0x86, 0x14, 0xc1, 0x47, 0x5d, 0x2e, 0x6d, 0xe6, 0x7e, 0xf5, 0xeb, - 0xff, 0x42, 0xa6, 0x0e, 0xd0, 0xba, 0xeb, 0x28, 0x93, 0xd2, 0xfb, 0x7b, 0xb7, 0x5f, 0x36, 0x38, - 0x7f, 0x72, 0xef, 0x9c, 0x19, 0xe3, 0x36, 0xfc, 0x53, 0x09, 0x8e, 0xc7, 0x4d, 0xa0, 0x99, 0xfb, - 0x6d, 0xde, 0xf9, 0xe5, 0x5b, 0x1e, 0x12, 0xc9, 0x6f, 0x82, 0xe4, 0x9c, 0xb9, 0x8f, 0x8e, 0xb3, - 0xfc, 0x47, 0x6d, 0x38, 0x35, 0xee, 0x48, 0x83, 0xa4, 0xbc, 0xe5, 0xd4, 0xd0, 0x64, 0x70, 0xb5, - 0x5b, 0x3a, 0x39, 0xcc, 0xef, 0x6b, 0x17, 0x53, 0xdf, 0xff, 0xf4, 0x74, 0x5f, 0x69, 0x2f, 0x6e, - 0x92, 0x2f, 0x77, 0x8d, 0x78, 0xe9, 0x39, 0x73, 0x5f, 0xd8, 0xa4, 0x9f, 0x1e, 0x7a, 0x89, 0x43, - 0xae, 0xa9, 0xf8, 0x21, 0xd7, 0xdb, 0x70, 0xad, 0x76, 0xd9, 0xb4, 0xae, 0x99, 0x9b, 0x04, 0xcd, - 0xd7, 0xfb, 0xc3, 0x09, 0x98, 0x6a, 0xea, 0x7a, 0x3e, 0x0b, 0xb4, 0x7b, 0xe4, 0x58, 0x84, 0xf4, - 0x82, 0x98, 0x5c, 0x72, 0x30, 0xe8, 0x62, 0xdd, 0x32, 0x2b, 0x2e, 0x55, 0x35, 0xa9, 0x88, 0x22, - 0x51, 0xd5, 0xd4, 0x4c, 0xcb, 0xe5, 0x37, 0xab, 0x59, 0xa1, 0xf4, 0x71, 0xe9, 0x60, 0x31, 0x7d, - 0x44, 0xb4, 0x24, 0xd4, 0x7c, 0xb2, 0xeb, 0xb1, 0xdf, 0x1e, 0xd1, 0xd2, 0x57, 0x22, 0x72, 0xf4, - 0xd7, 0xab, 0x55, 0x3e, 0x92, 0x80, 0xe9, 0xb8, 0x55, 0xc8, 0xd4, 0xea, 0x7a, 0x5a, 0xdd, 0x6e, - 0x67, 0x96, 0xf3, 0x90, 0xd9, 0x14, 0x38, 0x07, 0xb6, 0xcb, 0xcd, 0x03, 0xda, 0x65, 0xd4, 0x6f, - 0x4a, 0x18, 0xe6, 0x74, 0x8f, 0x86, 0xf1, 0xf5, 0x38, 0x94, 0x65, 0xde, 0x9b, 0x04, 0xfe, 0x66, - 0x58, 0x65, 0xee, 0xcf, 0x1f, 0x10, 0x33, 0x9b, 0x0c, 0x87, 0xab, 0x7a, 0x88, 0x29, 0x17, 0x61, - 0x94, 0xa6, 0x0b, 0xf4, 0x88, 0x88, 0x66, 0x68, 0x5d, 0x93, 0xea, 0xaf, 0xfd, 0x3b, 0x3a, 0x49, - 0x29, 0x23, 0x3e, 0x21, 0xbd, 0x21, 0xb7, 0x09, 0x93, 0x46, 0xdd, 0xae, 0x61, 0x7a, 0x34, 0xae, - 0xfa, 0x75, 0xdd, 0xf9, 0x7d, 0x9d, 0xf3, 0x9b, 0x08, 0xc8, 0x97, 0x04, 0x75, 0x71, 0x19, 0xc6, - 0x35, 0x5d, 0xc7, 0x76, 0x84, 0x65, 0x97, 0x54, 0x46, 0x08, 0x98, 0xe5, 0x94, 0x3e, 0xb7, 0xd2, - 0x73, 0x6d, 0x1f, 0x28, 0x3f, 0x18, 0xca, 0x56, 0x1c, 0x5c, 0xc5, 0xe6, 0xe3, 0x26, 0xf6, 0xae, - 0x59, 0xce, 0x1e, 0x37, 0xef, 0xe3, 0xac, 0x29, 0xd1, 0x09, 0xef, 0x4f, 0xc2, 0x54, 0xf8, 0x91, - 0xb7, 0x78, 0xde, 0xad, 0x5b, 0x86, 0x18, 0xb4, 0x13, 0xe1, 0x87, 0xdd, 0xbc, 0xbe, 0x4d, 0xd4, - 0x5a, 0x84, 0xd4, 0xbc, 0x65, 0x98, 0xc4, 0x31, 0x2b, 0xd8, 0xb4, 0xea, 0x3c, 0x66, 0xb1, 0x02, - 0xba, 0x1f, 0x06, 0xb4, 0xba, 0xd5, 0x30, 0x79, 0x76, 0x51, 0x1a, 0xfa, 0xea, 0xad, 0xe9, 0xbe, - 0xdf, 0xbf, 0x35, 0x9d, 0x5c, 0x32, 0x3d, 0x85, 0x57, 0x15, 0x53, 0xaf, 0x7f, 0x6a, 0x5a, 0x92, - 0x2f, 0xc1, 0xe0, 0x02, 0xd6, 0x0f, 0xc3, 0x6b, 0x01, 0xeb, 0x31, 0x5e, 0x8f, 0x40, 0x7a, 0xc9, - 0xf4, 0xd8, 0x5b, 0x84, 0x7b, 0x21, 0x69, 0x98, 0xec, 0x7a, 0x6b, 0xac, 0x7d, 0x02, 0x27, 0xa8, - 0x0b, 0x58, 0xf7, 0x51, 0x2b, 0x58, 0x8f, 0xa3, 0x12, 0xf6, 0x04, 0x5e, 0xba, 0xf0, 0x7b, 0xff, - 0x69, 0xaa, 0xef, 0x95, 0x6f, 0x4d, 0xf5, 0xb5, 0xed, 0x89, 0x07, 0x7a, 0x79, 0x2a, 0xee, 0x77, - 0xc4, 0xef, 0x48, 0x30, 0x43, 0x1f, 0xa2, 0x39, 0x75, 0xc3, 0xf4, 0x66, 0x6b, 0xc6, 0xb6, 0x3b, - 0xbb, 0x6d, 0x78, 0x2e, 0x43, 0xe3, 0x5d, 0x31, 0x19, 0x60, 0x14, 0x08, 0x46, 0x81, 0x60, 0xc8, - 0x4f, 0x43, 0xba, 0x64, 0x78, 0x73, 0x8e, 0xa3, 0xed, 0xd3, 0x74, 0xca, 0xf0, 0x44, 0xa4, 0xa0, - 0xbf, 0x89, 0x05, 0x71, 0x0d, 0xd7, 0x5d, 0x7a, 0x15, 0x25, 0xa5, 0xb0, 0x42, 0x69, 0xab, 0xad, - 0xe0, 0xe7, 0x43, 0x82, 0x87, 0x44, 0x0a, 0xfd, 0x64, 0x1d, 0xdf, 0x4a, 0x5c, 0x5f, 0x9f, 0xcf, - 0xa5, 0xe0, 0xde, 0x10, 0x82, 0xee, 0xec, 0xdb, 0x1e, 0x4d, 0x9d, 0xad, 0x1d, 0xae, 0xcc, 0x78, - 0x48, 0x19, 0x56, 0xdd, 0xc6, 0xab, 0x76, 0xa0, 0x7f, 0x9d, 0xd0, 0x05, 0x8f, 0xf5, 0x99, 0x76, - 0xac, 0x40, 0xa0, 0xec, 0x31, 0x5e, 0x82, 0x41, 0x0d, 0xf1, 0x0e, 0xaf, 0x86, 0xb5, 0x1d, 0xf6, - 0xa6, 0x21, 0x49, 0xa7, 0xc8, 0x34, 0x01, 0xd0, 0xe7, 0x0b, 0x93, 0xd0, 0xaf, 0x35, 0xd8, 0x65, - 0x9a, 0x24, 0x99, 0x3b, 0x69, 0x41, 0xbe, 0x0c, 0x83, 0xfc, 0x48, 0xbf, 0xc5, 0x27, 0x0a, 0x0a, - 0xd0, 0x4f, 0x85, 0xe7, 0x8f, 0xb5, 0x72, 0x85, 0x26, 0xe9, 0x0b, 0x54, 0x48, 0x85, 0xa1, 0xc9, - 0x97, 0x20, 0xbd, 0x60, 0xd5, 0x0d, 0xd3, 0x8a, 0x72, 0xcb, 0x30, 0x6e, 0x54, 0x66, 0x92, 0x53, - 0xb3, 0x4c, 0x90, 0x15, 0xe8, 0x67, 0x10, 0xe8, 0x1b, 0x17, 0x7e, 0x21, 0x88, 0x97, 0xe4, 0x79, - 0x18, 0xa4, 0xbc, 0xd7, 0x6c, 0xd2, 0xbf, 0xfe, 0x75, 0xe2, 0x0c, 0x7f, 0xf1, 0xc8, 0xd9, 0x27, - 0x02, 0x61, 0x11, 0xa4, 0x2a, 0x9a, 0xa7, 0x71, 0xbd, 0xe9, 0x6f, 0xf9, 0x2d, 0x90, 0xe6, 0x4c, - 0x5c, 0x74, 0x1a, 0x92, 0x96, 0x2d, 0x96, 0x1f, 0xf9, 0x76, 0xaa, 0xac, 0xd9, 0xa5, 0x14, 0xf1, - 0x7b, 0x85, 0x20, 0x97, 0x94, 0xb6, 0xfe, 0x72, 0xee, 0xe0, 0xfe, 0xc2, 0x9a, 0xf1, 0x9d, 0xe5, - 0xd3, 0x09, 0x98, 0x0a, 0xd5, 0x5e, 0xc5, 0x0e, 0x59, 0xb4, 0x44, 0x5c, 0x1f, 0x85, 0x84, 0xe4, - 0xf5, 0x6d, 0xdc, 0xe5, 0xcd, 0x90, 0x9c, 0xb3, 0x6d, 0xb2, 0xc8, 0xa1, 0x65, 0xdd, 0x62, 0xfe, - 0x92, 0x52, 0xfc, 0x32, 0x5d, 0x00, 0x59, 0x3b, 0xde, 0x35, 0xcd, 0xf1, 0x9f, 0x81, 0x8a, 0xb2, - 0xfc, 0x2c, 0x64, 0xe6, 0x49, 0x92, 0x6f, 0xba, 0x0d, 0x3a, 0x74, 0xb6, 0x6b, 0x96, 0xbe, 0xc7, - 0x39, 0xb0, 0x02, 0x31, 0xb8, 0x66, 0xdb, 0xfc, 0x93, 0x11, 0xe4, 0x27, 0x8b, 0x34, 0xa5, 0x8d, - 0xb6, 0x26, 0x7a, 0xf6, 0xe0, 0x26, 0xe2, 0x4a, 0xfa, 0x36, 0xfa, 0x03, 0x09, 0x4e, 0x34, 0x0f, - 0xa8, 0x3d, 0xbc, 0xef, 0x1e, 0x74, 0x3c, 0x9d, 0x83, 0xcc, 0x3a, 0xfd, 0x16, 0xc3, 0x65, 0xbc, - 0x8f, 0xf2, 0x30, 0x88, 0x2b, 0xa7, 0xcf, 0x9c, 0x79, 0xf2, 0x59, 0xe6, 0xed, 0x17, 0xfb, 0x14, - 0x01, 0x28, 0xa6, 0x89, 0x56, 0xaf, 0x7f, 0x7a, 0x5a, 0x2a, 0xf5, 0x43, 0xd2, 0x6d, 0xd4, 0xef, - 0xaa, 0x0f, 0xbc, 0xd6, 0x1f, 0x09, 0x80, 0x2c, 0xcf, 0xb8, 0xaa, 0xd5, 0x8c, 0x8a, 0x16, 0x7c, - 0x25, 0x23, 0x1b, 0xd2, 0x91, 0x62, 0xb4, 0x56, 0x31, 0xdf, 0xd1, 0x52, 0xf2, 0xe7, 0x25, 0x18, - 0xbe, 0x22, 0x38, 0x6f, 0x60, 0x0f, 0x9d, 0x07, 0xf0, 0x5b, 0x12, 0xc3, 0xe2, 0x9e, 0x42, 0xbc, - 0xad, 0x82, 0x4f, 0xa3, 0x84, 0xd0, 0xd1, 0x33, 0xd4, 0xd1, 0x6c, 0xcb, 0xe5, 0x4f, 0xff, 0xba, - 0x90, 0xfa, 0xc8, 0xe8, 0x31, 0x40, 0x34, 0x82, 0xa9, 0x57, 0x2d, 0xcf, 0x30, 0xab, 0xaa, 0x6d, - 0x5d, 0xe3, 0x0f, 0xaa, 0x93, 0x4a, 0x96, 0xd6, 0x5c, 0xa1, 0x15, 0xeb, 0x04, 0x4e, 0x84, 0xce, - 0xf8, 0x5c, 0x48, 0x52, 0xa8, 0x55, 0x2a, 0x0e, 0x76, 0x5d, 0xf1, 0x45, 0x13, 0x5e, 0x44, 0xe7, - 0x61, 0xd0, 0x6e, 0x6c, 0xab, 0x22, 0x22, 0x0c, 0x9d, 0x3e, 0xd1, 0x6a, 0x7c, 0x8b, 0xfe, 0xe7, - 0x23, 0x7c, 0xc0, 0x6e, 0x6c, 0x13, 0x6f, 0xb8, 0x0f, 0x86, 0x5b, 0x08, 0x33, 0x74, 0x35, 0x90, - 0x83, 0x7e, 0xe2, 0x83, 0x6b, 0xa0, 0xda, 0x8e, 0x61, 0x39, 0x86, 0xb7, 0x4f, 0x77, 0x01, 0x92, - 0x4a, 0x56, 0x54, 0xac, 0x73, 0xb8, 0xbc, 0x07, 0x63, 0x1b, 0x34, 0x1b, 0x0a, 0x24, 0x3f, 0x13, - 0xc8, 0x27, 0x75, 0x97, 0xaf, 0xad, 0x64, 0x89, 0x26, 0xc9, 0x4a, 0xcf, 0xb7, 0xf5, 0xce, 0x67, - 0x0e, 0xee, 0x9d, 0xd1, 0xd9, 0xf9, 0xcf, 0xf2, 0x91, 0xc1, 0xc7, 0x9c, 0x33, 0x1c, 0x9e, 0x7a, - 0x75, 0xcc, 0x6e, 0x6b, 0x81, 0x7c, 0xd7, 0x24, 0x20, 0xdf, 0x79, 0x5a, 0xcd, 0x77, 0x09, 0xa4, - 0xf9, 0xae, 0x83, 0x4c, 0x7e, 0x16, 0x46, 0xd6, 0x35, 0xc7, 0xdb, 0xc0, 0xde, 0x45, 0xac, 0x55, - 0xb0, 0x13, 0x9d, 0x77, 0x47, 0xc4, 0xbc, 0x8b, 0x20, 0x45, 0x27, 0x57, 0x36, 0xef, 0xd0, 0xdf, - 0xf2, 0x2e, 0xa4, 0xe8, 0xed, 0x5c, 0x7f, 0x4e, 0xe6, 0x14, 0x6c, 0x4e, 0x26, 0xd1, 0x74, 0xdf, - 0xc3, 0xae, 0x58, 0xb2, 0xd2, 0x02, 0x7a, 0x5a, 0xcc, 0xac, 0xc9, 0xce, 0x33, 0x2b, 0x77, 0x55, - 0x3e, 0xbf, 0xd6, 0x60, 0xb0, 0x44, 0x82, 0xf1, 0xd2, 0x82, 0x2f, 0x88, 0x14, 0x08, 0x82, 0x56, - 0x60, 0xcc, 0xd6, 0x1c, 0x8f, 0x3e, 0x6c, 0xda, 0xa5, 0x5a, 0xf0, 0xd1, 0x30, 0xdd, 0x3c, 0x36, - 0x23, 0xca, 0xf2, 0x56, 0x46, 0xec, 0x30, 0x50, 0xfe, 0xe3, 0x14, 0x0c, 0x70, 0x63, 0xbc, 0x19, - 0x06, 0xb9, 0x59, 0xb9, 0xff, 0xde, 0x5b, 0x68, 0x9e, 0x9a, 0x0a, 0xfe, 0x14, 0xc2, 0xf9, 0x09, - 0x1a, 0xf4, 0x10, 0xa4, 0xf5, 0x5d, 0xcd, 0x30, 0x55, 0xa3, 0x22, 0x52, 0xd7, 0x6f, 0xdd, 0x9a, - 0x1e, 0x9c, 0x27, 0xb0, 0xa5, 0x05, 0x65, 0x90, 0x56, 0x2e, 0x55, 0x48, 0x2e, 0xb0, 0x8b, 0x8d, - 0xea, 0xae, 0xc7, 0xc7, 0x20, 0x2f, 0xa1, 0x73, 0x90, 0x22, 0x2e, 0xc3, 0x9f, 0xbd, 0xe6, 0x9b, - 0x16, 0x10, 0xfe, 0x62, 0xae, 0x94, 0x26, 0x0d, 0x7f, 0xe8, 0x0f, 0xa7, 0x25, 0x85, 0x52, 0xa0, - 0x79, 0x18, 0xa9, 0x69, 0xae, 0xa7, 0xd2, 0x39, 0x8c, 0x34, 0xdf, 0x4f, 0x59, 0x1c, 0x6f, 0x36, - 0x08, 0x37, 0x2c, 0x17, 0x7d, 0x88, 0x50, 0x31, 0x50, 0x05, 0x9d, 0x84, 0x2c, 0x65, 0xa2, 0x5b, - 0xf5, 0xba, 0xe1, 0xb1, 0xec, 0x6a, 0x80, 0xda, 0x7d, 0x94, 0xc0, 0xe7, 0x29, 0x98, 0xe6, 0x58, - 0xf7, 0x40, 0x86, 0x3e, 0xb4, 0xa3, 0x28, 0xec, 0x4a, 0x78, 0x9a, 0x00, 0x68, 0xe5, 0xc3, 0x30, - 0x16, 0x44, 0x50, 0x86, 0x92, 0x66, 0x5c, 0x02, 0x30, 0x45, 0x7c, 0x02, 0x26, 0xe9, 0xa7, 0x9b, - 0xe2, 0xd8, 0x19, 0x8a, 0x8d, 0x48, 0xdd, 0x95, 0x28, 0xc5, 0x83, 0x30, 0xaa, 0x0b, 0xe3, 0x33, - 0x5c, 0xa0, 0xb8, 0x23, 0x3e, 0x94, 0xa2, 0x1d, 0x87, 0xb4, 0x66, 0xdb, 0x0c, 0x61, 0x88, 0x47, - 0x50, 0xdb, 0xa6, 0x55, 0xa7, 0x60, 0x9c, 0xea, 0xe8, 0x60, 0xb7, 0x51, 0xf3, 0x38, 0x93, 0x61, - 0x8a, 0x33, 0x46, 0x2a, 0x14, 0x06, 0xa7, 0xb8, 0xf7, 0xc3, 0x08, 0xbe, 0x6a, 0x54, 0xb0, 0xa9, - 0x63, 0x86, 0x37, 0x42, 0xf1, 0x86, 0x05, 0x90, 0x22, 0x3d, 0x02, 0x7e, 0x64, 0x54, 0x45, 0xd4, - 0x1e, 0x65, 0xfc, 0x04, 0x7c, 0x8e, 0x81, 0xe5, 0xc7, 0x20, 0xb5, 0xa0, 0x79, 0x1a, 0x49, 0x31, - 0xbc, 0xeb, 0x6c, 0x2a, 0x1a, 0x56, 0xc8, 0xcf, 0x96, 0xc3, 0xed, 0xf5, 0x04, 0xa4, 0xae, 0x58, - 0x1e, 0x46, 0x4f, 0x85, 0xd2, 0xc2, 0xd1, 0x56, 0x3e, 0xbe, 0x61, 0x54, 0x4d, 0x5c, 0x59, 0x71, - 0xab, 0xa1, 0x2f, 0x65, 0x04, 0x2e, 0x96, 0x88, 0xb8, 0xd8, 0x24, 0xf4, 0x3b, 0x56, 0xc3, 0xac, - 0x88, 0x1b, 0xd6, 0xb4, 0x80, 0xca, 0x90, 0xf6, 0x3d, 0x27, 0xd5, 0xcd, 0x73, 0xc6, 0x88, 0xe7, - 0x10, 0xbf, 0xe6, 0x00, 0x65, 0x70, 0x9b, 0x3b, 0x50, 0x09, 0x32, 0x7e, 0xc8, 0xe3, 0x1e, 0xd8, - 0x9b, 0x13, 0x07, 0x64, 0x64, 0x0a, 0xf2, 0xfd, 0xc1, 0x37, 0x28, 0xf3, 0xc2, 0xac, 0x5f, 0xc1, - 0x2d, 0x1a, 0x71, 0x35, 0xfe, 0xd5, 0x8e, 0x41, 0xaa, 0x57, 0xe0, 0x6a, 0xec, 0xcb, 0x1d, 0x27, - 0x20, 0xe3, 0x1a, 0x55, 0x53, 0xf3, 0x1a, 0x0e, 0xe6, 0xde, 0x18, 0x00, 0xe4, 0x57, 0x13, 0x30, - 0xc0, 0xbc, 0x3b, 0x64, 0x37, 0xa9, 0xb5, 0xdd, 0x12, 0xed, 0xec, 0x96, 0x3c, 0xbc, 0xdd, 0xe6, - 0x00, 0x7c, 0x61, 0x5c, 0xfe, 0x31, 0x85, 0x16, 0x79, 0x06, 0x13, 0x71, 0xc3, 0xa8, 0xf2, 0xc1, - 0x1b, 0x22, 0xf2, 0x3d, 0xa8, 0x3f, 0x14, 0x27, 0xcf, 0x43, 0x66, 0xdb, 0xf0, 0x54, 0x8d, 0x2c, - 0x1e, 0xa9, 0x09, 0x87, 0x4e, 0x4f, 0x15, 0x5a, 0xad, 0x32, 0x0b, 0x62, 0x89, 0xa9, 0xa4, 0xb7, - 0xf9, 0x2f, 0xf9, 0x0f, 0x24, 0x92, 0x2b, 0xf3, 0x06, 0xd1, 0x1c, 0x8c, 0x08, 0x45, 0xd5, 0x9d, - 0x9a, 0x56, 0xe5, 0xce, 0x78, 0x6f, 0x5b, 0x6d, 0x2f, 0xd4, 0xb4, 0xaa, 0x32, 0xc4, 0x15, 0x24, - 0x85, 0xd6, 0x1d, 0x9b, 0x68, 0xd3, 0xb1, 0x11, 0x4f, 0x4a, 0x1e, 0xce, 0x93, 0x22, 0x7d, 0x9e, - 0x8a, 0xf7, 0xf9, 0x17, 0x12, 0x74, 0xcd, 0x64, 0x5b, 0xae, 0x56, 0xfb, 0x71, 0x0c, 0xb1, 0x7b, - 0x20, 0x63, 0x5b, 0x35, 0x95, 0xd5, 0xb0, 0xa7, 0x0c, 0x69, 0xdb, 0xaa, 0x29, 0x4d, 0x7e, 0xd4, - 0x7f, 0x87, 0xc6, 0xdf, 0xc0, 0x1d, 0xb0, 0xda, 0x60, 0xdc, 0x6a, 0x0e, 0x0c, 0x33, 0x53, 0xf0, - 0x09, 0xf3, 0x09, 0x62, 0x03, 0x3a, 0x03, 0x4b, 0xcd, 0x13, 0x3c, 0x13, 0x9b, 0x61, 0x2a, 0x1c, - 0x8f, 0x50, 0xb0, 0xf9, 0xa5, 0xd5, 0x62, 0x3b, 0xec, 0xe7, 0x0a, 0xc7, 0x93, 0xff, 0x8e, 0x04, - 0xb0, 0x4c, 0x2c, 0x4b, 0xf5, 0x25, 0x53, 0x9d, 0x4b, 0x45, 0x50, 0x23, 0x2d, 0x4f, 0xb5, 0xeb, - 0x34, 0xde, 0xfe, 0xb0, 0x1b, 0x96, 0x7b, 0x1e, 0x46, 0x02, 0x67, 0x14, 0xdf, 0x26, 0x6c, 0xc9, - 0x24, 0xbc, 0x96, 0x50, 0x86, 0xaf, 0x86, 0x4a, 0xf2, 0xbf, 0x92, 0x20, 0x43, 0x65, 0x5a, 0xc1, - 0x9e, 0x16, 0xe9, 0x43, 0xe9, 0xf0, 0x7d, 0x78, 0x2f, 0x00, 0x63, 0xe3, 0x1a, 0x2f, 0x63, 0xee, - 0x59, 0x19, 0x0a, 0xd9, 0x30, 0x5e, 0xc6, 0xe8, 0xac, 0x6f, 0xf0, 0x64, 0x67, 0x83, 0x8b, 0xe4, - 0x9f, 0x9b, 0xfd, 0x18, 0x0c, 0xd2, 0xaf, 0x99, 0x5d, 0x77, 0x79, 0x3e, 0x3f, 0x60, 0x36, 0xea, - 0x9b, 0xd7, 0x5d, 0xf9, 0x45, 0x18, 0xdc, 0xbc, 0xce, 0xb6, 0x60, 0xee, 0x81, 0x8c, 0x63, 0x59, - 0x7c, 0xe2, 0x67, 0x09, 0x57, 0x9a, 0x00, 0xe8, 0x3c, 0x27, 0xb6, 0x1d, 0x12, 0xc1, 0xb6, 0x43, - 0xb0, 0x6f, 0x92, 0xec, 0x69, 0xdf, 0xe4, 0xd4, 0xbf, 0x97, 0x60, 0x28, 0x14, 0x1f, 0xd0, 0x93, - 0x70, 0xa4, 0xb4, 0xbc, 0x36, 0x7f, 0x59, 0x5d, 0x5a, 0x50, 0x2f, 0x2c, 0xcf, 0x2d, 0x06, 0x8f, - 0xf5, 0xf2, 0x47, 0x6f, 0xdc, 0x9c, 0x41, 0x21, 0xdc, 0x2d, 0x93, 0x6e, 0x4b, 0xa3, 0x59, 0x98, - 0x8c, 0x92, 0xcc, 0x95, 0x36, 0xca, 0xab, 0x9b, 0x59, 0x29, 0x7f, 0xe4, 0xc6, 0xcd, 0x99, 0xf1, - 0x10, 0xc5, 0xdc, 0xb6, 0x8b, 0x4d, 0xaf, 0x99, 0x60, 0x7e, 0x6d, 0x65, 0x65, 0x69, 0x33, 0x9b, - 0x68, 0x22, 0xe0, 0x33, 0xc0, 0x23, 0x30, 0x1e, 0x25, 0x58, 0x5d, 0x5a, 0xce, 0x26, 0xf3, 0xe8, - 0xc6, 0xcd, 0x99, 0xd1, 0x10, 0xf6, 0xaa, 0x51, 0xcb, 0xa7, 0x3f, 0xf0, 0x99, 0xa9, 0xbe, 0x5f, - 0xfa, 0xc5, 0x29, 0x89, 0x68, 0x36, 0x12, 0x89, 0x11, 0xe8, 0x31, 0x38, 0xb6, 0xb1, 0xb4, 0xb8, - 0x5a, 0x5e, 0x50, 0x57, 0x36, 0x16, 0x55, 0xf6, 0x99, 0x23, 0x5f, 0xbb, 0xb1, 0x1b, 0x37, 0x67, - 0x86, 0xb8, 0x4a, 0xed, 0xb0, 0xd7, 0x95, 0xf2, 0x95, 0xb5, 0xcd, 0x72, 0x56, 0x62, 0xd8, 0xeb, - 0x0e, 0xbe, 0x6a, 0x79, 0xec, 0x73, 0x87, 0x4f, 0xc0, 0xf1, 0x16, 0xd8, 0xbe, 0x62, 0xe3, 0x37, - 0x6e, 0xce, 0x8c, 0xac, 0x3b, 0x98, 0x8d, 0x1f, 0x4a, 0x51, 0x80, 0x5c, 0x33, 0xc5, 0xda, 0xfa, - 0xda, 0xc6, 0xdc, 0x72, 0x76, 0x26, 0x9f, 0xbd, 0x71, 0x73, 0x66, 0x58, 0x04, 0x43, 0x82, 0x1f, - 0x68, 0x76, 0x37, 0x17, 0x5e, 0x1f, 0x2c, 0xc0, 0x03, 0x7c, 0x7f, 0xda, 0xf5, 0xb4, 0x3d, 0xc3, - 0xac, 0xfa, 0x5b, 0xd4, 0xbc, 0xcc, 0x17, 0x60, 0x47, 0xf9, 0x2e, 0xb5, 0x80, 0x76, 0xdc, 0xa8, - 0xce, 0xb7, 0x3f, 0xa0, 0xcb, 0x77, 0x39, 0xc3, 0xea, 0xbe, 0x82, 0x6b, 0x7f, 0xa8, 0x91, 0xef, - 0xb2, 0xd5, 0x9e, 0xef, 0xb8, 0xc6, 0x94, 0x3f, 0x28, 0xc1, 0xe8, 0x45, 0xc3, 0xf5, 0x2c, 0xc7, - 0xd0, 0xb5, 0x1a, 0x7d, 0xa2, 0x77, 0xb6, 0xd7, 0xd8, 0x1a, 0x1b, 0xea, 0xcf, 0xc1, 0xc0, 0x55, - 0xad, 0xc6, 0x82, 0x5a, 0x92, 0x7e, 0x93, 0xa8, 0xb5, 0xf9, 0x82, 0xd0, 0x26, 0x18, 0x30, 0x32, - 0xf9, 0xd7, 0x13, 0x30, 0x46, 0x07, 0x83, 0xcb, 0xbe, 0x56, 0xe7, 0xd1, 0x4f, 0xcb, 0xa4, 0x1c, - 0xcd, 0xe3, 0x7b, 0x93, 0xa5, 0x27, 0xf8, 0x96, 0xf9, 0xc9, 0x5e, 0xb6, 0xc1, 0x0b, 0x0b, 0x58, - 0x57, 0x28, 0x35, 0xfa, 0x19, 0x48, 0xd7, 0xb5, 0xeb, 0x2a, 0xe5, 0xc4, 0x16, 0x48, 0xf3, 0x07, - 0xe5, 0x74, 0xfb, 0xd6, 0xf4, 0xd8, 0xbe, 0x56, 0xaf, 0x15, 0x65, 0xc1, 0x49, 0x56, 0x06, 0xeb, - 0xda, 0x75, 0x22, 0x26, 0x72, 0x60, 0x8c, 0x40, 0xf5, 0x5d, 0xcd, 0xac, 0x62, 0xd6, 0x0c, 0xdd, - 0x6d, 0x2d, 0x5d, 0x3a, 0x44, 0x33, 0x47, 0x83, 0x66, 0x42, 0x0c, 0x65, 0x65, 0xa4, 0xae, 0x5d, - 0x9f, 0xa7, 0x00, 0xd2, 0x66, 0x31, 0xfd, 0xd1, 0x4f, 0x4d, 0xf7, 0xd1, 0xc3, 0x88, 0x6f, 0x4a, - 0x00, 0x81, 0xdd, 0xd0, 0x4f, 0x41, 0x56, 0xf7, 0x4b, 0x94, 0xd6, 0xe5, 0x3d, 0xf9, 0x70, 0xbb, - 0x1e, 0x89, 0x59, 0x9d, 0xcd, 0xd0, 0xdf, 0xb8, 0x35, 0x2d, 0x29, 0x63, 0x7a, 0xac, 0x43, 0xde, - 0x09, 0x43, 0x0d, 0xbb, 0xa2, 0x79, 0x58, 0xa5, 0x4b, 0xc6, 0x44, 0xd7, 0xd9, 0x7e, 0x8a, 0xf0, - 0xba, 0x7d, 0x6b, 0x1a, 0x31, 0xb5, 0x42, 0xc4, 0x32, 0xcd, 0x01, 0x80, 0x41, 0x08, 0x41, 0x48, - 0xa7, 0xaf, 0x49, 0x30, 0xb4, 0x10, 0xba, 0x42, 0x9b, 0x83, 0xc1, 0xba, 0x65, 0x1a, 0x7b, 0x58, - 0xdc, 0x2e, 0x11, 0x45, 0x94, 0x87, 0x34, 0x7b, 0xbb, 0xec, 0xed, 0x8b, 0x7d, 0x57, 0x51, 0x26, - 0x54, 0xd7, 0xf0, 0xb6, 0x6b, 0x88, 0xfe, 0x50, 0x44, 0x11, 0x5d, 0x80, 0xac, 0x8b, 0xf5, 0x86, - 0x63, 0x78, 0xfb, 0xaa, 0x6e, 0x99, 0x9e, 0xa6, 0xf3, 0x6b, 0x27, 0xa5, 0x7b, 0x6e, 0xdf, 0x9a, - 0x3e, 0xc6, 0x64, 0x8d, 0x63, 0xc8, 0xca, 0x98, 0x00, 0xcd, 0x33, 0x08, 0x69, 0xa1, 0x82, 0x3d, - 0xcd, 0xa8, 0xb9, 0xec, 0x76, 0x8a, 0x22, 0x8a, 0x21, 0x5d, 0x3e, 0x3f, 0x18, 0xde, 0x65, 0xbb, - 0x00, 0x59, 0xcb, 0xc6, 0x4e, 0x24, 0x1d, 0x95, 0xe2, 0x2d, 0xc7, 0x31, 0x64, 0x65, 0x4c, 0x80, - 0x44, 0xaa, 0xea, 0x91, 0x6e, 0x16, 0x6b, 0x52, 0xbb, 0xb1, 0x1d, 0x6c, 0xce, 0x4d, 0x36, 0xf5, - 0xc6, 0x9c, 0xb9, 0x5f, 0x7a, 0x2a, 0xe0, 0x1e, 0xa7, 0x93, 0xbf, 0xfe, 0xc5, 0xc7, 0x27, 0xb9, - 0x6b, 0x04, 0x9b, 0x65, 0x97, 0xf1, 0x3e, 0xe9, 0x7e, 0x8e, 0xba, 0x4e, 0x31, 0x49, 0xf2, 0xf9, - 0xa2, 0x66, 0xd4, 0xc4, 0xd7, 0x1c, 0x14, 0x5e, 0x42, 0x45, 0x18, 0x70, 0x3d, 0xcd, 0x6b, 0xb8, - 0xfc, 0x2b, 0x8d, 0x72, 0x3b, 0x57, 0x2b, 0x59, 0x66, 0x65, 0x83, 0x62, 0x2a, 0x9c, 0x02, 0x5d, - 0x84, 0x01, 0xcf, 0xda, 0xc3, 0x26, 0x37, 0xe1, 0x01, 0x47, 0x39, 0x3d, 0xe8, 0x63, 0xf4, 0xe8, - 0x2a, 0x64, 0x2b, 0xb8, 0x86, 0xab, 0x2c, 0xbd, 0xda, 0xd5, 0xc8, 0xb2, 0x86, 0xde, 0x0d, 0x2a, - 0x5d, 0x3e, 0xc4, 0x40, 0xe4, 0xd6, 0x8a, 0x73, 0x94, 0x95, 0x31, 0x1f, 0xb4, 0x41, 0x21, 0xe8, - 0x72, 0xe4, 0xbe, 0x37, 0xff, 0xaa, 0xe9, 0xfd, 0xed, 0x4c, 0x10, 0xf2, 0x6b, 0xb1, 0x1d, 0x12, - 0xbe, 0x2d, 0x7e, 0x01, 0xb2, 0x0d, 0x73, 0xdb, 0xa2, 0xf7, 0x86, 0x54, 0x9e, 0xe9, 0x93, 0xa5, - 0x63, 0x32, 0xec, 0x20, 0x71, 0x0c, 0x59, 0x19, 0xf3, 0x41, 0x17, 0xd9, 0x7a, 0xa0, 0x02, 0xa3, - 0x01, 0x16, 0x1d, 0xac, 0x99, 0xae, 0x83, 0xf5, 0x3e, 0x3e, 0x58, 0x8f, 0xc4, 0x5b, 0x09, 0xc6, - 0xeb, 0x88, 0x0f, 0x24, 0x64, 0xe8, 0x22, 0x40, 0x10, 0x22, 0xe8, 0xb6, 0xc8, 0x50, 0xfb, 0xce, - 0x0f, 0xe2, 0x8c, 0x58, 0x4a, 0x06, 0xb4, 0xe8, 0x3d, 0x30, 0x51, 0x37, 0x4c, 0xd5, 0xc5, 0xb5, - 0x1d, 0x95, 0x1b, 0x98, 0xb0, 0xa4, 0xdf, 0xdd, 0x2a, 0xad, 0x1e, 0xd4, 0x27, 0x6e, 0xdf, 0x9a, - 0xce, 0xf3, 0x40, 0xda, 0xcc, 0x54, 0x56, 0xc6, 0xeb, 0x86, 0xb9, 0x81, 0x6b, 0x3b, 0x0b, 0x3e, - 0xac, 0x38, 0xfc, 0x81, 0x4f, 0x4d, 0xf7, 0xf1, 0x41, 0xdb, 0x27, 0x9f, 0xa5, 0xdb, 0xf9, 0x7c, - 0xb0, 0x61, 0x97, 0xac, 0x4f, 0x34, 0x51, 0xa0, 0x5b, 0x28, 0x19, 0x25, 0x00, 0xb0, 0xc1, 0xfe, - 0xca, 0x7f, 0x9c, 0x91, 0xe4, 0x5f, 0x91, 0x60, 0x60, 0xe1, 0xca, 0xba, 0x66, 0x38, 0x68, 0x09, - 0xc6, 0x03, 0xdf, 0x89, 0x0e, 0xf5, 0x13, 0xb7, 0x6f, 0x4d, 0xe7, 0xe2, 0xee, 0xe5, 0x8f, 0xf5, - 0xc0, 0x89, 0xc5, 0x60, 0x5f, 0x6a, 0xb7, 0x88, 0x8d, 0xb0, 0x6a, 0x42, 0x91, 0x9b, 0x97, 0xb8, - 0x31, 0x35, 0xcb, 0x30, 0xc8, 0xa4, 0x75, 0x51, 0x11, 0xfa, 0x6d, 0xf2, 0x83, 0x9f, 0x55, 0x4c, - 0xb5, 0x75, 0x5f, 0x8a, 0xef, 0xef, 0x9c, 0x12, 0x12, 0xf9, 0xd5, 0x04, 0xc0, 0xc2, 0x95, 0x2b, - 0x9b, 0x8e, 0x61, 0xd7, 0xb0, 0x77, 0x27, 0x35, 0xdf, 0x84, 0x23, 0xa1, 0x15, 0x93, 0xa3, 0xc7, - 0xb4, 0x9f, 0xb9, 0x7d, 0x6b, 0xfa, 0x44, 0x5c, 0xfb, 0x10, 0x9a, 0xac, 0x4c, 0x04, 0x6b, 0x27, - 0x47, 0x6f, 0xc9, 0xb5, 0xe2, 0x7a, 0x3e, 0xd7, 0x64, 0x7b, 0xae, 0x21, 0xb4, 0x30, 0xd7, 0x05, - 0xd7, 0x6b, 0x6d, 0xda, 0x0d, 0x18, 0x0a, 0x4c, 0x42, 0x32, 0x99, 0xb4, 0xc7, 0x7f, 0x73, 0x0b, - 0xcb, 0xed, 0x2d, 0x2c, 0xc8, 0xb8, 0x95, 0x7d, 0x4a, 0xf9, 0xff, 0x4a, 0x00, 0x81, 0xcf, 0xfe, - 0x64, 0xba, 0x18, 0x09, 0xe8, 0x3c, 0xf8, 0x26, 0x0f, 0x99, 0xb6, 0x71, 0xfa, 0x98, 0x45, 0x7f, - 0x2e, 0x01, 0x13, 0x5b, 0x22, 0xfa, 0xfc, 0xc4, 0x5b, 0x61, 0x1d, 0x06, 0xb1, 0xe9, 0x39, 0x06, - 0x35, 0x03, 0xe9, 0xef, 0x27, 0xda, 0xf5, 0x77, 0x0b, 0x9d, 0xe8, 0xd7, 0xc7, 0xc4, 0x3e, 0x3f, - 0x67, 0x13, 0xb3, 0xc6, 0x87, 0x93, 0x90, 0x6b, 0x47, 0x89, 0xe6, 0x61, 0x4c, 0x77, 0x30, 0x05, - 0xa8, 0xe1, 0x8d, 0xc5, 0x52, 0x3e, 0xc8, 0x30, 0x63, 0x08, 0xb2, 0x32, 0x2a, 0x20, 0x7c, 0x06, - 0xa9, 0x02, 0x49, 0xff, 0x88, 0xe3, 0x11, 0xac, 0x1e, 0xf3, 0x3d, 0x99, 0x4f, 0x21, 0xa2, 0x91, - 0x28, 0x03, 0x36, 0x87, 0x8c, 0x06, 0x50, 0x3a, 0x89, 0xb8, 0x30, 0x66, 0x98, 0x86, 0x67, 0x68, - 0x35, 0x75, 0x5b, 0xab, 0x69, 0xa6, 0x7e, 0xb8, 0xfc, 0x99, 0x85, 0x7d, 0xde, 0x70, 0x8c, 0xa1, - 0xac, 0x8c, 0x72, 0x48, 0x89, 0x01, 0xd0, 0x25, 0x18, 0x14, 0x8d, 0xa5, 0x0e, 0x99, 0x77, 0x08, - 0x06, 0xa1, 0x64, 0xef, 0xd5, 0x24, 0x8c, 0x2b, 0xb8, 0xf2, 0x97, 0xdd, 0x71, 0xd0, 0xee, 0x58, - 0x03, 0x60, 0x83, 0x9e, 0x04, 0xda, 0x43, 0xf5, 0x08, 0x09, 0x1c, 0x19, 0xc6, 0x63, 0xc1, 0xf5, - 0x42, 0x7d, 0x72, 0x2b, 0x01, 0xc3, 0xe1, 0x3e, 0xf9, 0x0b, 0x3a, 0x3f, 0xa1, 0xa5, 0x20, 0x22, - 0xa5, 0xf8, 0xb7, 0x9b, 0xdb, 0x44, 0xa4, 0x26, 0x0f, 0xee, 0x1c, 0x8a, 0xfe, 0x2c, 0x01, 0x03, - 0xeb, 0x9a, 0xa3, 0xd5, 0x5d, 0xa4, 0x37, 0x65, 0x9d, 0x62, 0x53, 0xb2, 0xe9, 0x0b, 0xfd, 0x7c, - 0x0f, 0xa4, 0x4b, 0xd2, 0xf9, 0xd1, 0x16, 0x49, 0xe7, 0x5b, 0x61, 0x94, 0x2c, 0x8f, 0x43, 0xf7, - 0x2b, 0x88, 0xb5, 0x47, 0x4a, 0xc7, 0x03, 0x2e, 0xd1, 0x7a, 0xb6, 0x7a, 0xbe, 0x12, 0xbe, 0x60, - 0x31, 0x44, 0x30, 0x82, 0x00, 0x4d, 0xc8, 0x8f, 0x06, 0xcb, 0xd4, 0x50, 0xa5, 0xac, 0x40, 0x5d, - 0xbb, 0x5e, 0x66, 0x05, 0xb4, 0x0c, 0x68, 0xd7, 0xdf, 0x2f, 0x51, 0x03, 0x73, 0x12, 0xfa, 0x7b, - 0x6f, 0xdf, 0x9a, 0x3e, 0xce, 0xe8, 0x9b, 0x71, 0x64, 0x65, 0x3c, 0x00, 0x0a, 0x6e, 0x4f, 0x03, - 0x10, 0xbd, 0x54, 0x76, 0x1b, 0x91, 0x2d, 0x7f, 0x8e, 0xdc, 0xbe, 0x35, 0x3d, 0xce, 0xb8, 0x04, - 0x75, 0xb2, 0x92, 0x21, 0x85, 0x05, 0xf2, 0x3b, 0xe4, 0xd9, 0x9f, 0x91, 0x00, 0x05, 0xa1, 0xdf, - 0xff, 0xe7, 0x34, 0x17, 0x01, 0x42, 0x19, 0xb4, 0xd4, 0x39, 0x29, 0x0f, 0xe8, 0x45, 0x52, 0x1e, - 0x1a, 0x29, 0xcf, 0x06, 0x41, 0x32, 0xc1, 0xfb, 0xb1, 0xc5, 0xd5, 0xcd, 0xc2, 0xbc, 0x65, 0x08, - 0xea, 0xa6, 0x98, 0xd8, 0x27, 0xff, 0x8e, 0x04, 0xc7, 0x9b, 0x3c, 0xca, 0x17, 0xf6, 0x67, 0x00, - 0x39, 0xa1, 0x4a, 0xfe, 0x21, 0x4e, 0x26, 0xf4, 0x81, 0x1d, 0x74, 0xdc, 0x69, 0x8a, 0xbd, 0x77, - 0x32, 0xce, 0xb3, 0xdb, 0x9f, 0xff, 0x52, 0x82, 0xc9, 0xb0, 0x00, 0xbe, 0x2a, 0xab, 0x30, 0x1c, - 0x6e, 0x9f, 0x2b, 0xf1, 0x40, 0x2f, 0x4a, 0x70, 0xf9, 0x23, 0xf4, 0xe8, 0xf9, 0x60, 0xc0, 0xb2, - 0x3d, 0xb5, 0x27, 0x7b, 0xb6, 0x87, 0x90, 0x29, 0x3e, 0x70, 0x53, 0xb4, 0x47, 0xde, 0x97, 0x80, - 0xd4, 0xba, 0x65, 0xd5, 0xd0, 0x4b, 0x30, 0x6e, 0x5a, 0x9e, 0x4a, 0x7c, 0x0b, 0x57, 0x54, 0xbe, - 0x0c, 0x67, 0x91, 0xb0, 0x7c, 0x50, 0x33, 0x7d, 0xf7, 0xd6, 0x74, 0x33, 0x33, 0x65, 0xcc, 0xb4, - 0xbc, 0x12, 0x85, 0x6c, 0xb2, 0x45, 0xfa, 0x7b, 0x60, 0x24, 0xda, 0x1c, 0x8b, 0x94, 0x2f, 0x1c, - 0xa2, 0xb9, 0x28, 0xa3, 0xdb, 0xb7, 0xa6, 0x27, 0x83, 0x71, 0xe3, 0x83, 0x65, 0x65, 0x78, 0x3b, - 0xd4, 0x3e, 0xbb, 0x81, 0xf6, 0xfd, 0x4f, 0x4d, 0x4b, 0xa7, 0xbe, 0x24, 0x01, 0x04, 0xfb, 0x11, - 0xe8, 0x31, 0x38, 0x56, 0x5a, 0x5b, 0x5d, 0x50, 0x37, 0x36, 0xe7, 0x36, 0xb7, 0x36, 0xd4, 0xad, - 0xd5, 0x8d, 0xf5, 0xf2, 0xfc, 0xd2, 0x85, 0xa5, 0xf2, 0x42, 0xb0, 0x75, 0xee, 0xda, 0x58, 0xa7, - 0x9f, 0x26, 0x45, 0x0f, 0xc1, 0x64, 0x14, 0x9b, 0x94, 0xca, 0x0b, 0x59, 0x29, 0x3f, 0x7c, 0xe3, - 0xe6, 0x4c, 0x9a, 0x65, 0x66, 0xb8, 0x82, 0x4e, 0xc2, 0x91, 0x66, 0xbc, 0xa5, 0xd5, 0xc5, 0x6c, - 0x22, 0x3f, 0x72, 0xe3, 0xe6, 0x4c, 0xc6, 0x4f, 0xe1, 0x90, 0x0c, 0x28, 0x8c, 0xc9, 0xf9, 0x25, - 0xf3, 0x70, 0xe3, 0xe6, 0xcc, 0x00, 0x33, 0x61, 0x3e, 0xf5, 0x81, 0xcf, 0x4c, 0xf5, 0x95, 0xde, - 0xda, 0x76, 0x73, 0xfc, 0xa1, 0x2e, 0xd6, 0xe3, 0x7e, 0xe3, 0xef, 0x85, 0xdf, 0x3a, 0x03, 0x72, - 0x9b, 0xbd, 0x70, 0xf6, 0xff, 0xb6, 0x3a, 0xef, 0x84, 0x1f, 0xe0, 0x9f, 0x79, 0xb5, 0xbb, 0x55, - 0xd7, 0xe9, 0x69, 0x50, 0xbe, 0xa7, 0x7d, 0x7a, 0xf9, 0x3a, 0x1c, 0x7d, 0x9e, 0xb4, 0x1d, 0xc4, - 0x77, 0xf1, 0x6f, 0xc1, 0x8e, 0xfa, 0xdb, 0x52, 0x12, 0xff, 0x97, 0x42, 0xac, 0xab, 0x2f, 0x00, - 0x04, 0xf2, 0xf1, 0xc8, 0xf6, 0x50, 0xa1, 0xed, 0x7f, 0x1b, 0x2b, 0x84, 0xfe, 0xd5, 0x98, 0x12, - 0xa2, 0x94, 0x7f, 0x59, 0x82, 0x63, 0x4d, 0x4d, 0xf3, 0x60, 0xb0, 0xd8, 0xe2, 0x02, 0x60, 0xcf, - 0x7b, 0xe2, 0xe1, 0xcb, 0x80, 0x8b, 0x2d, 0x84, 0x7d, 0xb8, 0xab, 0xb0, 0x4c, 0x8a, 0x88, 0xb4, - 0x6f, 0x81, 0x23, 0x51, 0x61, 0x85, 0x99, 0x1e, 0x84, 0xd1, 0xe8, 0x92, 0x86, 0x9b, 0x6b, 0x24, - 0xb2, 0xa8, 0x91, 0xd5, 0xb8, 0x9d, 0x7d, 0x5d, 0xcb, 0x90, 0xf1, 0x51, 0x79, 0xd4, 0xeb, 0x59, - 0xd5, 0x80, 0x52, 0x7e, 0x55, 0x82, 0x99, 0x68, 0x0b, 0xc1, 0xe4, 0xe4, 0x1e, 0x4c, 0xd8, 0x3b, - 0xd6, 0xc5, 0xaf, 0x4b, 0x70, 0x5f, 0x07, 0x99, 0xb8, 0x01, 0x5e, 0x86, 0xc9, 0xd0, 0x14, 0x26, - 0x1e, 0xf5, 0x89, 0x6e, 0x3f, 0xd5, 0x7d, 0xee, 0xf5, 0xe3, 0xf5, 0x3d, 0xc4, 0x28, 0x9f, 0xfb, - 0xc3, 0xe9, 0x89, 0xe6, 0x3a, 0x57, 0x99, 0x68, 0x9e, 0x74, 0xee, 0xa0, 0x7f, 0xbc, 0x26, 0xc1, - 0x23, 0x51, 0x55, 0x5b, 0xac, 0x2f, 0xdf, 0xa8, 0x7e, 0xf8, 0x0f, 0x12, 0x9c, 0xea, 0x45, 0x38, - 0xde, 0x21, 0xdb, 0x30, 0x11, 0x24, 0x92, 0xf1, 0xfe, 0x78, 0xf4, 0x00, 0x2b, 0x71, 0xee, 0xa5, - 0xc8, 0xe7, 0x76, 0x17, 0x0c, 0x6f, 0xf3, 0x81, 0x15, 0xee, 0x72, 0xdf, 0xc8, 0xd1, 0x65, 0x88, - 0x30, 0x72, 0x64, 0x21, 0xd2, 0xa2, 0x2f, 0x12, 0x2d, 0xfa, 0xa2, 0x98, 0xfe, 0x80, 0x48, 0xc9, - 0xae, 0xf2, 0xb8, 0xd5, 0x22, 0x79, 0x7c, 0x27, 0x4c, 0xb4, 0x70, 0x65, 0x3e, 0xaa, 0x0f, 0xe0, - 0xc9, 0x0a, 0x6a, 0x76, 0x56, 0x79, 0x1f, 0xa6, 0x69, 0xbb, 0x2d, 0x0c, 0x7d, 0xb7, 0x55, 0xae, - 0xf3, 0xd8, 0xd2, 0xb2, 0x69, 0xae, 0xfb, 0x12, 0x0c, 0xb0, 0x7e, 0xe6, 0xea, 0x1e, 0xc2, 0x51, - 0x38, 0x03, 0xf9, 0xe3, 0x22, 0x96, 0x2d, 0x08, 0xb1, 0x5b, 0x8f, 0xa1, 0x5e, 0x74, 0xbd, 0x43, - 0x63, 0x28, 0x64, 0x8c, 0x6f, 0x8a, 0xa8, 0xd6, 0x5a, 0x3a, 0x6e, 0x0e, 0xfd, 0x8e, 0x45, 0x35, - 0x66, 0x9b, 0xbb, 0x1b, 0xbe, 0x7e, 0x51, 0x84, 0x2f, 0x5f, 0xa7, 0x2e, 0xe1, 0xeb, 0x8d, 0x31, - 0xbd, 0x1f, 0xc8, 0xba, 0x88, 0xf9, 0xe7, 0x31, 0x90, 0x7d, 0x5f, 0x82, 0xe3, 0x54, 0xb7, 0xf0, - 0x7a, 0xe4, 0xa0, 0x26, 0x7f, 0x0c, 0x90, 0xeb, 0xe8, 0x6a, 0xcb, 0xd1, 0x9d, 0x75, 0x1d, 0xfd, - 0x4a, 0x64, 0x7e, 0x79, 0x0c, 0x50, 0xc5, 0xf5, 0xe2, 0xd8, 0xec, 0xb8, 0x37, 0x5b, 0x71, 0xbd, - 0x2b, 0x1d, 0x66, 0xa3, 0xd4, 0x1d, 0xe8, 0xce, 0x6f, 0x48, 0x90, 0x6f, 0xa5, 0x32, 0xef, 0x3e, - 0x03, 0x8e, 0x46, 0x56, 0xb7, 0xf1, 0x1e, 0x7c, 0xac, 0x97, 0x15, 0x5d, 0x6c, 0x18, 0x1d, 0x71, - 0xf0, 0xdd, 0xce, 0x03, 0xa6, 0xa3, 0x1e, 0xda, 0x9c, 0x59, 0xbf, 0x61, 0xc3, 0xe7, 0x8b, 0x4d, - 0x71, 0xf5, 0xcf, 0x45, 0xee, 0x7d, 0x1d, 0xa6, 0xda, 0x48, 0x7d, 0xb7, 0xe7, 0xbd, 0xdd, 0xb6, - 0x9d, 0x79, 0xa7, 0xd3, 0xf7, 0xa7, 0xf9, 0x48, 0x88, 0x5e, 0x28, 0x0a, 0xad, 0xc5, 0x5a, 0x5d, - 0x71, 0x96, 0x5f, 0x80, 0x7b, 0x5a, 0x52, 0x71, 0xd9, 0x8a, 0x90, 0xda, 0x35, 0x5c, 0x8f, 0x8b, - 0xf5, 0x50, 0x3b, 0xb1, 0x62, 0xd4, 0x94, 0x46, 0x46, 0x90, 0xa5, 0xac, 0xd7, 0x2d, 0xab, 0xc6, - 0xc5, 0x90, 0x2f, 0xc3, 0x78, 0x08, 0xc6, 0x1b, 0x39, 0x0b, 0x29, 0xdb, 0xe2, 0x8f, 0xfa, 0x86, - 0x4e, 0x9f, 0x68, 0xd7, 0x08, 0xa1, 0xe1, 0x6a, 0x53, 0x7c, 0x79, 0x12, 0x10, 0x63, 0x46, 0x37, - 0x3f, 0x45, 0x13, 0x1b, 0x30, 0x11, 0x81, 0xf2, 0x46, 0xde, 0x04, 0x03, 0x36, 0x85, 0xf8, 0x57, - 0x47, 0xdb, 0x35, 0x43, 0xb1, 0xfc, 0x67, 0x54, 0xb4, 0x74, 0xfa, 0xbb, 0x47, 0xa0, 0x9f, 0x72, - 0x45, 0x1f, 0x93, 0x00, 0x42, 0x5b, 0x99, 0x85, 0x76, 0x6c, 0x5a, 0xaf, 0x89, 0xf3, 0xb3, 0x3d, - 0xe3, 0xf3, 0x9c, 0xed, 0xd4, 0x7b, 0xff, 0xcd, 0x77, 0x3e, 0x9c, 0x78, 0x00, 0xc9, 0xb3, 0x6d, - 0x56, 0xe3, 0xa1, 0xf1, 0xf2, 0xd9, 0xc8, 0x8b, 0xb2, 0xc7, 0x7b, 0x6b, 0x4a, 0x48, 0x56, 0xe8, - 0x15, 0x9d, 0x0b, 0x76, 0x9e, 0x0a, 0x76, 0x06, 0x3d, 0xd5, 0x5d, 0xb0, 0xd9, 0x77, 0x45, 0x07, - 0xcd, 0xbb, 0xd1, 0xbf, 0x95, 0x60, 0xb2, 0xd5, 0x92, 0x0e, 0x9d, 0xeb, 0x4d, 0x8a, 0xe6, 0x94, - 0x22, 0xff, 0xec, 0x21, 0x28, 0xb9, 0x2a, 0x8b, 0x54, 0x95, 0x39, 0xf4, 0xdc, 0x21, 0x54, 0x99, - 0x0d, 0xcd, 0x3b, 0xe8, 0xff, 0x48, 0x70, 0x6f, 0xc7, 0x15, 0x12, 0x9a, 0xeb, 0x4d, 0xca, 0x0e, - 0xb9, 0x53, 0xbe, 0xf4, 0xa3, 0xb0, 0xe0, 0x1a, 0x3f, 0x4f, 0x35, 0xbe, 0x8c, 0x96, 0x0e, 0xa3, - 0x71, 0x90, 0x11, 0x85, 0x75, 0xff, 0xed, 0xe8, 0xe1, 0x78, 0x67, 0x77, 0x6a, 0x5a, 0x78, 0x74, - 0x19, 0x18, 0xcd, 0x49, 0xad, 0xfc, 0x76, 0xaa, 0x82, 0x82, 0xd6, 0x7f, 0xc4, 0x4e, 0x9b, 0x7d, - 0x57, 0x34, 0xf0, 0xbf, 0x1b, 0xfd, 0x2f, 0xa9, 0xf5, 0x49, 0xf7, 0x33, 0x1d, 0x45, 0x6c, 0xbf, - 0xa8, 0xca, 0x9f, 0x3b, 0x38, 0x21, 0x57, 0xb2, 0x4e, 0x95, 0xac, 0x22, 0x7c, 0xa7, 0x95, 0x6c, - 0xd9, 0x89, 0xe8, 0x6b, 0x12, 0x4c, 0xb6, 0x5a, 0x93, 0x74, 0x19, 0x96, 0x1d, 0x16, 0x59, 0x5d, - 0x86, 0x65, 0xa7, 0x05, 0x90, 0xfc, 0x26, 0xaa, 0xfc, 0x59, 0xf4, 0x74, 0x3b, 0xe5, 0x3b, 0xf6, - 0x22, 0x19, 0x8b, 0x1d, 0x93, 0xfc, 0x2e, 0x63, 0xb1, 0x97, 0x75, 0x4c, 0x97, 0xb1, 0xd8, 0xd3, - 0x1a, 0xa3, 0xfb, 0x58, 0xf4, 0x35, 0xeb, 0xb1, 0x1b, 0x5d, 0xf4, 0x15, 0x09, 0x46, 0x22, 0x19, - 0x31, 0x7a, 0xb2, 0xa3, 0xa0, 0xad, 0x16, 0x0c, 0xf9, 0xd3, 0x07, 0x21, 0xe1, 0xba, 0x2c, 0x51, - 0x5d, 0xe6, 0xd1, 0xdc, 0x61, 0x74, 0x71, 0x22, 0x12, 0x7f, 0x43, 0x82, 0x89, 0x16, 0x59, 0x66, - 0x97, 0x51, 0xd8, 0x3e, 0x69, 0xce, 0x9f, 0x3b, 0x38, 0x21, 0xd7, 0xea, 0x02, 0xd5, 0xea, 0xad, - 0xe8, 0x2d, 0x87, 0xd1, 0x2a, 0x34, 0x3f, 0xdf, 0x0a, 0x0e, 0x0c, 0x43, 0xed, 0xa0, 0xb3, 0x07, - 0x14, 0x4c, 0x28, 0xf4, 0xcc, 0x81, 0xe9, 0xb8, 0x3e, 0x6f, 0xa3, 0xfa, 0x3c, 0x8f, 0xd6, 0x7e, - 0x34, 0x7d, 0x9a, 0xa7, 0xf5, 0x2f, 0x34, 0x5f, 0x68, 0xef, 0xec, 0x45, 0x2d, 0x93, 0xd5, 0xfc, - 0x53, 0x07, 0xa2, 0xe1, 0x4a, 0x9d, 0xa3, 0x4a, 0x9d, 0x46, 0x4f, 0xb4, 0x53, 0x2a, 0x74, 0x2a, - 0x6c, 0x98, 0x3b, 0xd6, 0xec, 0xbb, 0x58, 0x0a, 0xfc, 0x6e, 0xf4, 0xb3, 0x12, 0x3f, 0x8f, 0x3b, - 0xd9, 0xb1, 0xdd, 0x50, 0x1e, 0x9b, 0x7f, 0xa4, 0x07, 0x4c, 0x2e, 0xd7, 0x03, 0x54, 0xae, 0x29, - 0x74, 0xa2, 0x9d, 0x5c, 0x24, 0x97, 0x45, 0x1f, 0x94, 0xfc, 0x43, 0xfc, 0x53, 0x9d, 0x79, 0x87, - 0x93, 0xdd, 0xfc, 0xa3, 0x3d, 0xe1, 0x72, 0x49, 0x1e, 0xa2, 0x92, 0xcc, 0xa0, 0xa9, 0xb6, 0x92, - 0xb0, 0xd4, 0xf7, 0xce, 0x1d, 0x70, 0xdd, 0x38, 0x06, 0xd3, 0x6d, 0xda, 0xf2, 0xae, 0x77, 0x39, - 0xdd, 0xea, 0xf0, 0xa2, 0xa3, 0xeb, 0x8b, 0x8d, 0x36, 0x6f, 0x44, 0x0e, 0xff, 0x8e, 0xa3, 0xb7, - 0xa3, 0xb0, 0x7f, 0x9d, 0x02, 0xb4, 0xe2, 0x56, 0xe7, 0x1d, 0xcc, 0xfe, 0xfd, 0x15, 0x1f, 0xdf, - 0xb1, 0x0b, 0xca, 0xd2, 0x8f, 0x74, 0x41, 0x79, 0x25, 0x72, 0xe5, 0x37, 0x71, 0xb0, 0xa7, 0x05, - 0x3d, 0xdf, 0xfb, 0x4d, 0xfe, 0x98, 0xee, 0xfd, 0xb6, 0xbe, 0x0c, 0x94, 0xba, 0x73, 0xb7, 0x07, - 0xfb, 0x0f, 0x75, 0x7b, 0xf0, 0x02, 0x0c, 0xf0, 0x4b, 0xfd, 0x03, 0x1d, 0x2e, 0xf5, 0xe7, 0xda, - 0xde, 0xdc, 0xe7, 0xd4, 0xe8, 0x8c, 0xf8, 0xa4, 0xdf, 0x60, 0x6f, 0xd7, 0x37, 0xf8, 0x37, 0xff, - 0x82, 0xed, 0x83, 0x13, 0x90, 0x6f, 0x76, 0x28, 0x7f, 0x40, 0x7f, 0x24, 0x09, 0xd9, 0x15, 0xb7, - 0x5a, 0xae, 0x18, 0xde, 0x5d, 0xf2, 0xb6, 0xe7, 0xda, 0xdf, 0xc8, 0x44, 0xb7, 0x6f, 0x4d, 0x8f, - 0x32, 0x9b, 0x76, 0xb0, 0xa4, 0x05, 0x63, 0xb1, 0xf7, 0x30, 0xdc, 0xb7, 0x2e, 0x1c, 0xee, 0x61, - 0x4e, 0x8c, 0x99, 0x4c, 0xaf, 0xcf, 0x85, 0x7c, 0x1c, 0xbd, 0xdc, 0xda, 0xa1, 0x99, 0x4b, 0x5d, - 0xba, 0xbb, 0x97, 0xd8, 0x83, 0x7e, 0xcb, 0x43, 0x2e, 0xde, 0x31, 0x7e, 0xaf, 0xfd, 0xb1, 0x04, - 0x43, 0x2b, 0xae, 0x48, 0x05, 0xf1, 0x4f, 0xe8, 0x05, 0xda, 0x67, 0xfc, 0xef, 0xb1, 0x25, 0x7b, - 0xf3, 0x5d, 0xf1, 0x8d, 0xb6, 0xc0, 0x08, 0x47, 0x60, 0x22, 0xa4, 0xa7, 0xaf, 0xff, 0xef, 0x26, - 0x68, 0x94, 0x2c, 0xe1, 0xaa, 0x61, 0xfa, 0x59, 0x24, 0xfe, 0x8b, 0x7a, 0x2d, 0x30, 0xb0, 0x73, - 0xea, 0xb0, 0x76, 0xde, 0xa3, 0x41, 0x22, 0x66, 0x4f, 0x7f, 0xe3, 0x6b, 0xa5, 0xf9, 0xe2, 0xaa, - 0x74, 0x80, 0x57, 0xe2, 0xb1, 0xeb, 0xa9, 0xf2, 0xeb, 0x12, 0x8c, 0xac, 0xb8, 0xd5, 0x2d, 0xb3, - 0xf2, 0xff, 0xbd, 0xff, 0xee, 0xc0, 0x91, 0x88, 0xa6, 0x77, 0xc9, 0xa4, 0xa7, 0x5f, 0x4b, 0x41, - 0x72, 0xc5, 0xad, 0xa2, 0x97, 0x60, 0x2c, 0x9e, 0x3a, 0xb4, 0xcd, 0x05, 0x9b, 0x67, 0x85, 0xf6, - 0xeb, 0xb5, 0xf6, 0x33, 0x08, 0xda, 0x83, 0x91, 0xe8, 0xec, 0x71, 0xb2, 0x03, 0x93, 0x08, 0x66, - 0xfe, 0x89, 0x5e, 0x31, 0xfd, 0xc6, 0x7e, 0x0a, 0xd2, 0x7e, 0xd0, 0xbb, 0xbf, 0x03, 0xb5, 0x40, - 0x6a, 0x9f, 0xdd, 0xb6, 0x08, 0x2b, 0xc4, 0x7a, 0xf1, 0x90, 0xd2, 0xc9, 0x7a, 0x31, 0xdc, 0x8e, - 0xd6, 0x6b, 0x37, 0xb4, 0xb6, 0x01, 0x42, 0xe3, 0xe0, 0xc1, 0x0e, 0x1c, 0x02, 0xb4, 0xfc, 0xe3, - 0x3d, 0xa1, 0xf9, 0x87, 0x4e, 0x77, 0x2c, 0x19, 0xff, 0x7f, 0x01, 0x00, 0x00, 0xff, 0xff, 0x55, - 0x4d, 0x55, 0xa2, 0xff, 0x91, 0x00, 0x00, + 0x71, 0x18, 0x67, 0x3f, 0x80, 0xdd, 0xc6, 0xd7, 0xe2, 0x01, 0x24, 0x97, 0x7b, 0x3c, 0x00, 0x37, + 0xf7, 0xc5, 0xe3, 0xdd, 0x01, 0x77, 0x3c, 0x92, 0x47, 0x2e, 0x25, 0x9d, 0xb0, 0xc0, 0x12, 0x04, + 0x89, 0xaf, 0x1b, 0x00, 0x94, 0x4e, 0xb2, 0x3d, 0x35, 0x98, 0x7d, 0x58, 0xcc, 0x61, 0x77, 0x66, + 0x6e, 0x66, 0x96, 0x24, 0x4e, 0x91, 0xea, 0x2c, 0x25, 0x8a, 0x44, 0x57, 0x12, 0x9d, 0x95, 0x8a, + 0xa4, 0x93, 0xa8, 0x48, 0x96, 0x13, 0x39, 0xb2, 0x93, 0xd8, 0x92, 0xac, 0xc4, 0x49, 0xaa, 0x22, + 0xa5, 0xca, 0xb6, 0xa4, 0x2a, 0x3b, 0x52, 0x25, 0x95, 0x38, 0xae, 0x98, 0x76, 0x24, 0x95, 0x73, + 0x51, 0x94, 0x44, 0xa1, 0x65, 0xe7, 0x43, 0x7f, 0x52, 0xef, 0x6b, 0x3e, 0xf6, 0x6b, 0x16, 0x10, + 0xa9, 0x93, 0x63, 0xff, 0xc2, 0xbe, 0x7e, 0xdd, 0xfd, 0xba, 0xfb, 0x75, 0xf7, 0xeb, 0xf7, 0xe6, + 0xcd, 0x00, 0xfe, 0xe4, 0x02, 0x4c, 0x55, 0x2d, 0xab, 0x5a, 0xc3, 0x33, 0xb6, 0x63, 0x79, 0xd6, + 0x56, 0x63, 0x7b, 0xa6, 0x82, 0x5d, 0xdd, 0x31, 0x6c, 0xcf, 0x72, 0xa6, 0x29, 0x0c, 0x8d, 0x30, + 0x8c, 0x69, 0x81, 0x21, 0x2f, 0xc3, 0xe8, 0x45, 0xa3, 0x86, 0xe7, 0x7d, 0xc4, 0x75, 0xec, 0xa1, + 0x73, 0x90, 0xda, 0x36, 0x6a, 0x38, 0x2f, 0x4d, 0x25, 0x4f, 0x0c, 0x9c, 0x7a, 0x68, 0xba, 0x89, + 0x68, 0x3a, 0x4a, 0xb1, 0x46, 0xc0, 0x0a, 0xa5, 0x90, 0xbf, 0x93, 0x82, 0xb1, 0x36, 0xbd, 0x08, + 0x41, 0xca, 0xd4, 0xea, 0x84, 0xa3, 0x74, 0x22, 0xab, 0xd0, 0xdf, 0x28, 0x0f, 0xfd, 0xb6, 0xa6, + 0xef, 0x6a, 0x55, 0x9c, 0x4f, 0x50, 0xb0, 0x68, 0xa2, 0x09, 0x80, 0x0a, 0xb6, 0xb1, 0x59, 0xc1, + 0xa6, 0xbe, 0x97, 0x4f, 0x4e, 0x25, 0x4f, 0x64, 0x95, 0x10, 0x04, 0x3d, 0x0e, 0xa3, 0x76, 0x63, + 0xab, 0x66, 0xe8, 0x6a, 0x08, 0x0d, 0xa6, 0x92, 0x27, 0xd2, 0x4a, 0x8e, 0x75, 0xcc, 0x07, 0xc8, + 0x8f, 0xc2, 0xc8, 0x75, 0xac, 0xed, 0x86, 0x51, 0x07, 0x28, 0xea, 0x30, 0x01, 0x87, 0x10, 0xe7, + 0x60, 0xb0, 0x8e, 0x5d, 0x57, 0xab, 0x62, 0xd5, 0xdb, 0xb3, 0x71, 0x3e, 0x45, 0xb5, 0x9f, 0x6a, + 0xd1, 0xbe, 0x59, 0xf3, 0x01, 0x4e, 0xb5, 0xb1, 0x67, 0x63, 0x34, 0x0b, 0x59, 0x6c, 0x36, 0xea, + 0x8c, 0x43, 0xba, 0x83, 0xfd, 0xca, 0x66, 0xa3, 0xde, 0xcc, 0x25, 0x43, 0xc8, 0x38, 0x8b, 0x7e, + 0x17, 0x3b, 0xd7, 0x0c, 0x1d, 0xe7, 0xfb, 0x28, 0x83, 0x47, 0x5b, 0x18, 0xac, 0xb3, 0xfe, 0x66, + 0x1e, 0x82, 0x0e, 0xcd, 0x41, 0x16, 0xdf, 0xf0, 0xb0, 0xe9, 0x1a, 0x96, 0x99, 0xef, 0xa7, 0x4c, + 0x1e, 0x6e, 0x33, 0x8b, 0xb8, 0x56, 0x69, 0x66, 0x11, 0xd0, 0xa1, 0xb3, 0xd0, 0x6f, 0xd9, 0x9e, + 0x61, 0x99, 0x6e, 0x3e, 0x33, 0x25, 0x9d, 0x18, 0x38, 0x75, 0xbc, 0xad, 0x23, 0xac, 0x32, 0x1c, + 0x45, 0x20, 0xa3, 0x45, 0xc8, 0xb9, 0x56, 0xc3, 0xd1, 0xb1, 0xaa, 0x5b, 0x15, 0xac, 0x1a, 0xe6, + 0xb6, 0x95, 0xcf, 0x52, 0x06, 0x93, 0xad, 0x8a, 0x50, 0xc4, 0x39, 0xab, 0x82, 0x17, 0xcd, 0x6d, + 0x4b, 0x19, 0x76, 0x23, 0x6d, 0x74, 0x04, 0xfa, 0xdc, 0x3d, 0xd3, 0xd3, 0x6e, 0xe4, 0x07, 0xa9, + 0x87, 0xf0, 0x96, 0xfc, 0x1b, 0x7d, 0x30, 0xd2, 0x8b, 0x8b, 0x5d, 0x80, 0xf4, 0x36, 0xd1, 0x32, + 0x9f, 0xd8, 0x8f, 0x0d, 0x18, 0x4d, 0xd4, 0x88, 0x7d, 0x07, 0x34, 0xe2, 0x2c, 0x0c, 0x98, 0xd8, + 0xf5, 0x70, 0x85, 0x79, 0x44, 0xb2, 0x47, 0x9f, 0x02, 0x46, 0xd4, 0xea, 0x52, 0xa9, 0x03, 0xb9, + 0xd4, 0xdb, 0x61, 0xc4, 0x17, 0x49, 0x75, 0x34, 0xb3, 0x2a, 0x7c, 0x73, 0x26, 0x4e, 0x92, 0xe9, + 0xb2, 0xa0, 0x53, 0x08, 0x99, 0x32, 0x8c, 0x23, 0x6d, 0x34, 0x0f, 0x60, 0x99, 0xd8, 0xda, 0x56, + 0x2b, 0x58, 0xaf, 0xe5, 0x33, 0x1d, 0xac, 0xb4, 0x4a, 0x50, 0x5a, 0xac, 0x64, 0x31, 0xa8, 0x5e, + 0x43, 0xe7, 0x03, 0x57, 0xeb, 0xef, 0xe0, 0x29, 0xcb, 0x2c, 0xc8, 0x5a, 0xbc, 0x6d, 0x13, 0x86, + 0x1d, 0x4c, 0xfc, 0x1e, 0x57, 0xb8, 0x66, 0x59, 0x2a, 0xc4, 0x74, 0xac, 0x66, 0x0a, 0x27, 0x63, + 0x8a, 0x0d, 0x39, 0xe1, 0x26, 0x7a, 0x10, 0x7c, 0x80, 0x4a, 0xdd, 0x0a, 0x68, 0x16, 0x1a, 0x14, + 0xc0, 0x15, 0xad, 0x8e, 0x0b, 0x2f, 0xc3, 0x70, 0xd4, 0x3c, 0x68, 0x1c, 0xd2, 0xae, 0xa7, 0x39, + 0x1e, 0xf5, 0xc2, 0xb4, 0xc2, 0x1a, 0x28, 0x07, 0x49, 0x6c, 0x56, 0x68, 0x96, 0x4b, 0x2b, 0xe4, + 0x27, 0x7a, 0x6b, 0xa0, 0x70, 0x92, 0x2a, 0xfc, 0x48, 0xeb, 0x8c, 0x46, 0x38, 0x37, 0xeb, 0x5d, + 0x78, 0x16, 0x86, 0x22, 0x0a, 0xf4, 0x3a, 0xb4, 0xfc, 0x57, 0xe0, 0x70, 0x5b, 0xd6, 0xe8, 0xed, + 0x30, 0xde, 0x30, 0x0d, 0xd3, 0xc3, 0x8e, 0xed, 0x60, 0xe2, 0xb1, 0x6c, 0xa8, 0xfc, 0x7f, 0xee, + 0xef, 0xe0, 0x73, 0x9b, 0x61, 0x6c, 0xc6, 0x45, 0x19, 0x6b, 0xb4, 0x02, 0x4f, 0x66, 0x33, 0xaf, + 0xf7, 0xe7, 0x5e, 0x79, 0xe5, 0x95, 0x57, 0x12, 0xf2, 0x57, 0xfa, 0x60, 0xbc, 0x5d, 0xcc, 0xb4, + 0x0d, 0xdf, 0x23, 0xd0, 0x67, 0x36, 0xea, 0x5b, 0xd8, 0xa1, 0x46, 0x4a, 0x2b, 0xbc, 0x85, 0x66, + 0x21, 0x5d, 0xd3, 0xb6, 0x70, 0x2d, 0x9f, 0x9a, 0x92, 0x4e, 0x0c, 0x9f, 0x7a, 0xbc, 0xa7, 0xa8, + 0x9c, 0x5e, 0x22, 0x24, 0x0a, 0xa3, 0x44, 0x6f, 0x81, 0x14, 0x4f, 0xd1, 0x84, 0xc3, 0xc9, 0xde, + 0x38, 0x90, 0x58, 0x52, 0x28, 0x1d, 0xba, 0x0f, 0xb2, 0xe4, 0x2f, 0xf3, 0x8d, 0x3e, 0x2a, 0x73, + 0x86, 0x00, 0x88, 0x5f, 0xa0, 0x02, 0x64, 0x68, 0x98, 0x54, 0xb0, 0x58, 0xda, 0xfc, 0x36, 0x71, + 0xac, 0x0a, 0xde, 0xd6, 0x1a, 0x35, 0x4f, 0xbd, 0xa6, 0xd5, 0x1a, 0x98, 0x3a, 0x7c, 0x56, 0x19, + 0xe4, 0xc0, 0xab, 0x04, 0x86, 0x26, 0x61, 0x80, 0x45, 0x95, 0x61, 0x56, 0xf0, 0x0d, 0x9a, 0x3d, + 0xd3, 0x0a, 0x0b, 0xb4, 0x45, 0x02, 0x21, 0xc3, 0xbf, 0xe8, 0x5a, 0xa6, 0x70, 0x4d, 0x3a, 0x04, + 0x01, 0xd0, 0xe1, 0x9f, 0x6d, 0x4e, 0xdc, 0xf7, 0xb7, 0x57, 0xaf, 0x25, 0x96, 0x1e, 0x85, 0x11, + 0x8a, 0xf1, 0x0c, 0x9f, 0x7a, 0xad, 0x96, 0x1f, 0x9d, 0x92, 0x4e, 0x64, 0x94, 0x61, 0x06, 0x5e, + 0xe5, 0x50, 0xf9, 0x4b, 0x09, 0x48, 0xd1, 0xc4, 0x32, 0x02, 0x03, 0x1b, 0x2f, 0xac, 0x95, 0xd5, + 0xf9, 0xd5, 0xcd, 0xd2, 0x52, 0x39, 0x27, 0xa1, 0x61, 0x00, 0x0a, 0xb8, 0xb8, 0xb4, 0x3a, 0xbb, + 0x91, 0x4b, 0xf8, 0xed, 0xc5, 0x95, 0x8d, 0xb3, 0xa7, 0x73, 0x49, 0x9f, 0x60, 0x93, 0x01, 0x52, + 0x61, 0x84, 0x67, 0x4e, 0xe5, 0xd2, 0x28, 0x07, 0x83, 0x8c, 0xc1, 0xe2, 0xdb, 0xcb, 0xf3, 0x67, + 0x4f, 0xe7, 0xfa, 0xa2, 0x90, 0x67, 0x4e, 0xe5, 0xfa, 0xd1, 0x10, 0x64, 0x29, 0xa4, 0xb4, 0xba, + 0xba, 0x94, 0xcb, 0xf8, 0x3c, 0xd7, 0x37, 0x94, 0xc5, 0x95, 0x85, 0x5c, 0xd6, 0xe7, 0xb9, 0xa0, + 0xac, 0x6e, 0xae, 0xe5, 0xc0, 0xe7, 0xb0, 0x5c, 0x5e, 0x5f, 0x9f, 0x5d, 0x28, 0xe7, 0x06, 0x7c, + 0x8c, 0xd2, 0x0b, 0x1b, 0xe5, 0xf5, 0xdc, 0x60, 0x44, 0xac, 0x67, 0x4e, 0xe5, 0x86, 0xfc, 0x21, + 0xca, 0x2b, 0x9b, 0xcb, 0xb9, 0x61, 0x34, 0x0a, 0x43, 0x6c, 0x08, 0x21, 0xc4, 0x48, 0x13, 0xe8, + 0xec, 0xe9, 0x5c, 0x2e, 0x10, 0x84, 0x71, 0x19, 0x8d, 0x00, 0xce, 0x9e, 0xce, 0x21, 0x79, 0x0e, + 0xd2, 0xd4, 0x0d, 0x11, 0x82, 0xe1, 0xa5, 0xd9, 0x52, 0x79, 0x49, 0x5d, 0x5d, 0xdb, 0x58, 0x5c, + 0x5d, 0x99, 0x5d, 0xca, 0x49, 0x01, 0x4c, 0x29, 0x3f, 0xbf, 0xb9, 0xa8, 0x94, 0xe7, 0x73, 0x89, + 0x30, 0x6c, 0xad, 0x3c, 0xbb, 0x51, 0x9e, 0xcf, 0x25, 0x65, 0x1d, 0xc6, 0xdb, 0x25, 0xd4, 0xb6, + 0x21, 0x14, 0xf2, 0x85, 0x44, 0x07, 0x5f, 0xa0, 0xbc, 0x9a, 0x7d, 0x41, 0xfe, 0x76, 0x02, 0xc6, + 0xda, 0x2c, 0x2a, 0x6d, 0x07, 0x79, 0x0e, 0xd2, 0xcc, 0x97, 0xd9, 0x32, 0xfb, 0x58, 0xdb, 0xd5, + 0x89, 0x7a, 0x76, 0xcb, 0x52, 0x4b, 0xe9, 0xc2, 0xa5, 0x46, 0xb2, 0x43, 0xa9, 0x41, 0x58, 0xb4, + 0x38, 0xec, 0x4f, 0xb7, 0x24, 0x7f, 0xb6, 0x3e, 0x9e, 0xed, 0x65, 0x7d, 0xa4, 0xb0, 0xfd, 0x2d, + 0x02, 0xe9, 0x36, 0x8b, 0xc0, 0x05, 0x18, 0x6d, 0x61, 0xd4, 0x73, 0x32, 0x7e, 0x9f, 0x04, 0xf9, + 0x4e, 0xc6, 0x89, 0x49, 0x89, 0x89, 0x48, 0x4a, 0xbc, 0xd0, 0x6c, 0xc1, 0x07, 0x3a, 0x4f, 0x42, + 0xcb, 0x5c, 0x7f, 0x56, 0x82, 0x23, 0xed, 0x4b, 0xca, 0xb6, 0x32, 0xbc, 0x05, 0xfa, 0xea, 0xd8, + 0xdb, 0xb1, 0x44, 0x59, 0xf5, 0x48, 0x9b, 0xc5, 0x9a, 0x74, 0x37, 0x4f, 0x36, 0xa7, 0x0a, 0xaf, + 0xf6, 0xc9, 0x4e, 0x75, 0x21, 0x93, 0xa6, 0x45, 0xd2, 0x0f, 0x26, 0xe0, 0x70, 0x5b, 0xe6, 0x6d, + 0x05, 0xbd, 0x1f, 0xc0, 0x30, 0xed, 0x86, 0xc7, 0x4a, 0x27, 0x96, 0x89, 0xb3, 0x14, 0x42, 0x93, + 0x17, 0xc9, 0xb2, 0x0d, 0xcf, 0xef, 0x4f, 0xd2, 0x7e, 0x60, 0x20, 0x8a, 0x70, 0x2e, 0x10, 0x34, + 0x45, 0x05, 0x9d, 0xe8, 0xa0, 0x69, 0x8b, 0x63, 0x3e, 0x05, 0x39, 0xbd, 0x66, 0x60, 0xd3, 0x53, + 0x5d, 0xcf, 0xc1, 0x5a, 0xdd, 0x30, 0xab, 0x74, 0xa9, 0xc9, 0x14, 0xd3, 0xdb, 0x5a, 0xcd, 0xc5, + 0xca, 0x08, 0xeb, 0x5e, 0x17, 0xbd, 0x84, 0x82, 0x3a, 0x90, 0x13, 0xa2, 0xe8, 0x8b, 0x50, 0xb0, + 0x6e, 0x9f, 0x42, 0x7e, 0x35, 0x0b, 0x03, 0xa1, 0x02, 0x1c, 0x3d, 0x00, 0x83, 0x2f, 0x6a, 0xd7, + 0x34, 0x55, 0x6c, 0xaa, 0x98, 0x25, 0x06, 0x08, 0x6c, 0x8d, 0x6f, 0xac, 0x9e, 0x82, 0x71, 0x8a, + 0x62, 0x35, 0x3c, 0xec, 0xa8, 0x7a, 0x4d, 0x73, 0x5d, 0x6a, 0xb4, 0x0c, 0x45, 0x45, 0xa4, 0x6f, + 0x95, 0x74, 0xcd, 0x89, 0x1e, 0x74, 0x06, 0xc6, 0x28, 0x45, 0xbd, 0x51, 0xf3, 0x0c, 0xbb, 0x86, + 0x55, 0xb2, 0xcd, 0x73, 0xe9, 0x92, 0xe3, 0x4b, 0x36, 0x4a, 0x30, 0x96, 0x39, 0x02, 0x91, 0xc8, + 0x45, 0xf3, 0x70, 0x3f, 0x25, 0xab, 0x62, 0x13, 0x3b, 0x9a, 0x87, 0x55, 0xfc, 0x52, 0x43, 0xab, + 0xb9, 0xaa, 0x66, 0x56, 0xd4, 0x1d, 0xcd, 0xdd, 0xc9, 0x8f, 0x13, 0x06, 0xa5, 0x44, 0x5e, 0x52, + 0x8e, 0x11, 0xc4, 0x05, 0x8e, 0x57, 0xa6, 0x68, 0xb3, 0x66, 0xe5, 0x92, 0xe6, 0xee, 0xa0, 0x22, + 0x1c, 0xa1, 0x5c, 0x5c, 0xcf, 0x31, 0xcc, 0xaa, 0xaa, 0xef, 0x60, 0x7d, 0x57, 0x6d, 0x78, 0xdb, + 0xe7, 0xf2, 0xf7, 0x85, 0xc7, 0xa7, 0x12, 0xae, 0x53, 0x9c, 0x39, 0x82, 0xb2, 0xe9, 0x6d, 0x9f, + 0x43, 0xeb, 0x30, 0x48, 0x26, 0xa3, 0x6e, 0xbc, 0x8c, 0xd5, 0x6d, 0xcb, 0xa1, 0x6b, 0xe8, 0x70, + 0x9b, 0xd4, 0x14, 0xb2, 0xe0, 0xf4, 0x2a, 0x27, 0x58, 0xb6, 0x2a, 0xb8, 0x98, 0x5e, 0x5f, 0x2b, + 0x97, 0xe7, 0x95, 0x01, 0xc1, 0xe5, 0xa2, 0xe5, 0x10, 0x87, 0xaa, 0x5a, 0xbe, 0x81, 0x07, 0x98, + 0x43, 0x55, 0x2d, 0x61, 0xde, 0x33, 0x30, 0xa6, 0xeb, 0x4c, 0x67, 0x43, 0x57, 0xf9, 0x66, 0xcc, + 0xcd, 0xe7, 0x22, 0xc6, 0xd2, 0xf5, 0x05, 0x86, 0xc0, 0x7d, 0xdc, 0x45, 0xe7, 0xe1, 0x70, 0x60, + 0xac, 0x30, 0xe1, 0x68, 0x8b, 0x96, 0xcd, 0xa4, 0x67, 0x60, 0xcc, 0xde, 0x6b, 0x25, 0x44, 0x91, + 0x11, 0xed, 0xbd, 0x66, 0xb2, 0x67, 0x61, 0xdc, 0xde, 0xb1, 0x5b, 0xe9, 0x4e, 0x86, 0xe9, 0x90, + 0xbd, 0x63, 0x37, 0x13, 0x3e, 0x4c, 0x77, 0xe6, 0x0e, 0xd6, 0x35, 0x0f, 0x57, 0xf2, 0x47, 0xc3, + 0xe8, 0xa1, 0x0e, 0x34, 0x0d, 0x39, 0x5d, 0x57, 0xb1, 0xa9, 0x6d, 0xd5, 0xb0, 0xaa, 0x39, 0xd8, + 0xd4, 0xdc, 0xfc, 0x24, 0x45, 0x4e, 0x79, 0x4e, 0x03, 0x2b, 0xc3, 0xba, 0x5e, 0xa6, 0x9d, 0xb3, + 0xb4, 0x0f, 0x9d, 0x84, 0x51, 0x6b, 0xeb, 0x45, 0x9d, 0x79, 0xa4, 0x6a, 0x3b, 0x78, 0xdb, 0xb8, + 0x91, 0x7f, 0x88, 0x9a, 0x77, 0x84, 0x74, 0x50, 0x7f, 0x5c, 0xa3, 0x60, 0xf4, 0x18, 0xe4, 0x74, + 0x77, 0x47, 0x73, 0x6c, 0x9a, 0x92, 0x5d, 0x5b, 0xd3, 0x71, 0xfe, 0x61, 0x86, 0xca, 0xe0, 0x2b, + 0x02, 0x4c, 0x22, 0xc2, 0xbd, 0x6e, 0x6c, 0x7b, 0x82, 0xe3, 0xa3, 0x2c, 0x22, 0x28, 0x8c, 0x73, + 0x3b, 0x01, 0x39, 0x62, 0x89, 0xc8, 0xc0, 0x27, 0x28, 0xda, 0xb0, 0xbd, 0x63, 0x87, 0xc7, 0x7d, + 0x10, 0x86, 0x08, 0x66, 0x30, 0xe8, 0x63, 0xac, 0x70, 0xb3, 0x77, 0x42, 0x23, 0x9e, 0x86, 0x23, + 0x04, 0xa9, 0x8e, 0x3d, 0xad, 0xa2, 0x79, 0x5a, 0x08, 0xfb, 0x09, 0x8a, 0x4d, 0xcc, 0xbe, 0xcc, + 0x3b, 0x23, 0x72, 0x3a, 0x8d, 0xad, 0x3d, 0xdf, 0xb1, 0x9e, 0x64, 0x72, 0x12, 0x98, 0x70, 0xad, + 0x7b, 0x56, 0x9c, 0xcb, 0x45, 0x18, 0x0c, 0xfb, 0x3d, 0xca, 0x02, 0xf3, 0xfc, 0x9c, 0x44, 0x8a, + 0xa0, 0xb9, 0xd5, 0x79, 0x52, 0xbe, 0xbc, 0xa3, 0x9c, 0x4b, 0x90, 0x32, 0x6a, 0x69, 0x71, 0xa3, + 0xac, 0x2a, 0x9b, 0x2b, 0x1b, 0x8b, 0xcb, 0xe5, 0x5c, 0x32, 0x54, 0xd8, 0x5f, 0x4e, 0x65, 0x1e, + 0xc9, 0x3d, 0x4a, 0xaa, 0x86, 0xe1, 0xe8, 0x4e, 0x0d, 0xbd, 0x09, 0x8e, 0x8a, 0x63, 0x15, 0x17, + 0x7b, 0xea, 0x75, 0xc3, 0xa1, 0x01, 0x59, 0xd7, 0xd8, 0xe2, 0xe8, 0xfb, 0xcf, 0x38, 0xc7, 0x5a, + 0xc7, 0xde, 0xdb, 0x0c, 0x87, 0x84, 0x5b, 0x5d, 0xf3, 0xd0, 0x12, 0x4c, 0x9a, 0x96, 0xea, 0x7a, + 0x9a, 0x59, 0xd1, 0x9c, 0x8a, 0x1a, 0x1c, 0x68, 0xa9, 0x9a, 0xae, 0x63, 0xd7, 0xb5, 0xd8, 0x42, + 0xe8, 0x73, 0x39, 0x6e, 0x5a, 0xeb, 0x1c, 0x39, 0x58, 0x21, 0x66, 0x39, 0x6a, 0x93, 0xfb, 0x26, + 0x3b, 0xb9, 0xef, 0x7d, 0x90, 0xad, 0x6b, 0xb6, 0x8a, 0x4d, 0xcf, 0xd9, 0xa3, 0xf5, 0x79, 0x46, + 0xc9, 0xd4, 0x35, 0xbb, 0x4c, 0xda, 0x3f, 0x96, 0x6d, 0xd2, 0xe5, 0x54, 0x26, 0x95, 0x4b, 0x5f, + 0x4e, 0x65, 0xd2, 0xb9, 0xbe, 0xcb, 0xa9, 0x4c, 0x5f, 0xae, 0xff, 0x72, 0x2a, 0x93, 0xc9, 0x65, + 0x2f, 0xa7, 0x32, 0xd9, 0x1c, 0xc8, 0x3f, 0x9f, 0x82, 0xc1, 0x70, 0x05, 0x4f, 0x36, 0x44, 0x3a, + 0x5d, 0xc3, 0x24, 0x9a, 0xe5, 0x1e, 0xec, 0x5a, 0xef, 0x4f, 0xcf, 0x91, 0xc5, 0xad, 0xd8, 0xc7, + 0xca, 0x65, 0x85, 0x51, 0x92, 0xc2, 0x82, 0xb8, 0x1f, 0x66, 0xe5, 0x49, 0x46, 0xe1, 0x2d, 0xb4, + 0x00, 0x7d, 0x2f, 0xba, 0x94, 0x77, 0x1f, 0xe5, 0xfd, 0x50, 0x77, 0xde, 0x97, 0xd7, 0x29, 0xf3, + 0xec, 0xe5, 0x75, 0x75, 0x65, 0x55, 0x59, 0x9e, 0x5d, 0x52, 0x38, 0x39, 0x3a, 0x06, 0xa9, 0x9a, + 0xf6, 0xf2, 0x5e, 0x74, 0x19, 0xa4, 0x20, 0x34, 0x0d, 0x23, 0x0d, 0xf3, 0x1a, 0x76, 0x8c, 0x6d, + 0x03, 0x57, 0x54, 0x8a, 0x35, 0x12, 0xc6, 0x1a, 0x0e, 0x7a, 0x97, 0x08, 0x7e, 0x8f, 0xd3, 0x78, + 0x0c, 0x52, 0xd7, 0xb1, 0xb6, 0x1b, 0x5d, 0xac, 0x28, 0xe8, 0x1e, 0x86, 0xd3, 0x0c, 0xa4, 0xa9, + 0x7d, 0x11, 0x00, 0xb7, 0x70, 0xee, 0x10, 0xca, 0x40, 0x6a, 0x6e, 0x55, 0x21, 0x21, 0x95, 0x83, + 0x41, 0x06, 0x55, 0xd7, 0x16, 0xcb, 0x73, 0xe5, 0x5c, 0x42, 0x3e, 0x03, 0x7d, 0xcc, 0x68, 0x24, + 0xdc, 0x7c, 0xb3, 0xe5, 0x0e, 0xf1, 0x26, 0xe7, 0x21, 0x89, 0xde, 0xcd, 0xe5, 0x52, 0x59, 0xc9, + 0x25, 0x5a, 0x9c, 0x45, 0x76, 0x61, 0x30, 0x5c, 0xc9, 0xff, 0x78, 0xb6, 0xf3, 0x5f, 0x96, 0x60, + 0x20, 0x54, 0x99, 0x93, 0x92, 0x4a, 0xab, 0xd5, 0xac, 0xeb, 0xaa, 0x56, 0x33, 0x34, 0x97, 0xbb, + 0x12, 0x50, 0xd0, 0x2c, 0x81, 0xf4, 0x3a, 0x75, 0x3f, 0xa6, 0x20, 0x4b, 0xe7, 0xfa, 0xe4, 0x4f, + 0x4a, 0x90, 0x6b, 0x2e, 0x8d, 0x9b, 0xc4, 0x94, 0xde, 0x48, 0x31, 0xe5, 0x4f, 0x48, 0x30, 0x1c, + 0xad, 0x87, 0x9b, 0xc4, 0x7b, 0xe0, 0x0d, 0x15, 0xef, 0x8f, 0x12, 0x30, 0x14, 0xa9, 0x82, 0x7b, + 0x95, 0xee, 0x25, 0x18, 0x35, 0x2a, 0xb8, 0x6e, 0x5b, 0x1e, 0x36, 0xf5, 0x3d, 0xb5, 0x86, 0xaf, + 0xe1, 0x5a, 0x5e, 0xa6, 0x49, 0x66, 0xa6, 0x7b, 0x9d, 0x3d, 0xbd, 0x18, 0xd0, 0x2d, 0x11, 0xb2, + 0xe2, 0xd8, 0xe2, 0x7c, 0x79, 0x79, 0x6d, 0x75, 0xa3, 0xbc, 0x32, 0xf7, 0x82, 0xba, 0xb9, 0x72, + 0x65, 0x65, 0xf5, 0x6d, 0x2b, 0x4a, 0xce, 0x68, 0x42, 0xbb, 0x87, 0x61, 0xbf, 0x06, 0xb9, 0x66, + 0xa1, 0xd0, 0x51, 0x68, 0x27, 0x56, 0xee, 0x10, 0x1a, 0x83, 0x91, 0x95, 0x55, 0x75, 0x7d, 0x71, + 0xbe, 0xac, 0x96, 0x2f, 0x5e, 0x2c, 0xcf, 0x6d, 0xac, 0xb3, 0x93, 0x13, 0x1f, 0x7b, 0x23, 0x12, + 0xe0, 0xf2, 0x6b, 0x49, 0x18, 0x6b, 0x23, 0x09, 0x9a, 0xe5, 0x7b, 0x1e, 0xb6, 0x0d, 0x7b, 0xb2, + 0x17, 0xe9, 0xa7, 0x49, 0xd5, 0xb1, 0xa6, 0x39, 0x1e, 0xdf, 0x22, 0x3d, 0x06, 0xc4, 0x4a, 0xa6, + 0x47, 0x92, 0xab, 0xc3, 0x4f, 0xa4, 0xd8, 0x46, 0x68, 0x24, 0x80, 0xb3, 0x43, 0xa9, 0x27, 0x00, + 0xd9, 0x96, 0x6b, 0x78, 0xc6, 0x35, 0xac, 0x1a, 0xa6, 0x38, 0xbe, 0x22, 0x1b, 0xa3, 0x94, 0x92, + 0x13, 0x3d, 0x8b, 0xa6, 0xe7, 0x63, 0x9b, 0xb8, 0xaa, 0x35, 0x61, 0x93, 0xe4, 0x9f, 0x54, 0x72, + 0xa2, 0xc7, 0xc7, 0x7e, 0x00, 0x06, 0x2b, 0x56, 0x83, 0x54, 0x8b, 0x0c, 0x8f, 0xac, 0x35, 0x92, + 0x32, 0xc0, 0x60, 0x3e, 0x0a, 0xdf, 0x07, 0x04, 0xe7, 0x66, 0x83, 0xca, 0x00, 0x83, 0x31, 0x94, + 0x47, 0x61, 0x44, 0xab, 0x56, 0x1d, 0xc2, 0x5c, 0x30, 0x62, 0x3b, 0x9b, 0x61, 0x1f, 0x4c, 0x11, + 0x0b, 0x97, 0x21, 0x23, 0xec, 0x40, 0x16, 0x7b, 0x62, 0x09, 0xd5, 0x66, 0xdb, 0xf5, 0xc4, 0x89, + 0xac, 0x92, 0x31, 0x45, 0xe7, 0x03, 0x30, 0x68, 0xb8, 0x6a, 0xf0, 0x18, 0x20, 0x31, 0x95, 0x38, + 0x91, 0x51, 0x06, 0x0c, 0xd7, 0x3f, 0x42, 0x95, 0x3f, 0x9b, 0x80, 0xe1, 0xe8, 0x63, 0x0c, 0x34, + 0x0f, 0x99, 0x9a, 0xa5, 0x6b, 0xd4, 0xb5, 0xd8, 0x33, 0xb4, 0x13, 0x31, 0x4f, 0x3e, 0xa6, 0x97, + 0x38, 0xbe, 0xe2, 0x53, 0x16, 0x7e, 0x57, 0x82, 0x8c, 0x00, 0xa3, 0x23, 0x90, 0xb2, 0x35, 0x6f, + 0x87, 0xb2, 0x4b, 0x97, 0x12, 0x39, 0x49, 0xa1, 0x6d, 0x02, 0x77, 0x6d, 0xcd, 0xa4, 0x2e, 0xc0, + 0xe1, 0xa4, 0x4d, 0xe6, 0xb5, 0x86, 0xb5, 0x0a, 0xdd, 0x36, 0x59, 0xf5, 0x3a, 0x36, 0x3d, 0x57, + 0xcc, 0x2b, 0x87, 0xcf, 0x71, 0x30, 0x7a, 0x1c, 0x46, 0x3d, 0x47, 0x33, 0x6a, 0x11, 0xdc, 0x14, + 0xc5, 0xcd, 0x89, 0x0e, 0x1f, 0xb9, 0x08, 0xc7, 0x04, 0xdf, 0x0a, 0xf6, 0x34, 0x7d, 0x07, 0x57, + 0x02, 0xa2, 0x3e, 0x7a, 0x3c, 0x72, 0x94, 0x23, 0xcc, 0xf3, 0x7e, 0x41, 0x2b, 0x7f, 0x53, 0x82, + 0x51, 0xb1, 0xd1, 0xab, 0xf8, 0xc6, 0x5a, 0x06, 0xd0, 0x4c, 0xd3, 0xf2, 0xc2, 0xe6, 0x6a, 0x75, + 0xe5, 0x16, 0xba, 0xe9, 0x59, 0x9f, 0x48, 0x09, 0x31, 0x28, 0xd4, 0x01, 0x82, 0x9e, 0x8e, 0x66, + 0x9b, 0x84, 0x01, 0xfe, 0x8c, 0x8a, 0x3e, 0xe8, 0x64, 0x47, 0x03, 0xc0, 0x40, 0x64, 0x47, 0x88, + 0xc6, 0x21, 0xbd, 0x85, 0xab, 0x86, 0xc9, 0x4f, 0x9e, 0x59, 0x43, 0x1c, 0xe0, 0xa4, 0xfc, 0x03, + 0x9c, 0xd2, 0x7b, 0x60, 0x4c, 0xb7, 0xea, 0xcd, 0xe2, 0x96, 0x72, 0x4d, 0xc7, 0x13, 0xee, 0x25, + 0xe9, 0x1d, 0x4f, 0x72, 0xa4, 0xaa, 0x55, 0xd3, 0xcc, 0xea, 0xb4, 0xe5, 0x54, 0x83, 0x07, 0xb5, + 0xa4, 0x42, 0x72, 0x43, 0x8f, 0x6b, 0xed, 0xad, 0xff, 0x2d, 0x49, 0xbf, 0x90, 0x48, 0x2e, 0xac, + 0x95, 0x3e, 0x97, 0x28, 0x2c, 0x30, 0xc2, 0x35, 0x61, 0x0c, 0x05, 0x6f, 0xd7, 0xb0, 0x4e, 0x14, + 0x84, 0xef, 0x3e, 0x0e, 0xe3, 0x55, 0xab, 0x6a, 0x51, 0x4e, 0x33, 0xe4, 0x17, 0x7f, 0xd2, 0x9b, + 0xf5, 0xa1, 0x85, 0xd8, 0xc7, 0xc2, 0xc5, 0x15, 0x18, 0xe3, 0xc8, 0x2a, 0x7d, 0xd4, 0xc4, 0x36, + 0x42, 0xa8, 0xeb, 0x29, 0x5c, 0xfe, 0xd7, 0xbe, 0x43, 0x97, 0x6f, 0x65, 0x94, 0x93, 0x92, 0x3e, + 0xb6, 0x57, 0x2a, 0x2a, 0x70, 0x38, 0xc2, 0x8f, 0x05, 0x29, 0x76, 0x62, 0x38, 0xfe, 0x26, 0xe7, + 0x38, 0x16, 0xe2, 0xb8, 0xce, 0x49, 0x8b, 0x73, 0x30, 0xb4, 0x1f, 0x5e, 0xbf, 0xc5, 0x79, 0x0d, + 0xe2, 0x30, 0x93, 0x05, 0x18, 0xa1, 0x4c, 0xf4, 0x86, 0xeb, 0x59, 0x75, 0x9a, 0x01, 0xbb, 0xb3, + 0xf9, 0xed, 0xef, 0xb0, 0xa8, 0x19, 0x26, 0x64, 0x73, 0x3e, 0x55, 0xb1, 0x08, 0xf4, 0xe9, 0x5a, + 0x05, 0xeb, 0xb5, 0x18, 0x0e, 0x5f, 0xe5, 0x82, 0xf8, 0xf8, 0xc5, 0xab, 0x30, 0x4e, 0x7e, 0xd3, + 0x04, 0x15, 0x96, 0x24, 0xfe, 0xc8, 0x2e, 0xff, 0xcd, 0xf7, 0xb1, 0xc0, 0x1c, 0xf3, 0x19, 0x84, + 0x64, 0x0a, 0xcd, 0x62, 0x15, 0x7b, 0x1e, 0x76, 0x5c, 0x55, 0xab, 0xb5, 0x13, 0x2f, 0x74, 0xe6, + 0x91, 0xff, 0xd8, 0xf7, 0xa2, 0xb3, 0xb8, 0xc0, 0x28, 0x67, 0x6b, 0xb5, 0xe2, 0x26, 0x1c, 0x6d, + 0xe3, 0x15, 0x3d, 0xf0, 0x7c, 0x8d, 0xf3, 0x1c, 0x6f, 0xf1, 0x0c, 0xc2, 0x76, 0x0d, 0x04, 0xdc, + 0x9f, 0xcb, 0x1e, 0x78, 0x7e, 0x9c, 0xf3, 0x44, 0x9c, 0x56, 0x4c, 0x29, 0xe1, 0x78, 0x19, 0x46, + 0xaf, 0x61, 0x67, 0xcb, 0x72, 0xf9, 0x39, 0x53, 0x0f, 0xec, 0x3e, 0xc1, 0xd9, 0x8d, 0x70, 0x42, + 0x7a, 0xf0, 0x44, 0x78, 0x9d, 0x87, 0xcc, 0xb6, 0xa6, 0xe3, 0x1e, 0x58, 0xdc, 0xe2, 0x2c, 0xfa, + 0x09, 0x3e, 0x21, 0x9d, 0x85, 0xc1, 0xaa, 0xc5, 0xd7, 0xa8, 0x78, 0xf2, 0x4f, 0x72, 0xf2, 0x01, + 0x41, 0xc3, 0x59, 0xd8, 0x96, 0xdd, 0xa8, 0x91, 0x05, 0x2c, 0x9e, 0xc5, 0xdf, 0x15, 0x2c, 0x04, + 0x0d, 0x67, 0xb1, 0x0f, 0xb3, 0x7e, 0x4a, 0xb0, 0x70, 0x43, 0xf6, 0x7c, 0x0e, 0x06, 0x2c, 0xb3, + 0xb6, 0x67, 0x99, 0xbd, 0x08, 0xf1, 0x69, 0xce, 0x01, 0x38, 0x09, 0x61, 0x70, 0x01, 0xb2, 0xbd, + 0x4e, 0xc4, 0xdf, 0xfb, 0x9e, 0x08, 0x0f, 0x31, 0x03, 0x0b, 0x30, 0x22, 0x12, 0x94, 0x61, 0x99, + 0x3d, 0xb0, 0xf8, 0xfb, 0x9c, 0xc5, 0x70, 0x88, 0x8c, 0xab, 0xe1, 0x61, 0xd7, 0xab, 0xe2, 0x5e, + 0x98, 0x7c, 0x56, 0xa8, 0xc1, 0x49, 0xb8, 0x29, 0xb7, 0xb0, 0xa9, 0xef, 0xf4, 0xc6, 0xe1, 0x97, + 0x84, 0x29, 0x05, 0x0d, 0x61, 0x31, 0x07, 0x43, 0x75, 0xcd, 0x71, 0x77, 0xb4, 0x5a, 0x4f, 0xd3, + 0xf1, 0x0f, 0x38, 0x8f, 0x41, 0x9f, 0x88, 0x5b, 0xa4, 0x61, 0xee, 0x87, 0xcd, 0xe7, 0x84, 0x45, + 0x42, 0x64, 0x3c, 0xf4, 0x5c, 0x8f, 0x1e, 0xca, 0xed, 0x87, 0xdb, 0x2f, 0x8b, 0xd0, 0x63, 0xb4, + 0xcb, 0x61, 0x8e, 0x17, 0x20, 0xeb, 0x1a, 0x2f, 0xf7, 0xc4, 0xe6, 0x57, 0xc4, 0x4c, 0x53, 0x02, + 0x42, 0xfc, 0x02, 0x1c, 0x6b, 0xbb, 0x4c, 0xf4, 0xc0, 0xec, 0x1f, 0x72, 0x66, 0x47, 0xda, 0x2c, + 0x15, 0x3c, 0x25, 0xec, 0x97, 0xe5, 0x3f, 0x12, 0x29, 0x01, 0x37, 0xf1, 0x5a, 0x23, 0xbb, 0x06, + 0x57, 0xdb, 0xde, 0x9f, 0xd5, 0xfe, 0xb1, 0xb0, 0x1a, 0xa3, 0x8d, 0x58, 0x6d, 0x03, 0x8e, 0x70, + 0x8e, 0xfb, 0x9b, 0xd7, 0x5f, 0x15, 0x89, 0x95, 0x51, 0x6f, 0x46, 0x67, 0xf7, 0x9d, 0x50, 0xf0, + 0xcd, 0x29, 0xca, 0x53, 0x57, 0xad, 0x6b, 0x76, 0x0f, 0x9c, 0x7f, 0x8d, 0x73, 0x16, 0x19, 0xdf, + 0xaf, 0x6f, 0xdd, 0x65, 0xcd, 0x26, 0xcc, 0xdf, 0x0e, 0x79, 0xc1, 0xbc, 0x61, 0x3a, 0x58, 0xb7, + 0xaa, 0xa6, 0xf1, 0x32, 0xae, 0xf4, 0xc0, 0xfa, 0xf3, 0x4d, 0x53, 0xb5, 0x19, 0x22, 0x27, 0x9c, + 0x17, 0x21, 0xe7, 0xd7, 0x2a, 0xaa, 0x51, 0xb7, 0x2d, 0xc7, 0x8b, 0xe1, 0xf8, 0x05, 0x31, 0x53, + 0x3e, 0xdd, 0x22, 0x25, 0x2b, 0x96, 0x81, 0x3d, 0xa9, 0xee, 0xd5, 0x25, 0xbf, 0xc8, 0x19, 0x0d, + 0x05, 0x54, 0x3c, 0x71, 0xe8, 0x56, 0xdd, 0xd6, 0x9c, 0x5e, 0xf2, 0xdf, 0xaf, 0x8b, 0xc4, 0xc1, + 0x49, 0x78, 0xe2, 0x20, 0x15, 0x1d, 0x59, 0xed, 0x7b, 0xe0, 0xf0, 0x25, 0x91, 0x38, 0x04, 0x0d, + 0x67, 0x21, 0x0a, 0x86, 0x1e, 0x58, 0xfc, 0x13, 0xc1, 0x42, 0xd0, 0x10, 0x16, 0xcf, 0x07, 0x0b, + 0xad, 0x83, 0xab, 0x86, 0xeb, 0x39, 0xac, 0x28, 0xee, 0xce, 0xea, 0x9f, 0x7e, 0x2f, 0x5a, 0x84, + 0x29, 0x21, 0x52, 0x92, 0x89, 0xf8, 0x31, 0x2d, 0xdd, 0x33, 0xc5, 0x0b, 0xf6, 0x1b, 0x22, 0x13, + 0x85, 0xc8, 0x88, 0x6c, 0xa1, 0x0a, 0x91, 0x98, 0x5d, 0x27, 0x3b, 0x85, 0x1e, 0xd8, 0xfd, 0xb3, + 0x26, 0xe1, 0xd6, 0x05, 0x2d, 0xe1, 0x19, 0xaa, 0x7f, 0x1a, 0xe6, 0x2e, 0xde, 0xeb, 0xc9, 0x3b, + 0xff, 0x79, 0x53, 0xfd, 0xb3, 0xc9, 0x28, 0x59, 0x0e, 0x19, 0x69, 0xaa, 0xa7, 0x50, 0xdc, 0xbd, + 0xa4, 0xfc, 0xcf, 0xfe, 0x80, 0xeb, 0x1b, 0x2d, 0xa7, 0x8a, 0x4b, 0xc4, 0xc9, 0xa3, 0x45, 0x4f, + 0x3c, 0xb3, 0xf7, 0xfd, 0xc0, 0xf7, 0xf3, 0x48, 0xcd, 0x53, 0xbc, 0x08, 0x43, 0x91, 0x82, 0x27, + 0x9e, 0xd5, 0x5f, 0xe5, 0xac, 0x06, 0xc3, 0xf5, 0x4e, 0xf1, 0x0c, 0xa4, 0x48, 0xf1, 0x12, 0x4f, + 0xfe, 0xd7, 0x38, 0x39, 0x45, 0x2f, 0xbe, 0x19, 0x32, 0xa2, 0x68, 0x89, 0x27, 0x7d, 0x3f, 0x27, + 0xf5, 0x49, 0x08, 0xb9, 0x28, 0x58, 0xe2, 0xc9, 0xff, 0xba, 0x20, 0x17, 0x24, 0x84, 0xbc, 0x77, + 0x13, 0x7e, 0xf9, 0xe7, 0x52, 0x7c, 0xd1, 0x11, 0xb6, 0xbb, 0x00, 0xfd, 0xbc, 0x52, 0x89, 0xa7, + 0xfe, 0x20, 0x1f, 0x5c, 0x50, 0x14, 0x9f, 0x85, 0x74, 0x8f, 0x06, 0xff, 0x1b, 0x9c, 0x94, 0xe1, + 0x17, 0xe7, 0x60, 0x20, 0x54, 0x9d, 0xc4, 0x93, 0xff, 0x4d, 0x4e, 0x1e, 0xa6, 0x22, 0xa2, 0xf3, + 0xea, 0x24, 0x9e, 0xc1, 0xdf, 0x12, 0xa2, 0x73, 0x0a, 0x62, 0x36, 0x51, 0x98, 0xc4, 0x53, 0x7f, + 0x48, 0x58, 0x5d, 0x90, 0x14, 0x9f, 0x83, 0xac, 0xbf, 0xd8, 0xc4, 0xd3, 0xbf, 0xca, 0xe9, 0x03, + 0x1a, 0x62, 0x81, 0xd0, 0x62, 0x17, 0xcf, 0xe2, 0xe7, 0x85, 0x05, 0x42, 0x54, 0x24, 0x8c, 0x9a, + 0x0b, 0x98, 0x78, 0x4e, 0x1f, 0x16, 0x61, 0xd4, 0x54, 0xbf, 0x90, 0xd9, 0xa4, 0x39, 0x3f, 0x9e, + 0xc5, 0xdf, 0x16, 0xb3, 0x49, 0xf1, 0x89, 0x18, 0xcd, 0x15, 0x41, 0x3c, 0x8f, 0x8f, 0x08, 0x31, + 0x9a, 0x0a, 0x82, 0xe2, 0x1a, 0xa0, 0xd6, 0x6a, 0x20, 0x9e, 0xdf, 0x47, 0x39, 0xbf, 0xd1, 0x96, + 0x62, 0xa0, 0xf8, 0x36, 0x38, 0xd2, 0xbe, 0x12, 0x88, 0xe7, 0xfa, 0xb1, 0x1f, 0x34, 0xed, 0xdd, + 0xc2, 0x85, 0x40, 0x71, 0x23, 0x58, 0x52, 0xc2, 0x55, 0x40, 0x3c, 0xdb, 0xd7, 0x7e, 0x10, 0x4d, + 0xdc, 0xe1, 0x22, 0xa0, 0x38, 0x0b, 0x10, 0x2c, 0xc0, 0xf1, 0xbc, 0x3e, 0xc1, 0x79, 0x85, 0x88, + 0x48, 0x68, 0xf0, 0xf5, 0x37, 0x9e, 0xfe, 0x96, 0x08, 0x0d, 0x4e, 0x41, 0x42, 0x43, 0x2c, 0xbd, + 0xf1, 0xd4, 0x9f, 0x14, 0xa1, 0x21, 0x48, 0x88, 0x67, 0x87, 0x56, 0xb7, 0x78, 0x0e, 0x9f, 0x16, + 0x9e, 0x1d, 0xa2, 0x2a, 0xae, 0xc0, 0x68, 0xcb, 0x82, 0x18, 0xcf, 0xea, 0x17, 0x38, 0xab, 0x5c, + 0xf3, 0x7a, 0x18, 0x5e, 0xbc, 0xf8, 0x62, 0x18, 0xcf, 0xed, 0x33, 0x4d, 0x8b, 0x17, 0x5f, 0x0b, + 0x8b, 0x17, 0x20, 0x63, 0x36, 0x6a, 0x35, 0x12, 0x3c, 0xa8, 0xfb, 0x5d, 0xc2, 0xfc, 0x7f, 0xf9, + 0x21, 0xb7, 0x8e, 0x20, 0x28, 0x9e, 0x81, 0x34, 0xae, 0x6f, 0xe1, 0x4a, 0x1c, 0xe5, 0x77, 0x7f, + 0x28, 0x12, 0x26, 0xc1, 0x2e, 0x3e, 0x07, 0xc0, 0x8e, 0x46, 0xe8, 0xc3, 0xc3, 0x18, 0xda, 0xff, + 0xfa, 0x43, 0x7e, 0x79, 0x27, 0x20, 0x09, 0x18, 0xb0, 0xab, 0x40, 0xdd, 0x19, 0x7c, 0x2f, 0xca, + 0x80, 0xce, 0xc8, 0x79, 0xe8, 0x7f, 0xd1, 0xb5, 0x4c, 0x4f, 0xab, 0xc6, 0x51, 0xff, 0x37, 0x4e, + 0x2d, 0xf0, 0x89, 0xc1, 0xea, 0x96, 0x83, 0x3d, 0xad, 0xea, 0xc6, 0xd1, 0xfe, 0x77, 0x4e, 0xeb, + 0x13, 0x10, 0x62, 0x5d, 0x73, 0xbd, 0x5e, 0xf4, 0xfe, 0x1f, 0x82, 0x58, 0x10, 0x10, 0xa1, 0xc9, + 0xef, 0x5d, 0xbc, 0x17, 0x47, 0xfb, 0x7d, 0x21, 0x34, 0xc7, 0x2f, 0xbe, 0x19, 0xb2, 0xe4, 0x27, + 0xbb, 0x91, 0x17, 0x43, 0xfc, 0x3f, 0x39, 0x71, 0x40, 0x41, 0x46, 0x76, 0xbd, 0x8a, 0x67, 0xc4, + 0x1b, 0xfb, 0x0e, 0x9f, 0x69, 0x81, 0x5f, 0x9c, 0x85, 0x01, 0xd7, 0xab, 0x54, 0x1a, 0xbc, 0x3e, + 0x8d, 0x21, 0xff, 0x93, 0x1f, 0xfa, 0x47, 0x16, 0x3e, 0x0d, 0x99, 0xed, 0xeb, 0xbb, 0x9e, 0x6d, + 0xd1, 0x07, 0x1e, 0x71, 0x1c, 0x7e, 0xc0, 0x39, 0x84, 0x48, 0x8a, 0x73, 0x30, 0x48, 0x74, 0x71, + 0xb0, 0x8d, 0xe9, 0xd3, 0xa9, 0x18, 0x16, 0x7f, 0xca, 0x0d, 0x10, 0x21, 0x2a, 0xfd, 0xf4, 0x57, + 0xbf, 0x35, 0x21, 0x7d, 0xe3, 0x5b, 0x13, 0xd2, 0x1f, 0x7d, 0x6b, 0x42, 0xfa, 0xd0, 0xb7, 0x27, + 0x0e, 0x7d, 0xe3, 0xdb, 0x13, 0x87, 0x7e, 0xef, 0xdb, 0x13, 0x87, 0xda, 0x9f, 0x12, 0xc3, 0x82, + 0xb5, 0x60, 0xb1, 0xf3, 0xe1, 0x77, 0xc8, 0x55, 0xc3, 0xdb, 0x69, 0x6c, 0x4d, 0xeb, 0x56, 0x9d, + 0x1e, 0xe3, 0x06, 0xa7, 0xb5, 0xfe, 0x26, 0x07, 0xfe, 0x54, 0x22, 0x1b, 0xe6, 0xe8, 0x59, 0xae, + 0x66, 0xee, 0x75, 0x78, 0xb7, 0xa7, 0xd0, 0xf6, 0x60, 0x58, 0x7e, 0x13, 0x24, 0x67, 0xcd, 0x3d, + 0x74, 0x8c, 0xe5, 0x3c, 0xb5, 0xe1, 0xd4, 0xf8, 0x4d, 0xb1, 0x7e, 0xd2, 0xde, 0x74, 0x6a, 0x68, + 0x3c, 0xb8, 0xce, 0x29, 0x9d, 0x18, 0xe4, 0x77, 0x34, 0x8b, 0xa9, 0xef, 0x7f, 0x7a, 0xf2, 0x50, + 0x69, 0xb7, 0x59, 0xc3, 0x2f, 0xc7, 0x6a, 0x99, 0x99, 0x35, 0xf7, 0xa8, 0x92, 0x6b, 0xd2, 0x3b, + 0xd2, 0xf4, 0xa0, 0x5b, 0x1c, 0x6c, 0x4f, 0x34, 0x1f, 0x6c, 0xbf, 0x0d, 0xd7, 0x6a, 0x57, 0x4c, + 0xeb, 0xba, 0xb9, 0x41, 0xd0, 0xb6, 0xfa, 0xd8, 0xb5, 0x63, 0xf8, 0x48, 0x02, 0x26, 0x9b, 0xf5, + 0x26, 0x8e, 0xe3, 0x7a, 0x5a, 0xdd, 0xee, 0xf4, 0x66, 0xd3, 0x05, 0xc8, 0x6e, 0x08, 0x1c, 0x94, + 0x87, 0x7e, 0x17, 0xeb, 0x96, 0x59, 0x71, 0xa9, 0xb2, 0x49, 0x45, 0x34, 0x89, 0xb2, 0xa6, 0x66, + 0x5a, 0x2e, 0xbf, 0x4f, 0xc9, 0x1a, 0xa5, 0x5b, 0xd2, 0xfe, 0x66, 0x72, 0xd8, 0x1f, 0x4a, 0x68, + 0x7a, 0x2a, 0xf6, 0xb4, 0x7f, 0x97, 0x28, 0x1a, 0xe8, 0x11, 0x39, 0xf2, 0xef, 0xd5, 0x32, 0xef, + 0x4d, 0xc2, 0x31, 0xdd, 0x72, 0xeb, 0x96, 0xab, 0xb2, 0x89, 0x66, 0x0d, 0x6e, 0x93, 0xc1, 0x70, + 0x57, 0x0f, 0x8f, 0x01, 0x2e, 0xc1, 0x30, 0x0d, 0x06, 0x7a, 0x00, 0x4a, 0xf3, 0x4f, 0xec, 0x92, + 0xf1, 0xb5, 0x7f, 0x97, 0xa6, 0xce, 0x33, 0xe4, 0x13, 0xd2, 0xfb, 0x1f, 0x1b, 0x30, 0x6e, 0xd4, + 0xed, 0x1a, 0xa6, 0x0f, 0x7e, 0x54, 0xbf, 0x2f, 0x9e, 0xdf, 0xd7, 0x39, 0xbf, 0xb1, 0x80, 0x7c, + 0x51, 0x50, 0x17, 0x97, 0x60, 0x54, 0xd3, 0x75, 0x6c, 0x47, 0x58, 0xc6, 0x04, 0xaa, 0x10, 0x30, + 0xc7, 0x29, 0x7d, 0x6e, 0xa5, 0xe7, 0x3a, 0x4d, 0xf1, 0x3b, 0x1e, 0x0e, 0xc5, 0xa2, 0x83, 0xab, + 0xd8, 0x7c, 0xd2, 0xc4, 0xde, 0x75, 0xcb, 0xd9, 0xe5, 0xe6, 0x7d, 0x92, 0x0d, 0x25, 0x26, 0xe1, + 0xfd, 0x49, 0x98, 0x60, 0x1d, 0x33, 0x5b, 0x9a, 0x8b, 0x67, 0xae, 0x3d, 0xbd, 0x85, 0x3d, 0xed, + 0xe9, 0x19, 0xdd, 0x32, 0x4c, 0x3e, 0x13, 0x63, 0x7c, 0x5e, 0x48, 0xff, 0x34, 0xef, 0xef, 0x10, + 0x9f, 0x0b, 0x90, 0x9a, 0xb3, 0x0c, 0x93, 0x38, 0x66, 0x05, 0x9b, 0x56, 0x9d, 0x47, 0x27, 0x6b, + 0xa0, 0x07, 0xa1, 0x4f, 0xab, 0x5b, 0x0d, 0xd3, 0x63, 0xcf, 0xac, 0x4a, 0x03, 0x5f, 0xbd, 0x3d, + 0x79, 0xe8, 0xf7, 0x6f, 0x4f, 0x26, 0x17, 0x4d, 0x4f, 0xe1, 0x5d, 0xc5, 0xd4, 0xeb, 0x9f, 0x9a, + 0x94, 0xe4, 0xcb, 0xd0, 0x3f, 0x8f, 0xf5, 0x83, 0xf0, 0x9a, 0xc7, 0x7a, 0x13, 0xaf, 0xc7, 0x20, + 0xb3, 0x68, 0x7a, 0xec, 0xa6, 0xed, 0xfd, 0x90, 0x34, 0x4c, 0x76, 0x79, 0xab, 0x69, 0x7c, 0x02, + 0x27, 0xa8, 0xf3, 0x58, 0xf7, 0x51, 0x2b, 0x58, 0x6f, 0x46, 0x25, 0xec, 0x09, 0xbc, 0x74, 0xf1, + 0xf7, 0xfe, 0xd3, 0xc4, 0xa1, 0x57, 0xbe, 0x35, 0x71, 0xa8, 0xe3, 0x4c, 0x3c, 0x14, 0x9a, 0x09, + 0xc3, 0x31, 0x5c, 0x13, 0x7b, 0x33, 0xba, 0xe5, 0xe0, 0x27, 0xdd, 0xca, 0xee, 0x93, 0x55, 0x8b, + 0x45, 0x92, 0x3f, 0x11, 0x1f, 0x4e, 0xc0, 0x44, 0x8b, 0x93, 0xf3, 0x15, 0xa2, 0x53, 0x9a, 0x28, + 0x42, 0x66, 0x5e, 0x2c, 0x3c, 0xfb, 0xcd, 0x12, 0x1f, 0xdf, 0x67, 0x96, 0x18, 0x12, 0x23, 0x89, + 0x24, 0xf1, 0x74, 0x8f, 0x49, 0x42, 0x28, 0x71, 0xa0, 0x1c, 0xf1, 0x3b, 0x12, 0x4c, 0xd1, 0x97, + 0x4f, 0x9c, 0xba, 0x61, 0x7a, 0x33, 0x35, 0x63, 0xcb, 0x9d, 0xd9, 0x32, 0x3c, 0x97, 0x8d, 0xc0, + 0xed, 0x32, 0x1e, 0x60, 0x4c, 0x13, 0x8c, 0x69, 0x82, 0x21, 0x9f, 0x86, 0x4c, 0xc9, 0xf0, 0x66, + 0x1d, 0x47, 0xdb, 0x43, 0x08, 0x52, 0x04, 0xc6, 0x2d, 0x43, 0x7f, 0x13, 0xb3, 0xe0, 0x1a, 0xae, + 0xbb, 0xf4, 0xf1, 0x73, 0x4a, 0x61, 0x8d, 0xd2, 0x66, 0xc7, 0xe9, 0xbc, 0x10, 0x9a, 0xce, 0x90, + 0x48, 0xa1, 0x9f, 0x2c, 0x1c, 0xda, 0x89, 0xeb, 0xeb, 0xf3, 0xb9, 0x14, 0xdc, 0x1f, 0x42, 0xd0, + 0x9d, 0x3d, 0xdb, 0xa3, 0xcb, 0xa5, 0xb5, 0xcd, 0x95, 0x19, 0x0d, 0x29, 0xc3, 0xba, 0x3b, 0xc4, + 0xda, 0x36, 0xa4, 0xd7, 0x08, 0x1d, 0x51, 0xc4, 0xb3, 0x3c, 0xad, 0xc6, 0xb5, 0x63, 0x0d, 0x02, + 0x65, 0x2f, 0xe0, 0x24, 0x18, 0xd4, 0x10, 0xef, 0xde, 0xd4, 0xb0, 0xb6, 0xcd, 0xee, 0x31, 0x27, + 0xe9, 0x12, 0x99, 0x21, 0x00, 0x7a, 0x65, 0x79, 0x1c, 0xd2, 0x5a, 0x83, 0x3d, 0x40, 0x4f, 0x92, + 0xb5, 0x93, 0x36, 0xe4, 0x2b, 0xd0, 0xcf, 0x1f, 0xe3, 0xa1, 0x1c, 0x24, 0x77, 0xf1, 0x1e, 0x1d, + 0x67, 0x50, 0x21, 0x3f, 0xd1, 0x34, 0xa4, 0xa9, 0xf0, 0xfc, 0x05, 0x8d, 0xfc, 0x74, 0x8b, 0xf4, + 0xd3, 0x54, 0x48, 0x85, 0xa1, 0xc9, 0x97, 0x21, 0x33, 0x6f, 0xd5, 0x0d, 0xd3, 0x8a, 0x72, 0xcb, + 0x32, 0x6e, 0x54, 0x66, 0xbb, 0xc1, 0x63, 0x5a, 0x61, 0x0d, 0x74, 0x04, 0xfa, 0xd8, 0xbd, 0x76, + 0x7e, 0x09, 0x80, 0xb7, 0xe4, 0x39, 0xe8, 0xa7, 0xbc, 0x57, 0x6d, 0x32, 0xbf, 0xfe, 0x15, 0xc2, + 0x2c, 0x7f, 0xcb, 0x89, 0xb3, 0x4f, 0x04, 0xc2, 0x22, 0x48, 0x55, 0x34, 0x4f, 0xe3, 0x7a, 0xd3, + 0xdf, 0xf2, 0x5b, 0x20, 0xc3, 0x99, 0xb8, 0xe8, 0x14, 0x24, 0x2d, 0xdb, 0xe5, 0x8f, 0xf1, 0x0b, + 0x9d, 0x54, 0x59, 0xb5, 0x4b, 0x29, 0x92, 0x0d, 0x14, 0x82, 0x5c, 0x52, 0x3a, 0xfa, 0xcb, 0xb9, + 0xfd, 0xfb, 0x0b, 0x1b, 0xc6, 0x77, 0x96, 0x4f, 0x27, 0x60, 0x22, 0xd4, 0x7b, 0x0d, 0x3b, 0x64, + 0x2f, 0x1b, 0x71, 0x7d, 0x14, 0x12, 0x92, 0xf7, 0x77, 0x70, 0x97, 0x37, 0x43, 0x72, 0xd6, 0xb6, + 0x51, 0x01, 0x32, 0xb4, 0xad, 0x5b, 0xcc, 0x5f, 0x52, 0x8a, 0xdf, 0x26, 0x7d, 0xae, 0xb5, 0xed, + 0x5d, 0xd7, 0x1c, 0xff, 0xd5, 0x2f, 0xd1, 0x96, 0xcf, 0x43, 0x76, 0xce, 0x32, 0x5d, 0x6c, 0xba, + 0x0d, 0x1a, 0x3a, 0x5b, 0x35, 0x4b, 0xdf, 0xe5, 0x1c, 0x58, 0x83, 0x18, 0x5c, 0xb3, 0x6d, 0x4a, + 0x99, 0x52, 0xc8, 0x4f, 0x96, 0x7f, 0x4b, 0xeb, 0x1d, 0x4d, 0x74, 0x7e, 0xff, 0x26, 0xe2, 0x4a, + 0xfa, 0x36, 0xfa, 0x03, 0x09, 0x8e, 0xb7, 0x06, 0xd4, 0x2e, 0xde, 0x73, 0xf7, 0x1b, 0x4f, 0xe7, + 0x20, 0xbb, 0x46, 0xdf, 0xbf, 0xbe, 0x82, 0xf7, 0x50, 0x01, 0xfa, 0x71, 0xe5, 0xd4, 0x99, 0x33, + 0x4f, 0x9f, 0x67, 0xde, 0x7e, 0xe9, 0x90, 0x22, 0x00, 0xc5, 0x0c, 0xd1, 0xea, 0xf5, 0x4f, 0x4f, + 0x4a, 0xa5, 0x34, 0x24, 0xdd, 0x46, 0xfd, 0x9e, 0xfa, 0xc0, 0x6b, 0xe9, 0x48, 0x02, 0x64, 0x89, + 0xf5, 0x9a, 0x56, 0x33, 0x2a, 0x5a, 0xf0, 0x66, 0x7c, 0x2e, 0xa4, 0x23, 0xc5, 0x68, 0xaf, 0x62, + 0xa1, 0xab, 0xa5, 0xe4, 0xcf, 0x4b, 0x30, 0x78, 0x55, 0x70, 0x5e, 0xc7, 0x1e, 0xba, 0x00, 0xe0, + 0x8f, 0x24, 0xc2, 0xe2, 0xbe, 0xe9, 0xe6, 0xb1, 0xa6, 0x7d, 0x1a, 0x25, 0x84, 0x8e, 0x9e, 0xa5, + 0x8e, 0x66, 0x5b, 0x2e, 0x7f, 0xdd, 0x27, 0x86, 0xd4, 0x47, 0x46, 0x4f, 0x00, 0xa2, 0x19, 0x4c, + 0xbd, 0x66, 0x79, 0x86, 0x59, 0x55, 0x6d, 0xeb, 0x3a, 0x7f, 0x89, 0x32, 0xa9, 0xe4, 0x68, 0xcf, + 0x55, 0xda, 0xb1, 0x46, 0xe0, 0x44, 0xe8, 0xac, 0xcf, 0x85, 0x2c, 0x82, 0x5a, 0xa5, 0xe2, 0x60, + 0xd7, 0xe5, 0x49, 0x4a, 0x34, 0xd1, 0x05, 0xe8, 0xb7, 0x1b, 0x5b, 0xaa, 0xc8, 0x08, 0x03, 0xa7, + 0x8e, 0xb7, 0x8b, 0x6f, 0x31, 0xff, 0x3c, 0xc2, 0xfb, 0xec, 0xc6, 0x16, 0xf1, 0x86, 0x07, 0x60, + 0xb0, 0x8d, 0x30, 0x03, 0xd7, 0x02, 0x39, 0xe8, 0x6b, 0xfd, 0x5c, 0x03, 0xd5, 0x76, 0x0c, 0xcb, + 0x31, 0xbc, 0x3d, 0x7a, 0xd7, 0x26, 0xa9, 0xe4, 0x44, 0xc7, 0x1a, 0x87, 0xcb, 0xbb, 0x30, 0xb2, + 0x4e, 0x6b, 0xc4, 0x40, 0xf2, 0x33, 0x81, 0x7c, 0x52, 0xbc, 0x7c, 0x1d, 0x25, 0x4b, 0xb4, 0x48, + 0x56, 0x7a, 0xbe, 0xa3, 0x77, 0x3e, 0xbb, 0x7f, 0xef, 0x8c, 0xd6, 0x2c, 0x7f, 0x56, 0x88, 0x04, + 0x1f, 0x73, 0xce, 0x70, 0x7a, 0xea, 0xd5, 0x31, 0xe3, 0x76, 0x48, 0x85, 0xd8, 0x22, 0xa0, 0xd0, + 0x7d, 0x59, 0x2d, 0xc4, 0x24, 0xd2, 0x42, 0x6c, 0x90, 0xc9, 0xe7, 0x61, 0x68, 0x4d, 0x73, 0xbc, + 0x75, 0xec, 0x5d, 0xc2, 0x5a, 0x05, 0x3b, 0xd1, 0x75, 0x77, 0x48, 0xac, 0xbb, 0x08, 0x52, 0x74, + 0x71, 0x65, 0xeb, 0x0e, 0xfd, 0x2d, 0xef, 0x40, 0x8a, 0xde, 0xc8, 0xf3, 0xd7, 0x64, 0x4e, 0xc1, + 0xd6, 0x64, 0x92, 0x4d, 0xf7, 0x3c, 0xec, 0x8a, 0x2d, 0x2b, 0x6d, 0xa0, 0xd3, 0x62, 0x65, 0x4d, + 0x76, 0x5f, 0x59, 0xb9, 0xab, 0xf2, 0xf5, 0xb5, 0x06, 0xfd, 0x25, 0x92, 0x8c, 0x17, 0xe7, 0x7d, + 0x41, 0xa4, 0x40, 0x10, 0xb4, 0x0c, 0x23, 0xb6, 0xe6, 0x78, 0xf4, 0x65, 0x86, 0x1d, 0xaa, 0x05, + 0x8f, 0x86, 0xc9, 0xd6, 0xd8, 0x8c, 0x28, 0xcb, 0x47, 0x19, 0xb2, 0xc3, 0x40, 0xf9, 0x8f, 0x53, + 0xd0, 0xc7, 0x8d, 0xf1, 0x66, 0xe8, 0xe7, 0x66, 0xe5, 0xfe, 0x7b, 0xff, 0x74, 0xeb, 0xd2, 0x34, + 0xed, 0x2f, 0x21, 0x9c, 0x9f, 0xa0, 0x41, 0x8f, 0x40, 0x46, 0xdf, 0xd1, 0x0c, 0x53, 0x35, 0x2a, + 0xa2, 0xa0, 0xff, 0xd6, 0xed, 0xc9, 0xfe, 0x39, 0x02, 0x5b, 0x9c, 0x57, 0xfa, 0x69, 0xe7, 0x62, + 0x85, 0xd4, 0x02, 0x3b, 0xd8, 0xa8, 0xee, 0x78, 0x3c, 0x06, 0x79, 0x0b, 0x9d, 0x83, 0x14, 0x71, + 0x19, 0xfe, 0xaa, 0x5b, 0xa1, 0x65, 0x5b, 0xe5, 0x6f, 0x71, 0x4b, 0x19, 0x32, 0xf0, 0x87, 0xfe, + 0x70, 0x52, 0x52, 0x28, 0x05, 0x9a, 0x83, 0xa1, 0x9a, 0xe6, 0x7a, 0x2a, 0x5d, 0xc3, 0xc8, 0xf0, + 0x69, 0xca, 0xe2, 0x58, 0xab, 0x41, 0xb8, 0x61, 0xb9, 0xe8, 0x03, 0x84, 0x8a, 0x81, 0x2a, 0xe8, + 0x04, 0xe4, 0x28, 0x13, 0xdd, 0xaa, 0xd7, 0x0d, 0x8f, 0x55, 0x57, 0x7d, 0xd4, 0xee, 0xc3, 0x04, + 0x3e, 0x47, 0xc1, 0xb4, 0xc6, 0xba, 0x0f, 0xb2, 0xf4, 0xe5, 0x1a, 0x8a, 0xc2, 0xae, 0x81, 0x66, + 0x08, 0x80, 0x76, 0x3e, 0x0a, 0x23, 0x41, 0x06, 0x65, 0x28, 0x19, 0xc6, 0x25, 0x00, 0x53, 0xc4, + 0xa7, 0x60, 0xdc, 0xc4, 0x37, 0xe8, 0xc5, 0xd4, 0x08, 0x76, 0x96, 0x62, 0x23, 0xd2, 0x77, 0x35, + 0x4a, 0xf1, 0x30, 0x0c, 0xeb, 0xc2, 0xf8, 0x0c, 0x17, 0x28, 0xee, 0x90, 0x0f, 0xa5, 0x68, 0xc7, + 0x20, 0xa3, 0xd9, 0x36, 0x43, 0x18, 0xe0, 0x19, 0xd4, 0xb6, 0x69, 0xd7, 0x49, 0x18, 0xa5, 0x3a, + 0x3a, 0xd8, 0x6d, 0xd4, 0x3c, 0xce, 0x64, 0x90, 0xe2, 0x8c, 0x90, 0x0e, 0x85, 0xc1, 0x29, 0xee, + 0x83, 0x30, 0x84, 0xaf, 0x19, 0x15, 0x6c, 0xea, 0x98, 0xe1, 0x0d, 0x51, 0xbc, 0x41, 0x01, 0xa4, + 0x48, 0x8f, 0x81, 0x9f, 0x19, 0x55, 0x91, 0xb5, 0x87, 0x19, 0x3f, 0x01, 0x9f, 0x65, 0x60, 0xf9, + 0x09, 0x48, 0xcd, 0x6b, 0x9e, 0x46, 0x4a, 0x0c, 0xef, 0x06, 0x5b, 0x8a, 0x06, 0x15, 0xf2, 0xb3, + 0x6d, 0xb8, 0xbd, 0x9e, 0x80, 0xd4, 0x55, 0xcb, 0xc3, 0xe8, 0x99, 0x50, 0x59, 0x38, 0xdc, 0xce, + 0xc7, 0xd7, 0x8d, 0xaa, 0x89, 0x2b, 0xcb, 0x6e, 0x35, 0xf4, 0x76, 0x7c, 0xe0, 0x62, 0x89, 0x88, + 0x8b, 0x8d, 0x43, 0xda, 0xb1, 0x1a, 0x66, 0x45, 0xdc, 0xaa, 0xa4, 0x0d, 0x54, 0x86, 0x8c, 0xef, + 0x39, 0xa9, 0x38, 0xcf, 0x19, 0x21, 0x9e, 0x43, 0xfc, 0x9a, 0x03, 0x94, 0xfe, 0x2d, 0xee, 0x40, + 0x25, 0xc8, 0xfa, 0x29, 0x8f, 0x7b, 0x60, 0x6f, 0x4e, 0x1c, 0x90, 0x91, 0x25, 0xc8, 0xf7, 0x07, + 0xdf, 0xa0, 0xcc, 0x0b, 0x73, 0x7e, 0x07, 0xb7, 0x68, 0xc4, 0xd5, 0xf8, 0x9b, 0xfa, 0xfd, 0x54, + 0xaf, 0xc0, 0xd5, 0xd8, 0xdb, 0xfa, 0xc7, 0x21, 0xeb, 0x1a, 0x55, 0x53, 0xf3, 0x1a, 0x0e, 0xe6, + 0xde, 0x18, 0x00, 0xe4, 0x57, 0x13, 0xd0, 0xc7, 0xbc, 0x3b, 0x64, 0x37, 0xa9, 0xbd, 0xdd, 0x12, + 0x9d, 0xec, 0x96, 0x3c, 0xb8, 0xdd, 0x66, 0x01, 0x7c, 0x61, 0x5c, 0xfe, 0x02, 0x75, 0x9b, 0x3a, + 0x83, 0x89, 0xb8, 0x6e, 0x54, 0x79, 0xf0, 0x86, 0x88, 0x7c, 0x0f, 0x4a, 0x87, 0xf2, 0xe4, 0x05, + 0xc8, 0x6e, 0x19, 0x9e, 0xaa, 0x91, 0xcd, 0x23, 0x35, 0xe1, 0xc0, 0xa9, 0x89, 0xe9, 0x76, 0xbb, + 0xcc, 0x69, 0xb1, 0xc5, 0x54, 0x32, 0x5b, 0xfc, 0x97, 0xfc, 0x07, 0x12, 0xa9, 0x95, 0xf9, 0x80, + 0x68, 0x16, 0x86, 0x84, 0xa2, 0xea, 0x76, 0x4d, 0xab, 0x72, 0x67, 0xbc, 0xbf, 0xa3, 0xb6, 0x17, + 0x6b, 0x5a, 0x55, 0x19, 0xe0, 0x0a, 0x92, 0x46, 0xfb, 0x89, 0x4d, 0x74, 0x98, 0xd8, 0x88, 0x27, + 0x25, 0x0f, 0xe6, 0x49, 0x91, 0x39, 0x4f, 0x35, 0xcf, 0xf9, 0x17, 0x12, 0x74, 0xcf, 0x64, 0x5b, + 0xae, 0x56, 0xfb, 0x71, 0x84, 0xd8, 0x7d, 0x90, 0xb5, 0xad, 0x9a, 0xca, 0x7a, 0xd8, 0xf5, 0xe5, + 0x8c, 0x6d, 0xd5, 0x94, 0x16, 0x3f, 0x4a, 0xdf, 0xa5, 0xf8, 0xeb, 0xbb, 0x0b, 0x56, 0xeb, 0x6f, + 0xb6, 0x9a, 0x03, 0x83, 0xcc, 0x14, 0x7c, 0xc1, 0x7c, 0x8a, 0xd8, 0x80, 0xae, 0xc0, 0x52, 0xeb, + 0x02, 0xcf, 0xc4, 0x66, 0x98, 0x0a, 0xc7, 0x23, 0x14, 0x6c, 0x7d, 0x69, 0xb7, 0xd9, 0x0e, 0xfb, + 0xb9, 0xc2, 0xf1, 0xe4, 0xbf, 0x23, 0x01, 0x2c, 0x11, 0xcb, 0x52, 0x7d, 0xc9, 0x52, 0xe7, 0x52, + 0x11, 0xd4, 0xc8, 0xc8, 0x13, 0x9d, 0x26, 0x8d, 0x8f, 0x3f, 0xe8, 0x86, 0xe5, 0x9e, 0x83, 0xa1, + 0xc0, 0x19, 0x5d, 0x2c, 0x84, 0x99, 0xe8, 0x52, 0xdc, 0xaf, 0x63, 0x4f, 0x19, 0xbc, 0x16, 0x6a, + 0xc9, 0xff, 0x4a, 0x82, 0x2c, 0x95, 0x69, 0x19, 0x7b, 0x5a, 0x64, 0x0e, 0xa5, 0x83, 0xcf, 0xe1, + 0xfd, 0x00, 0x8c, 0x8d, 0x6b, 0xbc, 0x8c, 0xb9, 0x67, 0x65, 0x29, 0x64, 0xdd, 0x78, 0x19, 0xa3, + 0xb3, 0xbe, 0xc1, 0x93, 0xdd, 0x0d, 0x2e, 0x8a, 0x7f, 0x6e, 0xf6, 0xa3, 0xd0, 0x4f, 0xbf, 0x60, + 0x74, 0xc3, 0xe5, 0xf5, 0x7c, 0x9f, 0xd9, 0xa8, 0x6f, 0xdc, 0x70, 0xe5, 0x17, 0xa1, 0x7f, 0xe3, + 0x06, 0x3b, 0x82, 0xb9, 0x0f, 0xb2, 0x8e, 0x65, 0xf1, 0x85, 0x9f, 0x15, 0x5c, 0x19, 0x02, 0xa0, + 0xeb, 0x9c, 0x38, 0x76, 0x48, 0x04, 0xc7, 0x0e, 0xc1, 0xb9, 0x49, 0xb2, 0xa7, 0x73, 0x93, 0x93, + 0xff, 0x5e, 0x82, 0x81, 0x50, 0x7e, 0x40, 0x4f, 0xc3, 0xe1, 0xd2, 0xd2, 0xea, 0xdc, 0x15, 0x75, + 0x71, 0x5e, 0xbd, 0xb8, 0x34, 0xbb, 0x10, 0xbc, 0xa0, 0x53, 0x38, 0x72, 0xf3, 0xd6, 0x14, 0x0a, + 0xe1, 0x6e, 0x9a, 0xf4, 0x1c, 0x0e, 0xcd, 0xc0, 0x78, 0x94, 0x64, 0xb6, 0xb4, 0x5e, 0x5e, 0xd9, + 0xc8, 0x49, 0x85, 0xc3, 0x37, 0x6f, 0x4d, 0x8d, 0x86, 0x28, 0x66, 0xb7, 0x5c, 0x6c, 0x7a, 0xad, + 0x04, 0x73, 0xab, 0xcb, 0xcb, 0x8b, 0x1b, 0xb9, 0x44, 0x0b, 0x01, 0x5f, 0x01, 0x1e, 0x83, 0xd1, + 0x28, 0xc1, 0xca, 0xe2, 0x52, 0x2e, 0x59, 0x40, 0x37, 0x6f, 0x4d, 0x0d, 0x87, 0xb0, 0x57, 0x8c, + 0x5a, 0x21, 0xf3, 0x81, 0xcf, 0x4c, 0x1c, 0xfa, 0xa5, 0x5f, 0x9c, 0x90, 0x88, 0x66, 0x43, 0x91, + 0x1c, 0x81, 0x9e, 0x80, 0xa3, 0xeb, 0x8b, 0x0b, 0x2b, 0xe5, 0x79, 0x75, 0x79, 0x7d, 0x41, 0x65, + 0x9f, 0x36, 0xf1, 0xb5, 0x1b, 0xb9, 0x79, 0x6b, 0x6a, 0x80, 0xab, 0xd4, 0x09, 0x7b, 0x4d, 0x29, + 0x5f, 0x5d, 0xdd, 0x28, 0xe7, 0x24, 0x86, 0xbd, 0xe6, 0xe0, 0x6b, 0x96, 0xc7, 0x3e, 0x71, 0xf6, + 0x14, 0x1c, 0x6b, 0x83, 0xed, 0x2b, 0x36, 0x7a, 0xf3, 0xd6, 0xd4, 0xd0, 0x9a, 0x83, 0x59, 0xfc, + 0x50, 0x8a, 0x69, 0xc8, 0xb7, 0x52, 0xac, 0xae, 0xad, 0xae, 0xcf, 0x2e, 0xe5, 0xa6, 0x0a, 0xb9, + 0x9b, 0xb7, 0xa6, 0x06, 0x45, 0x32, 0x24, 0xf8, 0x81, 0x66, 0xf7, 0x72, 0xe3, 0xf5, 0xc1, 0x69, + 0x78, 0x88, 0x9f, 0xda, 0xbb, 0x9e, 0xb6, 0x6b, 0x98, 0x55, 0xff, 0xe0, 0x9e, 0xb7, 0xf9, 0x06, + 0xec, 0x08, 0x3f, 0xbb, 0x17, 0xd0, 0xae, 0xc7, 0xf7, 0x85, 0xce, 0x0f, 0xe8, 0x0a, 0x31, 0x67, + 0xd3, 0xf1, 0x3b, 0xb8, 0xce, 0x8f, 0x7a, 0x0a, 0x31, 0x0f, 0x20, 0x0a, 0x5d, 0xf7, 0x98, 0xf2, + 0x07, 0x25, 0x18, 0xbe, 0x64, 0xb8, 0x9e, 0xe5, 0x18, 0xba, 0x56, 0xa3, 0xaf, 0xe5, 0x9c, 0xed, + 0x35, 0xb7, 0x36, 0x85, 0xfa, 0x73, 0xd0, 0x77, 0x4d, 0xab, 0xb1, 0xa4, 0x96, 0xa4, 0xdf, 0x21, + 0x69, 0x6f, 0xbe, 0x20, 0xb5, 0x09, 0x06, 0x8c, 0x4c, 0xfe, 0xf5, 0x04, 0x8c, 0xd0, 0x60, 0x70, + 0xd9, 0x17, 0xaa, 0x3c, 0xfa, 0x39, 0x89, 0x94, 0xa3, 0x79, 0xfc, 0x6c, 0xb2, 0xf4, 0x14, 0x7f, + 0x90, 0x70, 0xa2, 0x97, 0x87, 0x03, 0xd3, 0xf3, 0x58, 0x57, 0x28, 0x35, 0xfa, 0x19, 0xc8, 0xd4, + 0xb5, 0x1b, 0x2a, 0xe5, 0xc4, 0x36, 0x48, 0x73, 0xfb, 0xe5, 0x74, 0xe7, 0xf6, 0xe4, 0xc8, 0x9e, + 0x56, 0xaf, 0x15, 0x65, 0xc1, 0x49, 0x56, 0xfa, 0xeb, 0xda, 0x0d, 0x22, 0x26, 0x72, 0x60, 0x84, + 0x40, 0xf5, 0x1d, 0xcd, 0xac, 0x62, 0x36, 0x0c, 0x3d, 0x6d, 0x2d, 0x5d, 0x3e, 0xc0, 0x30, 0x47, + 0x82, 0x61, 0x42, 0x0c, 0x65, 0x65, 0xa8, 0xae, 0xdd, 0x98, 0xa3, 0x00, 0x32, 0x66, 0x31, 0xf3, + 0xd1, 0x4f, 0x4d, 0x1e, 0xa2, 0x8f, 0x68, 0xbe, 0x29, 0x01, 0x04, 0x76, 0x43, 0x3f, 0x05, 0x39, + 0xdd, 0x6f, 0x51, 0x5a, 0x97, 0xcf, 0xe4, 0xa3, 0x9d, 0x66, 0xa4, 0xc9, 0xea, 0x6c, 0x85, 0xfe, + 0xc6, 0xed, 0x49, 0x49, 0x19, 0xd1, 0x9b, 0x26, 0xe4, 0x9d, 0x30, 0xd0, 0xb0, 0x2b, 0x9a, 0x87, + 0x55, 0xba, 0x65, 0x4c, 0xc4, 0xae, 0xf6, 0x13, 0x84, 0xd7, 0x9d, 0xdb, 0x93, 0x88, 0xa9, 0x15, + 0x22, 0x96, 0x69, 0x0d, 0x00, 0x0c, 0x42, 0x08, 0x42, 0x3a, 0x7d, 0x4d, 0x82, 0x81, 0xf9, 0xd0, + 0xb5, 0xb9, 0x3c, 0xf4, 0xd7, 0x2d, 0xd3, 0xd8, 0xe5, 0x5e, 0x99, 0x55, 0x44, 0x13, 0x15, 0x20, + 0xc3, 0xde, 0x57, 0xf4, 0xf6, 0xc4, 0xb9, 0xab, 0x68, 0x13, 0xaa, 0xeb, 0x78, 0xcb, 0x35, 0xc4, + 0x7c, 0x28, 0xa2, 0x89, 0x2e, 0x42, 0xce, 0xc5, 0x7a, 0xc3, 0x31, 0xbc, 0x3d, 0x55, 0xb7, 0x4c, + 0x4f, 0xd3, 0x3d, 0xf6, 0xe6, 0x5b, 0xe9, 0xbe, 0x3b, 0xb7, 0x27, 0x8f, 0x32, 0x59, 0x9b, 0x31, + 0x64, 0x65, 0x44, 0x80, 0xe6, 0x18, 0x84, 0x8c, 0x50, 0xc1, 0x9e, 0x66, 0xd4, 0xdc, 0x3c, 0x7b, + 0xda, 0x28, 0x9a, 0x21, 0x5d, 0x3e, 0xdf, 0x1f, 0x3e, 0x65, 0xbb, 0x08, 0x39, 0xcb, 0xc6, 0x4e, + 0xa4, 0x1c, 0x95, 0x9a, 0x47, 0x6e, 0xc6, 0x90, 0x95, 0x11, 0x01, 0x12, 0xa5, 0xaa, 0x47, 0xa6, + 0x59, 0xec, 0x49, 0xed, 0xc6, 0x56, 0x70, 0x38, 0x37, 0xde, 0x32, 0x1b, 0xb3, 0xe6, 0x5e, 0xe9, + 0x99, 0x80, 0x7b, 0x33, 0x9d, 0xfc, 0xf5, 0x2f, 0x3e, 0x39, 0xce, 0x5d, 0x23, 0x38, 0x2c, 0xbb, + 0x82, 0xf7, 0xc8, 0xf4, 0x73, 0xd4, 0x35, 0x8a, 0x49, 0x8a, 0xcf, 0x17, 0x35, 0xa3, 0x26, 0xde, + 0xe0, 0x56, 0x78, 0x0b, 0x15, 0xa1, 0xcf, 0xf5, 0x34, 0xaf, 0xe1, 0xf2, 0x2f, 0xb3, 0xc9, 0x9d, + 0x5c, 0xad, 0x64, 0x99, 0x95, 0x75, 0x8a, 0xa9, 0x70, 0x0a, 0x74, 0x09, 0xfa, 0x3c, 0x6b, 0x17, + 0x9b, 0xdc, 0x84, 0xfb, 0x8c, 0x72, 0xfa, 0xf8, 0x93, 0xd1, 0xa3, 0x6b, 0x90, 0xab, 0xe0, 0x1a, + 0xae, 0xb2, 0xf2, 0x6a, 0x47, 0x23, 0xdb, 0x1a, 0xfa, 0x89, 0xb6, 0xd2, 0x95, 0x03, 0x04, 0x22, + 0xb7, 0x56, 0x33, 0x47, 0x59, 0x19, 0xf1, 0x41, 0xeb, 0x14, 0x82, 0xae, 0x44, 0xee, 0x78, 0xf2, + 0x2f, 0x19, 0x3e, 0xd8, 0xc9, 0x04, 0x21, 0xbf, 0x16, 0xc7, 0x21, 0xe1, 0x1b, 0xa2, 0x17, 0x21, + 0xd7, 0x30, 0xb7, 0x2c, 0x93, 0xbe, 0x6a, 0xc9, 0x2b, 0x7d, 0xb2, 0x75, 0x4c, 0x86, 0x1d, 0xa4, + 0x19, 0x43, 0x56, 0x46, 0x7c, 0xd0, 0x25, 0xb6, 0x1f, 0xa8, 0xc0, 0x70, 0x80, 0x45, 0x83, 0x35, + 0x1b, 0x1b, 0xac, 0x0f, 0xf0, 0x60, 0x3d, 0xdc, 0x3c, 0x4a, 0x10, 0xaf, 0x43, 0x3e, 0x90, 0x90, + 0xa1, 0x4b, 0x00, 0x41, 0x8a, 0xa0, 0xc7, 0x22, 0x03, 0x9d, 0x27, 0x3f, 0xc8, 0x33, 0x62, 0x2b, + 0x19, 0xd0, 0xa2, 0xf7, 0xc0, 0x58, 0xdd, 0x30, 0x55, 0x17, 0xd7, 0xb6, 0x55, 0x6e, 0x60, 0xc2, + 0x92, 0x7e, 0x6b, 0xa7, 0xb4, 0xb2, 0x5f, 0x9f, 0xb8, 0x73, 0x7b, 0xb2, 0xc0, 0x13, 0x69, 0x2b, + 0x53, 0x59, 0x19, 0xad, 0x1b, 0xe6, 0x3a, 0xae, 0x6d, 0xcf, 0xfb, 0xb0, 0xe2, 0xe0, 0x07, 0x3e, + 0x35, 0x79, 0x88, 0x07, 0xed, 0x21, 0xf9, 0x2c, 0x3d, 0xce, 0xe7, 0xc1, 0x86, 0x5d, 0xb2, 0x3f, + 0xd1, 0x44, 0x83, 0x1e, 0xa1, 0x64, 0x95, 0x00, 0xc0, 0x82, 0xfd, 0x95, 0xff, 0x38, 0x25, 0xc9, + 0xbf, 0x22, 0x41, 0xdf, 0xfc, 0xd5, 0x35, 0xcd, 0x70, 0xd0, 0x22, 0x8c, 0x06, 0xbe, 0x13, 0x0d, + 0xf5, 0xe3, 0x77, 0x6e, 0x4f, 0xe6, 0x9b, 0xdd, 0xcb, 0x8f, 0xf5, 0xc0, 0x89, 0x45, 0xb0, 0x2f, + 0x76, 0xda, 0xc4, 0x46, 0x58, 0xb5, 0xa0, 0xc8, 0xad, 0x5b, 0xdc, 0x26, 0x35, 0xcb, 0xd0, 0xcf, + 0xa4, 0x75, 0x51, 0x11, 0xd2, 0x36, 0xf9, 0xc1, 0x9f, 0x55, 0x4c, 0x74, 0x74, 0x5f, 0x8a, 0xef, + 0x9f, 0x9c, 0x12, 0x12, 0xf9, 0xd5, 0x04, 0xc0, 0xfc, 0xd5, 0xab, 0x1b, 0x8e, 0x61, 0xd7, 0xb0, + 0x77, 0x37, 0x35, 0xdf, 0x80, 0xc3, 0xa1, 0x1d, 0x93, 0xa3, 0x37, 0x69, 0x3f, 0x75, 0xe7, 0xf6, + 0xe4, 0xf1, 0x66, 0xed, 0x43, 0x68, 0xb2, 0x32, 0x16, 0xec, 0x9d, 0x1c, 0xbd, 0x2d, 0xd7, 0x8a, + 0xeb, 0xf9, 0x5c, 0x93, 0x9d, 0xb9, 0x86, 0xd0, 0xc2, 0x5c, 0xe7, 0x5d, 0xaf, 0xbd, 0x69, 0xd7, + 0x61, 0x20, 0x30, 0x09, 0xa9, 0x64, 0x32, 0x1e, 0xff, 0xcd, 0x2d, 0x2c, 0x77, 0xb6, 0xb0, 0x20, + 0xe3, 0x56, 0xf6, 0x29, 0xe5, 0xff, 0x2b, 0x01, 0x04, 0x3e, 0xfb, 0x93, 0xe9, 0x62, 0x24, 0xa1, + 0xf3, 0xe4, 0x9b, 0x3c, 0x60, 0xd9, 0xc6, 0xe9, 0x9b, 0x2c, 0xfa, 0x73, 0x09, 0x18, 0xdb, 0x14, + 0xd9, 0xe7, 0x27, 0xde, 0x0a, 0x6b, 0xd0, 0x8f, 0x4d, 0xcf, 0x31, 0xa8, 0x19, 0xc8, 0x7c, 0x3f, + 0xd5, 0x69, 0xbe, 0xdb, 0xe8, 0x44, 0xbf, 0x38, 0x24, 0xce, 0xf9, 0x39, 0x9b, 0x26, 0x6b, 0x7c, + 0x38, 0x09, 0xf9, 0x4e, 0x94, 0x68, 0x0e, 0x46, 0x74, 0x07, 0x53, 0x80, 0x1a, 0x3e, 0x58, 0x2c, + 0x15, 0x82, 0x0a, 0xb3, 0x09, 0x41, 0x56, 0x86, 0x05, 0x84, 0xaf, 0x20, 0x55, 0x20, 0xe5, 0x1f, + 0x71, 0x3c, 0x82, 0xd5, 0x63, 0xbd, 0x27, 0xf3, 0x25, 0x44, 0x0c, 0x12, 0x65, 0xc0, 0xd6, 0x90, + 0xe1, 0x00, 0x4a, 0x17, 0x11, 0x17, 0x46, 0x0c, 0xd3, 0xf0, 0x0c, 0xad, 0xa6, 0x6e, 0x69, 0x35, + 0xcd, 0xd4, 0x0f, 0x56, 0x3f, 0xb3, 0xb4, 0xcf, 0x07, 0x6e, 0x62, 0x28, 0x2b, 0xc3, 0x1c, 0x52, + 0x62, 0x00, 0x74, 0x19, 0xfa, 0xc5, 0x60, 0xa9, 0x03, 0xd6, 0x1d, 0x82, 0x41, 0xa8, 0xd8, 0x7b, + 0x35, 0x09, 0xa3, 0x0a, 0xae, 0xfc, 0xe5, 0x74, 0xec, 0x77, 0x3a, 0x56, 0x01, 0x58, 0xd0, 0x93, + 0x44, 0x7b, 0xa0, 0x19, 0x21, 0x89, 0x23, 0xcb, 0x78, 0xcc, 0xbb, 0x5e, 0x68, 0x4e, 0x6e, 0x27, + 0x60, 0x30, 0x3c, 0x27, 0x7f, 0x41, 0xd7, 0x27, 0xb4, 0x18, 0x64, 0xa4, 0x14, 0xff, 0x5e, 0x6b, + 0x87, 0x8c, 0xd4, 0xe2, 0xc1, 0xdd, 0x53, 0xd1, 0x9f, 0x25, 0xa0, 0x6f, 0x4d, 0x73, 0xb4, 0xba, + 0x8b, 0xf4, 0x96, 0xaa, 0x53, 0x1c, 0x4a, 0xb6, 0x7c, 0x95, 0x9b, 0x9f, 0x81, 0xc4, 0x14, 0x9d, + 0x1f, 0x6d, 0x53, 0x74, 0xbe, 0x15, 0x86, 0xc9, 0xf6, 0x38, 0x74, 0xbf, 0x82, 0x58, 0x7b, 0xa8, + 0x74, 0x2c, 0xe0, 0x12, 0xed, 0x67, 0xbb, 0xe7, 0xab, 0xe1, 0x0b, 0x16, 0x03, 0x04, 0x23, 0x48, + 0xd0, 0x84, 0xfc, 0x48, 0xb0, 0x4d, 0x0d, 0x75, 0xca, 0x0a, 0xd4, 0xb5, 0x1b, 0x65, 0xd6, 0x40, + 0x4b, 0x80, 0x76, 0xfc, 0xf3, 0x12, 0x35, 0x30, 0x27, 0xa1, 0xbf, 0xff, 0xce, 0xed, 0xc9, 0x63, + 0x8c, 0xbe, 0x15, 0x47, 0x56, 0x46, 0x03, 0xa0, 0xe0, 0x76, 0x1a, 0x80, 0xe8, 0xa5, 0xb2, 0x3b, + 0x9a, 0x6c, 0xfb, 0x73, 0xf8, 0xce, 0xed, 0xc9, 0x51, 0xc6, 0x25, 0xe8, 0x93, 0x95, 0x2c, 0x69, + 0xcc, 0x93, 0xdf, 0x21, 0xcf, 0xfe, 0x8c, 0x04, 0x28, 0x48, 0xfd, 0x0a, 0x76, 0x6d, 0xb2, 0x5f, + 0x23, 0x45, 0x79, 0xa8, 0x82, 0x96, 0xba, 0x17, 0xe5, 0x01, 0xbd, 0x28, 0xca, 0x43, 0x91, 0x72, + 0x3e, 0x48, 0x92, 0x09, 0x3e, 0x8f, 0x6d, 0x2e, 0xb4, 0x4e, 0xcf, 0x59, 0x86, 0xa0, 0x6e, 0xc9, + 0x89, 0x87, 0xe4, 0xdf, 0x91, 0xe0, 0x58, 0x8b, 0x47, 0xf9, 0xc2, 0xfe, 0x0c, 0x20, 0x27, 0xd4, + 0xc9, 0x3f, 0xbe, 0xc7, 0x84, 0xde, 0xb7, 0x83, 0x8e, 0x3a, 0x2d, 0xb9, 0xf7, 0x6e, 0xe6, 0x79, + 0x76, 0x27, 0xf6, 0x5f, 0x4a, 0x30, 0x1e, 0x16, 0xc0, 0x57, 0x65, 0x05, 0x06, 0xc3, 0xe3, 0x73, + 0x25, 0x1e, 0xea, 0x45, 0x09, 0x2e, 0x7f, 0x84, 0x1e, 0x3d, 0x1f, 0x04, 0x2c, 0x3b, 0x53, 0x7b, + 0xba, 0x67, 0x7b, 0x08, 0x99, 0x9a, 0x03, 0x37, 0x45, 0x67, 0xe4, 0x7d, 0x09, 0x48, 0xad, 0x59, + 0x56, 0x0d, 0xbd, 0x04, 0xa3, 0xa6, 0xe5, 0xa9, 0xc4, 0xb7, 0x70, 0x45, 0xe5, 0xdb, 0x70, 0x96, + 0x09, 0xcb, 0xfb, 0x35, 0xd3, 0x77, 0x6f, 0x4f, 0xb6, 0x32, 0x53, 0x46, 0x4c, 0xcb, 0x2b, 0x51, + 0xc8, 0x06, 0xdb, 0xa4, 0xbf, 0x07, 0x86, 0xa2, 0xc3, 0xb1, 0x4c, 0xf9, 0xc2, 0x01, 0x86, 0x8b, + 0x32, 0xba, 0x73, 0x7b, 0x72, 0x3c, 0x88, 0x1b, 0x1f, 0x2c, 0x2b, 0x83, 0x5b, 0xa1, 0xf1, 0xd9, + 0x0d, 0xb4, 0xef, 0x7f, 0x6a, 0x52, 0x3a, 0xf9, 0x25, 0x09, 0x20, 0x38, 0x8f, 0x40, 0x4f, 0xc0, + 0xd1, 0xd2, 0xea, 0xca, 0xbc, 0xba, 0xbe, 0x31, 0xbb, 0xb1, 0xb9, 0xae, 0x6e, 0xae, 0xac, 0xaf, + 0x95, 0xe7, 0x16, 0x2f, 0x2e, 0x96, 0xe7, 0x83, 0xa3, 0x73, 0xd7, 0xc6, 0x3a, 0xfd, 0x1c, 0x21, + 0x7a, 0x04, 0xc6, 0xa3, 0xd8, 0xa4, 0x55, 0x9e, 0xcf, 0x49, 0x85, 0xc1, 0x9b, 0xb7, 0xa6, 0x32, + 0xac, 0x32, 0xc3, 0x15, 0x74, 0x02, 0x0e, 0xb7, 0xe2, 0x2d, 0xae, 0x2c, 0xe4, 0x12, 0x85, 0xa1, + 0x9b, 0xb7, 0xa6, 0xb2, 0x7e, 0x09, 0x87, 0x64, 0x40, 0x61, 0x4c, 0xce, 0x2f, 0x59, 0x80, 0x9b, + 0xb7, 0xa6, 0xfa, 0x98, 0x09, 0x0b, 0xa9, 0x0f, 0x7c, 0x66, 0xe2, 0x50, 0xe9, 0xad, 0x1d, 0x0f, + 0xc7, 0x1f, 0x89, 0xb1, 0x1e, 0xf7, 0x1b, 0xff, 0x2c, 0xfc, 0xe6, 0x51, 0x98, 0xec, 0x70, 0x16, + 0xee, 0xdd, 0x88, 0x39, 0x06, 0xef, 0x72, 0xe0, 0x1d, 0x7b, 0xa0, 0xdd, 0xe1, 0x08, 0xfd, 0xe0, + 0xc7, 0xdc, 0x3d, 0x9d, 0xe8, 0xcb, 0xff, 0x3a, 0x05, 0x68, 0xd9, 0xad, 0xce, 0x91, 0xc2, 0x2a, + 0x74, 0x7f, 0xac, 0xe9, 0xfc, 0x46, 0xfa, 0x91, 0xce, 0x6f, 0x96, 0x23, 0x27, 0x22, 0x89, 0xfd, + 0x9d, 0xbc, 0xf6, 0x7c, 0x2c, 0x92, 0xfc, 0x31, 0x1d, 0x8b, 0xb4, 0xaf, 0x95, 0x52, 0x77, 0x6f, + 0x73, 0x95, 0x3e, 0xd0, 0xe6, 0xea, 0x22, 0xf4, 0xf1, 0x33, 0xcf, 0xbe, 0x2e, 0x67, 0x9e, 0xf9, + 0x8e, 0x07, 0x9b, 0x9c, 0x1a, 0x9d, 0x11, 0x6f, 0x3c, 0xf5, 0xf7, 0xb6, 0xba, 0xf1, 0x57, 0xa2, + 0x32, 0x1f, 0x10, 0x6b, 0xdb, 0x71, 0x28, 0xb4, 0x3a, 0x94, 0x48, 0xbe, 0xf2, 0x47, 0x92, 0x90, + 0x5b, 0x76, 0xab, 0xe5, 0x8a, 0xe1, 0xdd, 0x23, 0x6f, 0x7b, 0xae, 0xf3, 0x86, 0x15, 0xdd, 0xb9, + 0x3d, 0x39, 0xcc, 0x6c, 0xda, 0xc5, 0x92, 0x16, 0x8c, 0x34, 0x3d, 0x2e, 0xe0, 0xbe, 0x75, 0xf1, + 0x60, 0xcf, 0x2d, 0x9a, 0x98, 0xc9, 0x74, 0x77, 0x11, 0xf2, 0x71, 0xf4, 0x72, 0x7b, 0x87, 0x66, + 0x2e, 0x75, 0xf9, 0xde, 0x9e, 0xf1, 0x05, 0xf3, 0x56, 0x80, 0x7c, 0xf3, 0xc4, 0xf8, 0xb3, 0xf6, + 0xc7, 0x12, 0x0c, 0x2c, 0xbb, 0x62, 0x4f, 0x8d, 0x7f, 0x42, 0xcf, 0x17, 0x9e, 0xf5, 0x5f, 0xe2, + 0x49, 0xf6, 0xe6, 0xbb, 0xe2, 0xc5, 0x9e, 0xc0, 0x08, 0x87, 0x61, 0x2c, 0xa4, 0xa7, 0xaf, 0xff, + 0xef, 0x26, 0x68, 0x96, 0x2c, 0xe1, 0xaa, 0x61, 0xfa, 0x85, 0x05, 0xfe, 0x8b, 0xba, 0x6b, 0x0a, + 0xec, 0x9c, 0x3a, 0xa8, 0x9d, 0x77, 0x69, 0x92, 0x68, 0xb2, 0xa7, 0x5f, 0x35, 0x2e, 0xb7, 0xee, + 0xeb, 0xa5, 0x7d, 0x5c, 0xa2, 0x69, 0xda, 0xbd, 0xcb, 0xaf, 0x4b, 0x30, 0xb4, 0xec, 0x56, 0x37, + 0xcd, 0xca, 0xff, 0xf7, 0xfe, 0xbb, 0x0d, 0x87, 0x23, 0x9a, 0xde, 0x23, 0x93, 0x9e, 0x7a, 0x2d, + 0x05, 0xc9, 0x65, 0xb7, 0x8a, 0x5e, 0x82, 0x91, 0xe6, 0xd2, 0xe1, 0x64, 0xa7, 0xbc, 0xdd, 0xba, + 0x2a, 0x14, 0x4e, 0xf5, 0x8e, 0xeb, 0x6b, 0xb2, 0x0b, 0x43, 0xd1, 0xd5, 0xe3, 0x44, 0x17, 0x26, + 0x11, 0xcc, 0xc2, 0x53, 0xbd, 0x62, 0xfa, 0x83, 0xfd, 0x14, 0x64, 0xfc, 0xa4, 0xf7, 0x60, 0x17, + 0x6a, 0x81, 0x54, 0x78, 0xbc, 0x07, 0x24, 0x9f, 0xfb, 0x4b, 0x30, 0xd2, 0x9c, 0x52, 0xba, 0x59, + 0xaf, 0x09, 0xb7, 0xab, 0xf5, 0x3a, 0x85, 0xd6, 0x16, 0x40, 0x28, 0x0e, 0x1e, 0xee, 0xc2, 0x21, + 0x40, 0x2b, 0x3c, 0xd9, 0x13, 0x9a, 0xbf, 0xc1, 0xba, 0x7b, 0xc5, 0xf8, 0x6f, 0x25, 0xe0, 0x64, + 0xb8, 0xcc, 0x7d, 0xa9, 0x81, 0x9d, 0x3d, 0xbf, 0x92, 0xb5, 0xb5, 0xaa, 0x61, 0x86, 0xdf, 0x68, + 0x3c, 0x16, 0x8e, 0x17, 0x8a, 0x2b, 0x24, 0x95, 0x4d, 0x18, 0x58, 0xd3, 0xaa, 0x58, 0xc1, 0x2f, + 0x35, 0xb0, 0xeb, 0xb5, 0x79, 0xf5, 0xec, 0x08, 0xf4, 0x59, 0xdb, 0xdb, 0xe2, 0x06, 0x5a, 0x4a, + 0xe1, 0x2d, 0x34, 0x0e, 0xe9, 0x9a, 0x51, 0x37, 0x58, 0x4c, 0xa6, 0x14, 0xd6, 0x40, 0x93, 0x30, + 0xa0, 0x93, 0xd0, 0x53, 0xd9, 0x95, 0xfd, 0x94, 0xf8, 0xec, 0x55, 0xc3, 0xf4, 0x36, 0x08, 0x44, + 0x7e, 0x0e, 0x06, 0xd9, 0x78, 0xdc, 0xee, 0xc7, 0x20, 0x43, 0xaf, 0x58, 0x07, 0xa3, 0xf6, 0x93, + 0xf6, 0x15, 0xf6, 0x9a, 0x1a, 0xe3, 0xc2, 0x06, 0x66, 0x8d, 0xd2, 0x7c, 0x47, 0x23, 0x9e, 0xec, + 0xa5, 0x1a, 0x60, 0xa6, 0xf2, 0x0d, 0xf9, 0x9b, 0x69, 0x38, 0xcc, 0x77, 0x20, 0x9a, 0x6d, 0xcc, + 0xec, 0x78, 0x9e, 0x78, 0x59, 0x1c, 0x78, 0xf8, 0x6b, 0xb6, 0x21, 0xef, 0x41, 0xea, 0x92, 0xe7, + 0xd9, 0xe8, 0x24, 0xa4, 0x9d, 0x46, 0x0d, 0x8b, 0xc7, 0x32, 0x7e, 0x29, 0xa9, 0xd9, 0xc6, 0x34, + 0x41, 0x50, 0x1a, 0x35, 0xac, 0x30, 0x14, 0x54, 0x86, 0xc9, 0xed, 0x46, 0xad, 0xb6, 0xa7, 0x56, + 0x30, 0xfd, 0x1f, 0x87, 0xfe, 0x7f, 0x09, 0xc2, 0x37, 0x6c, 0xcd, 0xf4, 0x2b, 0xfe, 0x8c, 0x72, + 0x9c, 0xa2, 0xcd, 0x53, 0x2c, 0xf1, 0x1f, 0x82, 0xca, 0x02, 0x47, 0xfe, 0xfd, 0x04, 0x64, 0x04, + 0x6b, 0xfa, 0xe6, 0x18, 0xae, 0x61, 0xdd, 0xb3, 0xc4, 0xe5, 0x06, 0xbf, 0x8d, 0x10, 0x24, 0xab, + 0x7c, 0x92, 0xb2, 0x97, 0x0e, 0x29, 0xa4, 0x41, 0x60, 0xfe, 0xfb, 0x7c, 0x04, 0x66, 0x37, 0xc8, + 0xbc, 0xa5, 0x6c, 0x4b, 0x9c, 0x9b, 0x5e, 0x3a, 0xa4, 0xd0, 0x16, 0xca, 0x43, 0x1f, 0x71, 0x57, + 0x8f, 0x7d, 0x7e, 0x99, 0xc0, 0x79, 0x1b, 0x1d, 0x81, 0xb4, 0xad, 0x79, 0x3a, 0xbb, 0x68, 0x4f, + 0x3a, 0x58, 0x93, 0x24, 0x65, 0xf6, 0x21, 0x8c, 0xe6, 0x7f, 0x20, 0x46, 0x8c, 0xc1, 0xbe, 0x38, + 0x4a, 0xe4, 0x5e, 0xd3, 0x3c, 0x0f, 0x3b, 0x26, 0x61, 0xc8, 0xd0, 0xe9, 0x4b, 0xa2, 0x56, 0x65, + 0x8f, 0xff, 0x53, 0x33, 0xfa, 0x9b, 0xff, 0x17, 0x25, 0xea, 0x11, 0x2a, 0xed, 0x64, 0xff, 0xcb, + 0x71, 0x50, 0x00, 0x4b, 0x04, 0xa9, 0x0c, 0x63, 0x5a, 0xa5, 0x62, 0xb0, 0xff, 0x2f, 0xa6, 0x6e, + 0x19, 0x74, 0x2f, 0xec, 0xd2, 0xff, 0xd4, 0xd9, 0x69, 0x2e, 0x50, 0x40, 0x50, 0xe2, 0xf8, 0xa5, + 0x2c, 0xf4, 0xdb, 0x4c, 0x28, 0xf9, 0x02, 0x8c, 0xb6, 0x48, 0x4a, 0xe4, 0xdb, 0x35, 0xcc, 0x8a, + 0x78, 0xc9, 0x91, 0xfc, 0x26, 0x30, 0xfa, 0x8d, 0x60, 0x76, 0x6d, 0x84, 0xfe, 0x2e, 0xbd, 0xb7, + 0xf3, 0x9b, 0xbd, 0xc3, 0xa1, 0x37, 0x7b, 0x35, 0xdb, 0x28, 0x65, 0x29, 0x7f, 0xfe, 0x42, 0xef, + 0x6c, 0xeb, 0x0b, 0xbd, 0x55, 0x6c, 0x8a, 0x1d, 0x2e, 0xe9, 0xd2, 0x6c, 0xc3, 0xa5, 0xee, 0x18, + 0x7c, 0xb3, 0xd8, 0xbd, 0x10, 0xfa, 0x4d, 0x5f, 0xf0, 0x4d, 0x2d, 0xcc, 0xae, 0x2d, 0xfa, 0x7e, + 0xfc, 0x95, 0x04, 0x1c, 0x0f, 0xf9, 0x71, 0x08, 0xb9, 0xd5, 0x9d, 0x0b, 0xed, 0x3d, 0xbe, 0x87, + 0x97, 0xff, 0xaf, 0x40, 0x8a, 0xe0, 0xa3, 0x98, 0xff, 0x71, 0x94, 0xff, 0xd5, 0xaf, 0xff, 0x0b, + 0x39, 0xba, 0xd9, 0x8a, 0xcc, 0x0a, 0x65, 0x52, 0x7a, 0x7f, 0xef, 0xf6, 0xcb, 0x05, 0x9f, 0x6b, + 0x76, 0xef, 0x9e, 0x19, 0x9b, 0x6d, 0x78, 0xfb, 0x0c, 0xc8, 0x1d, 0xce, 0x06, 0x58, 0xce, 0xec, + 0x7e, 0xc8, 0xb1, 0x8f, 0x84, 0xdc, 0xe9, 0xbd, 0xc1, 0x6e, 0x33, 0xd8, 0xe3, 0xb9, 0xc5, 0x0d, + 0x38, 0xf2, 0x3c, 0x19, 0x3b, 0x38, 0xc1, 0x16, 0xa9, 0xfd, 0x88, 0x7f, 0xf1, 0x46, 0xe2, 0xff, + 0x28, 0x95, 0x1d, 0x66, 0x5d, 0x04, 0x08, 0xe4, 0xe3, 0xa7, 0x10, 0x8f, 0x4c, 0x77, 0x5c, 0x31, + 0xa6, 0x43, 0xcb, 0x85, 0x12, 0xa2, 0x94, 0x7f, 0x59, 0x82, 0xa3, 0x2d, 0x43, 0xf3, 0x2c, 0xbf, + 0xd0, 0xe6, 0x15, 0xc7, 0x9e, 0x6f, 0xfd, 0x85, 0x5f, 0x77, 0x5c, 0x68, 0x23, 0xec, 0xa3, 0xb1, + 0xc2, 0x32, 0x29, 0x22, 0xd2, 0xbe, 0x05, 0x0e, 0x47, 0x85, 0x15, 0x66, 0x7a, 0x18, 0x86, 0xa3, + 0x45, 0x29, 0x37, 0xd7, 0x50, 0xa4, 0x2c, 0x95, 0xd5, 0x66, 0x3b, 0xfb, 0xba, 0x96, 0x21, 0xeb, + 0xa3, 0xf2, 0x5a, 0xb2, 0x67, 0x55, 0x03, 0x4a, 0xf9, 0x55, 0x09, 0xa6, 0xa2, 0x23, 0x04, 0xbb, + 0x53, 0x77, 0x7f, 0xc2, 0xde, 0xb5, 0x29, 0x7e, 0x5d, 0x82, 0x07, 0xba, 0xc8, 0xc4, 0x0d, 0xf0, + 0x32, 0x8c, 0x87, 0x0e, 0xe9, 0x45, 0x0a, 0x17, 0xd3, 0x7e, 0x32, 0xfe, 0xe9, 0x82, 0x5f, 0x30, + 0xdd, 0x47, 0x8c, 0xf2, 0xb9, 0x3f, 0x9c, 0x1c, 0x6b, 0xed, 0x73, 0x95, 0xb1, 0xd6, 0x63, 0xf5, + 0xbb, 0xe8, 0x1f, 0xaf, 0x49, 0xf0, 0x58, 0x54, 0xd5, 0x36, 0x4f, 0xd0, 0xdf, 0xa8, 0x79, 0xf8, + 0x0f, 0x12, 0x9c, 0xec, 0x45, 0x38, 0xbf, 0xb6, 0x1d, 0x0b, 0x1e, 0x95, 0x35, 0xcf, 0xc7, 0xe3, + 0xfb, 0xb8, 0x6b, 0xc0, 0xbd, 0x14, 0xf9, 0xdc, 0xee, 0x81, 0xe1, 0x6d, 0x1e, 0x58, 0xe1, 0x29, + 0xf7, 0x8d, 0x1c, 0xdd, 0x79, 0x0a, 0x23, 0x47, 0xf6, 0x9e, 0x6d, 0xe6, 0x22, 0xd1, 0x66, 0x2e, + 0x42, 0x7b, 0xc3, 0x6b, 0x3c, 0x6f, 0xb5, 0x79, 0x3c, 0xf6, 0x4e, 0x18, 0x6b, 0xe3, 0xca, 0x3c, + 0xaa, 0xf7, 0xe1, 0xc9, 0x0a, 0x6a, 0x75, 0x56, 0x79, 0x0f, 0x26, 0xe9, 0xb8, 0x6d, 0x0c, 0x7d, + 0xaf, 0x55, 0xae, 0xf3, 0xdc, 0xd2, 0x76, 0x68, 0xae, 0xfb, 0x22, 0xf4, 0xb1, 0x79, 0xe6, 0xea, + 0x1e, 0xc0, 0x51, 0x38, 0x03, 0xf9, 0xe3, 0x22, 0x97, 0xcd, 0x0b, 0xb1, 0xdb, 0xc7, 0x50, 0x2f, + 0xba, 0xde, 0xa5, 0x18, 0x0a, 0x19, 0xe3, 0x9b, 0x22, 0xab, 0xb5, 0x97, 0x8e, 0x9b, 0x43, 0xbf, + 0x6b, 0x59, 0x8d, 0xd9, 0xe6, 0xde, 0xa6, 0xaf, 0x5f, 0x14, 0xe9, 0xcb, 0xd7, 0x29, 0x26, 0x7d, + 0xbd, 0x31, 0xa6, 0xf7, 0x13, 0x59, 0x8c, 0x98, 0x7f, 0x1e, 0x13, 0xd9, 0xf7, 0x25, 0x38, 0x46, + 0x75, 0x0b, 0x3f, 0x71, 0xdd, 0xaf, 0xc9, 0x9f, 0x00, 0xe4, 0x3a, 0xba, 0xda, 0x36, 0xba, 0x73, + 0xae, 0xa3, 0x5f, 0x8d, 0xac, 0x2f, 0x4f, 0x00, 0xaa, 0xb8, 0x5e, 0x33, 0x36, 0xbb, 0xd0, 0x9e, + 0xab, 0xb8, 0xde, 0xd5, 0x2e, 0xab, 0x51, 0xea, 0x2e, 0x4c, 0xe7, 0x37, 0x24, 0x28, 0xb4, 0x53, + 0x99, 0x4f, 0x9f, 0x01, 0x47, 0x22, 0xcf, 0xef, 0x9b, 0x67, 0xf0, 0x89, 0x5e, 0x9e, 0x59, 0x37, + 0x85, 0xd1, 0x61, 0x07, 0xdf, 0xeb, 0x3a, 0x60, 0x32, 0xea, 0xa1, 0xad, 0x95, 0xf5, 0x1b, 0x16, + 0x3e, 0x5f, 0x6c, 0xc9, 0xab, 0x7f, 0x2e, 0x6a, 0xef, 0x1b, 0x30, 0xd1, 0x41, 0xea, 0x7b, 0xbd, + 0xee, 0xed, 0x74, 0x9c, 0xcc, 0xbb, 0x5d, 0xbe, 0x9f, 0xe6, 0x91, 0x10, 0x7d, 0x65, 0x2a, 0xb4, + 0x17, 0x6b, 0xf7, 0x12, 0xb7, 0xfc, 0x02, 0xdc, 0xd7, 0x96, 0x8a, 0xcb, 0x56, 0x84, 0xd4, 0x8e, + 0xe1, 0x7a, 0x5c, 0xac, 0x47, 0x3a, 0x89, 0xd5, 0x44, 0x4d, 0x69, 0x64, 0x04, 0x39, 0xca, 0x7a, + 0xcd, 0xb2, 0x6a, 0x5c, 0x0c, 0xf9, 0x0a, 0x8c, 0x86, 0x60, 0x7c, 0x90, 0xb3, 0x90, 0xb2, 0x2d, + 0xfe, 0xd9, 0xa2, 0x81, 0x53, 0xc7, 0x3b, 0x0d, 0x42, 0x68, 0xb8, 0xda, 0x14, 0x5f, 0x1e, 0x07, + 0xc4, 0x98, 0xd1, 0xeb, 0x5d, 0x62, 0x88, 0x75, 0x18, 0x8b, 0x40, 0xf9, 0x20, 0x6f, 0x82, 0x3e, + 0x9b, 0x42, 0xfc, 0x97, 0x63, 0x3b, 0x0d, 0x43, 0xb1, 0xfc, 0x0f, 0xc5, 0xd0, 0xd6, 0xa9, 0xef, + 0x1e, 0x86, 0x34, 0xe5, 0x8a, 0x3e, 0x26, 0x01, 0x84, 0x2e, 0x6b, 0x4d, 0x77, 0x62, 0xd3, 0x7e, + 0x4f, 0x5c, 0x98, 0xe9, 0x19, 0x9f, 0xd7, 0x6c, 0x27, 0xdf, 0xfb, 0x6f, 0xbe, 0xf3, 0xe1, 0xc4, + 0x43, 0x48, 0x9e, 0xe9, 0xb0, 0x1b, 0x0f, 0xc5, 0xcb, 0x67, 0x23, 0xdf, 0xcc, 0x79, 0xb2, 0xb7, + 0xa1, 0x84, 0x64, 0xd3, 0xbd, 0xa2, 0x73, 0xc1, 0x2e, 0x50, 0xc1, 0xce, 0xa0, 0x67, 0xe2, 0x05, + 0x9b, 0x79, 0x57, 0x34, 0x68, 0xde, 0x8d, 0xfe, 0xad, 0x04, 0xe3, 0xed, 0xb6, 0x74, 0xe8, 0x5c, + 0x6f, 0x52, 0xb4, 0x96, 0x14, 0x85, 0xf3, 0x07, 0xa0, 0xe4, 0xaa, 0x2c, 0x50, 0x55, 0x66, 0xd1, + 0x73, 0x07, 0x50, 0x65, 0x26, 0xb4, 0xee, 0xa0, 0xff, 0x23, 0xc1, 0xfd, 0x5d, 0x77, 0x48, 0x68, + 0xb6, 0x37, 0x29, 0xbb, 0xd4, 0x4e, 0x85, 0xd2, 0x8f, 0xc2, 0x82, 0x6b, 0xfc, 0x3c, 0xd5, 0xf8, + 0x0a, 0x5a, 0x3c, 0x88, 0xc6, 0x41, 0x45, 0x14, 0xd6, 0xfd, 0xb7, 0xa3, 0xd7, 0xff, 0xbb, 0xbb, + 0x53, 0xcb, 0xc6, 0x23, 0x26, 0x30, 0x5a, 0x8b, 0x5a, 0xf9, 0xed, 0x54, 0x05, 0x05, 0xad, 0xfd, + 0x88, 0x93, 0x36, 0xf3, 0xae, 0x68, 0xe2, 0x7f, 0x37, 0xfa, 0x5f, 0x52, 0xfb, 0xbb, 0xfc, 0xcf, + 0x76, 0x15, 0xb1, 0xf3, 0xa6, 0xaa, 0x70, 0x6e, 0xff, 0x84, 0x5c, 0xc9, 0x3a, 0x55, 0xb2, 0x8a, + 0xf0, 0xdd, 0x56, 0xb2, 0xed, 0x24, 0xa2, 0xaf, 0x49, 0x30, 0xde, 0x6e, 0x4f, 0x12, 0x13, 0x96, + 0x5d, 0x36, 0x59, 0x31, 0x61, 0xd9, 0x6d, 0x03, 0x24, 0xbf, 0x89, 0x2a, 0x7f, 0x16, 0x9d, 0xee, + 0xa4, 0x7c, 0xd7, 0x59, 0x24, 0xb1, 0xd8, 0xb5, 0xc8, 0x8f, 0x89, 0xc5, 0x5e, 0xf6, 0x31, 0x31, + 0xb1, 0xd8, 0xd3, 0x1e, 0x23, 0x3e, 0x16, 0x7d, 0xcd, 0x7a, 0x9c, 0x46, 0x17, 0x7d, 0x45, 0x82, + 0xa1, 0x48, 0x45, 0x8c, 0x9e, 0xee, 0x2a, 0x68, 0xbb, 0x0d, 0x43, 0xe7, 0x87, 0x9a, 0x9d, 0x0b, + 0x6e, 0x79, 0x91, 0xea, 0x32, 0x87, 0x66, 0x0f, 0xa2, 0x8b, 0x13, 0x91, 0xf8, 0x1b, 0x12, 0x8c, + 0xb5, 0xa9, 0x32, 0x63, 0xa2, 0xb0, 0x73, 0xd1, 0x5c, 0x38, 0xb7, 0x7f, 0x42, 0xae, 0xd5, 0x45, + 0xaa, 0xd5, 0x5b, 0xd1, 0x5b, 0x0e, 0xa2, 0x55, 0x68, 0x7d, 0xbe, 0x1d, 0x5c, 0x89, 0x0e, 0x8d, + 0x83, 0xce, 0xee, 0x53, 0x30, 0xa1, 0xd0, 0xb3, 0xfb, 0xa6, 0xe3, 0xfa, 0xbc, 0x8d, 0xea, 0xf3, + 0x3c, 0x5a, 0xfd, 0xd1, 0xf4, 0x69, 0x5d, 0xd6, 0xbf, 0xd0, 0xfa, 0xca, 0x7e, 0x77, 0x2f, 0x6a, + 0x5b, 0xac, 0x16, 0x9e, 0xd9, 0x17, 0x0d, 0x57, 0xea, 0x1c, 0x55, 0xea, 0x14, 0x7a, 0xaa, 0x93, + 0x52, 0xa1, 0x7b, 0xef, 0x86, 0xb9, 0x6d, 0xcd, 0xbc, 0x8b, 0x95, 0xc0, 0xef, 0x46, 0x3f, 0x2b, + 0xf1, 0x1b, 0xc7, 0x27, 0xba, 0x8e, 0x1b, 0xaa, 0x63, 0x0b, 0x8f, 0xf5, 0x80, 0xc9, 0xe5, 0x7a, + 0x88, 0xca, 0x35, 0x81, 0x8e, 0x77, 0x92, 0x8b, 0xd4, 0xb2, 0xe8, 0x83, 0x92, 0xff, 0x9a, 0xc2, + 0xc9, 0xee, 0xbc, 0xc3, 0xc5, 0x6e, 0xe7, 0x4b, 0x0e, 0x6d, 0x4a, 0x60, 0xf9, 0x11, 0x2a, 0xc9, + 0x14, 0x9a, 0xe8, 0x28, 0x09, 0x2b, 0x7d, 0xef, 0xda, 0xad, 0x81, 0xff, 0x17, 0x00, 0x00, 0xff, + 0xff, 0xa3, 0xd0, 0x74, 0x7c, 0xff, 0x91, 0x00, 0x00, } r := bytes.NewReader(gzipped) gzipr, err := compress_gzip.NewReader(r) @@ -1823,7 +1822,7 @@ func StakingDescription() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descri if err != nil { panic(err) } - if err := github_com_gogo_protobuf_proto.Unmarshal(ungzipped, d); err != nil { + if err := github_com_cosmos_gogoproto_proto.Unmarshal(ungzipped, d); err != nil { panic(err) } return d @@ -2197,7 +2196,7 @@ func (m *Commission) MarshalToSizedBuffer(dAtA []byte) (int, error) { _ = i var l int _ = l - n2, err2 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.UpdateTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.UpdateTime):]) + n2, err2 := github_com_cosmos_gogoproto_types.StdTimeMarshalTo(m.UpdateTime, dAtA[i-github_com_cosmos_gogoproto_types.SizeOfStdTime(m.UpdateTime):]) if err2 != nil { return 0, err2 } @@ -2316,7 +2315,7 @@ func (m *Validator) MarshalToSizedBuffer(dAtA []byte) (int, error) { } i-- dAtA[i] = 0x52 - n5, err5 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.UnbondingTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.UnbondingTime):]) + n5, err5 := github_com_cosmos_gogoproto_types.StdTimeMarshalTo(m.UnbondingTime, dAtA[i-github_com_cosmos_gogoproto_types.SizeOfStdTime(m.UnbondingTime):]) if err5 != nil { return 0, err5 } @@ -2721,7 +2720,7 @@ func (m *UnbondingDelegationEntry) MarshalToSizedBuffer(dAtA []byte) (int, error } i-- dAtA[i] = 0x1a - n8, err8 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.CompletionTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.CompletionTime):]) + n8, err8 := github_com_cosmos_gogoproto_types.StdTimeMarshalTo(m.CompletionTime, dAtA[i-github_com_cosmos_gogoproto_types.SizeOfStdTime(m.CompletionTime):]) if err8 != nil { return 0, err8 } @@ -2777,7 +2776,7 @@ func (m *RedelegationEntry) MarshalToSizedBuffer(dAtA []byte) (int, error) { } i-- dAtA[i] = 0x1a - n9, err9 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.CompletionTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.CompletionTime):]) + n9, err9 := github_com_cosmos_gogoproto_types.StdTimeMarshalTo(m.CompletionTime, dAtA[i-github_com_cosmos_gogoproto_types.SizeOfStdTime(m.CompletionTime):]) if err9 != nil { return 0, err9 } @@ -2893,7 +2892,7 @@ func (m *Params) MarshalToSizedBuffer(dAtA []byte) (int, error) { i-- dAtA[i] = 0x10 } - n10, err10 := github_com_gogo_protobuf_types.StdDurationMarshalTo(m.UnbondingTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdDuration(m.UnbondingTime):]) + n10, err10 := github_com_cosmos_gogoproto_types.StdDurationMarshalTo(m.UnbondingTime, dAtA[i-github_com_cosmos_gogoproto_types.SizeOfStdDuration(m.UnbondingTime):]) if err10 != nil { return 0, err10 } @@ -3131,7 +3130,7 @@ func (m *Commission) Size() (n int) { _ = l l = m.CommissionRates.Size() n += 1 + l + sovStaking(uint64(l)) - l = github_com_gogo_protobuf_types.SizeOfStdTime(m.UpdateTime) + l = github_com_cosmos_gogoproto_types.SizeOfStdTime(m.UpdateTime) n += 1 + l + sovStaking(uint64(l)) return n } @@ -3194,7 +3193,7 @@ func (m *Validator) Size() (n int) { if m.UnbondingHeight != 0 { n += 1 + sovStaking(uint64(m.UnbondingHeight)) } - l = github_com_gogo_protobuf_types.SizeOfStdTime(m.UnbondingTime) + l = github_com_cosmos_gogoproto_types.SizeOfStdTime(m.UnbondingTime) n += 1 + l + sovStaking(uint64(l)) l = m.Commission.Size() n += 1 + l + sovStaking(uint64(l)) @@ -3337,7 +3336,7 @@ func (m *UnbondingDelegationEntry) Size() (n int) { if m.CreationHeight != 0 { n += 1 + sovStaking(uint64(m.CreationHeight)) } - l = github_com_gogo_protobuf_types.SizeOfStdTime(m.CompletionTime) + l = github_com_cosmos_gogoproto_types.SizeOfStdTime(m.CompletionTime) n += 1 + l + sovStaking(uint64(l)) l = m.InitialBalance.Size() n += 1 + l + sovStaking(uint64(l)) @@ -3355,7 +3354,7 @@ func (m *RedelegationEntry) Size() (n int) { if m.CreationHeight != 0 { n += 1 + sovStaking(uint64(m.CreationHeight)) } - l = github_com_gogo_protobuf_types.SizeOfStdTime(m.CompletionTime) + l = github_com_cosmos_gogoproto_types.SizeOfStdTime(m.CompletionTime) n += 1 + l + sovStaking(uint64(l)) l = m.InitialBalance.Size() n += 1 + l + sovStaking(uint64(l)) @@ -3397,7 +3396,7 @@ func (m *Params) Size() (n int) { } var l int _ = l - l = github_com_gogo_protobuf_types.SizeOfStdDuration(m.UnbondingTime) + l = github_com_cosmos_gogoproto_types.SizeOfStdDuration(m.UnbondingTime) n += 1 + l + sovStaking(uint64(l)) if m.MaxValidators != 0 { n += 1 + sovStaking(uint64(m.MaxValidators)) @@ -3855,7 +3854,7 @@ func (m *Commission) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.UpdateTime, dAtA[iNdEx:postIndex]); err != nil { + if err := github_com_cosmos_gogoproto_types.StdTimeUnmarshal(&m.UpdateTime, dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -4375,7 +4374,7 @@ func (m *Validator) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.UnbondingTime, dAtA[iNdEx:postIndex]); err != nil { + if err := github_com_cosmos_gogoproto_types.StdTimeUnmarshal(&m.UnbondingTime, dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -5350,7 +5349,7 @@ func (m *UnbondingDelegationEntry) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.CompletionTime, dAtA[iNdEx:postIndex]); err != nil { + if err := github_com_cosmos_gogoproto_types.StdTimeUnmarshal(&m.CompletionTime, dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -5520,7 +5519,7 @@ func (m *RedelegationEntry) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.CompletionTime, dAtA[iNdEx:postIndex]); err != nil { + if err := github_com_cosmos_gogoproto_types.StdTimeUnmarshal(&m.CompletionTime, dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -5851,7 +5850,7 @@ func (m *Params) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if err := github_com_gogo_protobuf_types.StdDurationUnmarshal(&m.UnbondingTime, dAtA[iNdEx:postIndex]); err != nil { + if err := github_com_cosmos_gogoproto_types.StdDurationUnmarshal(&m.UnbondingTime, dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex diff --git a/staking/tx.pb.go b/staking/tx.pb.go index 1f55015..be4392e 100644 --- a/staking/tx.pb.go +++ b/staking/tx.pb.go @@ -6,10 +6,10 @@ package staking import ( context "context" fmt "fmt" + grpc1 "github.com/cosmos/gogoproto/grpc" + proto "github.com/cosmos/gogoproto/proto" + github_com_cosmos_gogoproto_types "github.com/cosmos/gogoproto/types" _ "github.com/gogo/protobuf/gogoproto" - grpc1 "github.com/gogo/protobuf/grpc" - proto "github.com/gogo/protobuf/proto" - github_com_gogo_protobuf_types "github.com/gogo/protobuf/types" types "github.com/irisnet/core-sdk-go/common/codec/types" github_com_irisnet_core_sdk_go_types "github.com/irisnet/core-sdk-go/types" types1 "github.com/irisnet/core-sdk-go/types" @@ -1107,7 +1107,7 @@ func (m *MsgBeginRedelegateResponse) MarshalToSizedBuffer(dAtA []byte) (int, err _ = i var l int _ = l - n8, err8 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.CompletionTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.CompletionTime):]) + n8, err8 := github_com_cosmos_gogoproto_types.StdTimeMarshalTo(m.CompletionTime, dAtA[i-github_com_cosmos_gogoproto_types.SizeOfStdTime(m.CompletionTime):]) if err8 != nil { return 0, err8 } @@ -1185,7 +1185,7 @@ func (m *MsgUndelegateResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { _ = i var l int _ = l - n10, err10 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.CompletionTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.CompletionTime):]) + n10, err10 := github_com_cosmos_gogoproto_types.StdTimeMarshalTo(m.CompletionTime, dAtA[i-github_com_cosmos_gogoproto_types.SizeOfStdTime(m.CompletionTime):]) if err10 != nil { return 0, err10 } @@ -1334,7 +1334,7 @@ func (m *MsgBeginRedelegateResponse) Size() (n int) { } var l int _ = l - l = github_com_gogo_protobuf_types.SizeOfStdTime(m.CompletionTime) + l = github_com_cosmos_gogoproto_types.SizeOfStdTime(m.CompletionTime) n += 1 + l + sovTx(uint64(l)) return n } @@ -1364,7 +1364,7 @@ func (m *MsgUndelegateResponse) Size() (n int) { } var l int _ = l - l = github_com_gogo_protobuf_types.SizeOfStdTime(m.CompletionTime) + l = github_com_cosmos_gogoproto_types.SizeOfStdTime(m.CompletionTime) n += 1 + l + sovTx(uint64(l)) return n } @@ -2379,7 +2379,7 @@ func (m *MsgBeginRedelegateResponse) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.CompletionTime, dAtA[iNdEx:postIndex]); err != nil { + if err := github_com_cosmos_gogoproto_types.StdTimeUnmarshal(&m.CompletionTime, dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -2609,7 +2609,7 @@ func (m *MsgUndelegateResponse) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.CompletionTime, dAtA[iNdEx:postIndex]); err != nil { + if err := github_com_cosmos_gogoproto_types.StdTimeUnmarshal(&m.CompletionTime, dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex diff --git a/store/commit_info.pb.go b/store/commit_info.pb.go index a3b2597..bcfdeff 100644 --- a/store/commit_info.pb.go +++ b/store/commit_info.pb.go @@ -5,12 +5,11 @@ package store import ( fmt "fmt" - + proto "github.com/cosmos/gogoproto/proto" + _ "github.com/gogo/protobuf/gogoproto" io "io" math "math" math_bits "math/bits" - _ "github.com/gogo/protobuf/gogoproto" - proto "github.com/gogo/protobuf/proto" ) // Reference imports to suppress errors if they are not otherwise used. @@ -196,27 +195,26 @@ func init() { } var fileDescriptor_5f8c656cdef8c524 = []byte{ - // 308 bytes of a gzipped FileDescriptorProto + // 302 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x7c, 0x91, 0xb1, 0x4e, 0xf3, 0x30, - 0x14, 0x85, 0xe3, 0x36, 0xfa, 0xff, 0xd6, 0x65, 0xb2, 0x18, 0x02, 0x83, 0x5b, 0x15, 0x84, 0x2a, - 0xa4, 0xda, 0x6a, 0xd9, 0x18, 0x18, 0x4a, 0x85, 0x54, 0xb1, 0x85, 0x8d, 0x05, 0x25, 0xa9, 0x9b, - 0x5a, 0x28, 0xb9, 0x55, 0xae, 0xa9, 0xc4, 0x5b, 0x30, 0x32, 0xf2, 0x38, 0x1d, 0x3b, 0x32, 0x21, - 0x94, 0xbc, 0x08, 0x8a, 0x93, 0xb0, 0xd1, 0xed, 0xdc, 0xdc, 0x73, 0xcf, 0xa7, 0x13, 0xd3, 0x8b, - 0x08, 0x30, 0x01, 0x94, 0x68, 0x20, 0x53, 0x72, 0x3b, 0x09, 0x95, 0x09, 0x26, 0x32, 0x82, 0x24, - 0xd1, 0xe6, 0x49, 0xa7, 0x2b, 0x10, 0x9b, 0x0c, 0x0c, 0xb0, 0x93, 0xca, 0x27, 0xc2, 0x00, 0x95, - 0xb0, 0x66, 0x51, 0x9b, 0x4f, 0x8f, 0x63, 0x88, 0xc1, 0xba, 0x64, 0xa9, 0xaa, 0x83, 0x21, 0x52, - 0x7a, 0x6b, 0x53, 0x16, 0xe9, 0x0a, 0x98, 0x47, 0xff, 0x6f, 0x55, 0x86, 0x1a, 0x52, 0x8f, 0x0c, - 0xc8, 0xa8, 0xed, 0x37, 0x23, 0xbb, 0xa7, 0x3d, 0x1b, 0x67, 0x61, 0xe8, 0xb5, 0x06, 0xed, 0x51, - 0x6f, 0x7a, 0x2e, 0xfe, 0xc4, 0x89, 0x87, 0x72, 0x2a, 0x43, 0x67, 0xee, 0xee, 0xab, 0xef, 0xf8, - 0x14, 0x9b, 0x0f, 0x38, 0x8c, 0x69, 0xf7, 0x77, 0xcd, 0x18, 0x75, 0xd3, 0x20, 0x51, 0x16, 0xd8, - 0xf5, 0xad, 0x66, 0x77, 0xb4, 0xdb, 0x74, 0x5b, 0x7a, 0xad, 0x01, 0x19, 0xf5, 0xa6, 0x67, 0x07, - 0x58, 0x75, 0x83, 0x79, 0x8d, 0xea, 0x54, 0xb7, 0x8b, 0xe5, 0xf0, 0x86, 0x76, 0x9a, 0xdd, 0x81, - 0x6e, 0x8c, 0xba, 0xeb, 0x00, 0xd7, 0x16, 0x74, 0xe4, 0x5b, 0x7d, 0xed, 0xbe, 0x7f, 0xf4, 0x9d, - 0xd9, 0x7c, 0x97, 0x73, 0xb2, 0xcf, 0x39, 0xf9, 0xce, 0x39, 0x79, 0x2b, 0xb8, 0xb3, 0x2f, 0xb8, - 0xf3, 0x59, 0x70, 0xe7, 0xf1, 0x32, 0xd6, 0x66, 0xfd, 0x12, 0x8a, 0x08, 0x12, 0xa9, 0x33, 0x8d, - 0xa9, 0x32, 0x32, 0x82, 0x4c, 0x8d, 0x71, 0xf9, 0x3c, 0x8e, 0x41, 0x9a, 0xd7, 0x8d, 0xaa, 0x9f, - 0x2b, 0xfc, 0x67, 0x7f, 0xf5, 0xd5, 0x4f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x05, 0x9c, 0x35, 0x79, - 0xc5, 0x01, 0x00, 0x00, + 0x14, 0x85, 0xe3, 0x36, 0xfa, 0xff, 0xd6, 0x65, 0xb2, 0x18, 0x02, 0x83, 0x5b, 0x95, 0x0a, 0x75, + 0xa9, 0xad, 0x96, 0x8d, 0xa1, 0x43, 0x41, 0x48, 0x15, 0x5b, 0xd8, 0x58, 0x50, 0x92, 0xba, 0x89, + 0x85, 0x92, 0x8b, 0x72, 0x4d, 0x9f, 0x83, 0x91, 0x91, 0xc7, 0xe9, 0xd8, 0x91, 0x09, 0xa1, 0xe4, + 0x45, 0x50, 0x9c, 0x84, 0x8d, 0x6e, 0xe7, 0xe6, 0x9e, 0x7b, 0x3e, 0x9d, 0x98, 0x5e, 0x46, 0x80, + 0x29, 0xa0, 0x44, 0x03, 0xb9, 0x92, 0xbb, 0x79, 0xa8, 0x4c, 0x30, 0x97, 0x11, 0xa4, 0xa9, 0x36, + 0x4f, 0x3a, 0xdb, 0x82, 0x78, 0xc9, 0xc1, 0x00, 0x3b, 0xab, 0x7d, 0x22, 0x0c, 0x50, 0x09, 0x6b, + 0x16, 0x8d, 0xf9, 0xfc, 0x34, 0x86, 0x18, 0xac, 0x4b, 0x56, 0xaa, 0x3e, 0x18, 0x23, 0xa5, 0x37, + 0x36, 0x65, 0x9d, 0x6d, 0x81, 0x79, 0xf4, 0xff, 0x4e, 0xe5, 0xa8, 0x21, 0xf3, 0xc8, 0x88, 0x4c, + 0xbb, 0x7e, 0x3b, 0xb2, 0x7b, 0x3a, 0xb0, 0x71, 0x16, 0x86, 0x5e, 0x67, 0xd4, 0x9d, 0x0e, 0x16, + 0x13, 0xf1, 0x27, 0x4e, 0x3c, 0x54, 0x53, 0x15, 0xba, 0x72, 0xf7, 0x5f, 0x43, 0xc7, 0xa7, 0xd8, + 0x7e, 0xc0, 0x71, 0x4c, 0xfb, 0xbf, 0x6b, 0xc6, 0xa8, 0x9b, 0x05, 0xa9, 0xb2, 0xc0, 0xbe, 0x6f, + 0x35, 0xbb, 0xa3, 0xfd, 0xb6, 0xdb, 0xc6, 0xeb, 0x8c, 0xc8, 0x74, 0xb0, 0xb8, 0x38, 0xc2, 0x6a, + 0x1a, 0xdc, 0x36, 0xa8, 0x5e, 0x7d, 0xbb, 0xde, 0x8c, 0x97, 0xb4, 0xd7, 0xee, 0x8e, 0x74, 0x63, + 0xd4, 0x4d, 0x02, 0x4c, 0x2c, 0xe8, 0xc4, 0xb7, 0xfa, 0xda, 0x7d, 0xff, 0x18, 0x3a, 0xab, 0xe5, + 0xbe, 0xe0, 0xe4, 0x50, 0x70, 0xf2, 0x5d, 0x70, 0xf2, 0x56, 0x72, 0xe7, 0x50, 0x72, 0xe7, 0xb3, + 0xe4, 0xce, 0xe3, 0x24, 0xd6, 0x26, 0x79, 0x0d, 0x45, 0x04, 0xa9, 0xd4, 0xb9, 0xc6, 0x4c, 0x19, + 0x19, 0x41, 0xae, 0x66, 0xb8, 0x79, 0x9e, 0xc5, 0x50, 0x3f, 0x54, 0xf8, 0xcf, 0xfe, 0xe4, 0xab, + 0x9f, 0x00, 0x00, 0x00, 0xff, 0xff, 0xcb, 0xf1, 0xa3, 0x51, 0xbf, 0x01, 0x00, 0x00, } func (m *CommitInfo) Marshal() (dAtA []byte, err error) { diff --git a/store/listening.pb.go b/store/listening.pb.go index 51ed674..46c8423 100644 --- a/store/listening.pb.go +++ b/store/listening.pb.go @@ -5,11 +5,10 @@ package store import ( fmt "fmt" - + proto "github.com/cosmos/gogoproto/proto" io "io" math "math" math_bits "math/bits" - proto "github.com/gogo/protobuf/proto" ) // Reference imports to suppress errors if they are not otherwise used. @@ -103,7 +102,7 @@ func init() { } var fileDescriptor_b6caeb9d7b7c7c10 = []byte{ - // 232 bytes of a gzipped FileDescriptorProto + // 227 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x52, 0x49, 0xce, 0x2f, 0xce, 0xcd, 0x2f, 0xd6, 0x2f, 0x2e, 0xc9, 0x2f, 0x4a, 0xd5, 0x2f, 0x33, 0x4c, 0x4a, 0x2d, 0x49, 0x34, 0xd4, 0xcf, 0xc9, 0x2c, 0x2e, 0x49, 0xcd, 0xcb, 0xcc, 0x4b, 0xd7, 0x2b, 0x28, 0xca, 0x2f, 0xc9, @@ -113,12 +112,12 @@ var fileDescriptor_b6caeb9d7b7c7c10 = []byte{ 0xde, 0xa9, 0x95, 0x42, 0x62, 0x5c, 0x6c, 0x29, 0xa9, 0x39, 0xa9, 0x25, 0xa9, 0x12, 0x4c, 0x0a, 0x8c, 0x1a, 0x1c, 0x41, 0x50, 0x9e, 0x90, 0x00, 0x17, 0x33, 0x48, 0x39, 0xb3, 0x02, 0xa3, 0x06, 0x4f, 0x10, 0x88, 0x29, 0x24, 0xc2, 0xc5, 0x5a, 0x96, 0x98, 0x53, 0x9a, 0x2a, 0xc1, 0x02, 0x16, - 0x83, 0x70, 0x9c, 0x5c, 0x4e, 0x3c, 0x92, 0x63, 0xbc, 0xf0, 0x48, 0x8e, 0xf1, 0xc1, 0x23, 0x39, - 0xc6, 0x09, 0x8f, 0xe5, 0x18, 0x2e, 0x3c, 0x96, 0x63, 0xb8, 0xf1, 0x58, 0x8e, 0x21, 0x4a, 0x2b, + 0x83, 0x70, 0x9c, 0xec, 0x4e, 0x3c, 0x92, 0x63, 0xbc, 0xf0, 0x48, 0x8e, 0xf1, 0xc1, 0x23, 0x39, + 0xc6, 0x09, 0x8f, 0xe5, 0x18, 0x2e, 0x3c, 0x96, 0x63, 0xb8, 0xf1, 0x58, 0x8e, 0x21, 0x4a, 0x25, 0x3d, 0xb3, 0x24, 0xa3, 0x34, 0x49, 0x2f, 0x39, 0x3f, 0x57, 0x3f, 0xb3, 0x28, 0xb3, 0x38, 0x2f, - 0xb5, 0x44, 0x3f, 0x39, 0xbf, 0x28, 0x55, 0xb7, 0x38, 0x25, 0x5b, 0x37, 0x3d, 0x5f, 0xbf, 0xa4, - 0xb2, 0x20, 0x15, 0xea, 0xc9, 0x24, 0x36, 0xb0, 0x9f, 0x8c, 0x01, 0x01, 0x00, 0x00, 0xff, 0xff, - 0xe0, 0xac, 0x88, 0x02, 0xfb, 0x00, 0x00, 0x00, + 0xb5, 0x44, 0x3f, 0x39, 0xbf, 0x28, 0x55, 0xb7, 0x38, 0x25, 0x5b, 0x37, 0x3d, 0x1f, 0xe2, 0xbd, + 0x24, 0x36, 0xb0, 0x6f, 0x8c, 0x01, 0x01, 0x00, 0x00, 0xff, 0xff, 0x6f, 0x23, 0x5d, 0x01, 0xf5, + 0x00, 0x00, 0x00, } func (m *StoreKVPair) Marshal() (dAtA []byte, err error) { diff --git a/store/snapshot.pb.go b/store/snapshot.pb.go index 11420e2..83b1ce9 100644 --- a/store/snapshot.pb.go +++ b/store/snapshot.pb.go @@ -5,8 +5,8 @@ package store import ( fmt "fmt" + proto "github.com/cosmos/gogoproto/proto" _ "github.com/gogo/protobuf/gogoproto" - proto "github.com/gogo/protobuf/proto" io "io" math "math" math_bits "math/bits" @@ -236,28 +236,28 @@ func init() { } var fileDescriptor_a86cb47d6b1dddc7 = []byte{ - // 329 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x91, 0xc1, 0x4e, 0xc2, 0x30, - 0x18, 0xc7, 0x57, 0x19, 0xa8, 0x95, 0x03, 0x36, 0xc4, 0x4c, 0x0f, 0x93, 0xe0, 0x41, 0xa2, 0xd2, - 0x06, 0x7d, 0x02, 0x09, 0x07, 0x88, 0x9e, 0x4a, 0xe2, 0xc1, 0xdb, 0x86, 0xcd, 0xd6, 0xc0, 0xf6, - 0x91, 0xb5, 0x2c, 0xe1, 0x2d, 0x7c, 0x0d, 0xdf, 0xc4, 0x23, 0x47, 0x4f, 0xc6, 0x8c, 0x17, 0x31, - 0xed, 0xc6, 0x45, 0x63, 0xe2, 0xed, 0xfb, 0x37, 0xff, 0xdf, 0xaf, 0x5f, 0xf2, 0xe1, 0x8b, 0x19, - 0xa8, 0x04, 0x14, 0x53, 0x1a, 0x32, 0xc1, 0xf2, 0x41, 0x28, 0x74, 0x30, 0x60, 0x2a, 0x0d, 0x96, - 0x2a, 0x06, 0x4d, 0x97, 0x19, 0x68, 0x20, 0xa7, 0x65, 0x89, 0x86, 0x81, 0x12, 0xd4, 0x36, 0x69, - 0xd5, 0x3c, 0x6b, 0x47, 0x10, 0x81, 0x6d, 0x31, 0x33, 0x95, 0x40, 0xf7, 0x0d, 0xe1, 0xe6, 0xb4, - 0x72, 0x4c, 0xb4, 0x48, 0xc8, 0x08, 0xd7, 0x2d, 0xe7, 0xa1, 0x0e, 0xea, 0x1d, 0xdd, 0xde, 0xd0, - 0x3f, 0x8d, 0x74, 0xc7, 0x4d, 0xcd, 0xab, 0x81, 0xc7, 0x0e, 0x2f, 0x61, 0xf2, 0x80, 0x5d, 0x19, - 0xe4, 0x0b, 0x6f, 0xcf, 0x4a, 0xae, 0xff, 0x21, 0x99, 0xdc, 0x3f, 0x3d, 0x1a, 0xc7, 0xf0, 0xa0, - 0xf8, 0x3c, 0x77, 0x4d, 0x1a, 0x3b, 0xdc, 0x4a, 0x86, 0x0d, 0xec, 0x4a, 0x2d, 0x92, 0xee, 0x25, - 0x3e, 0xfe, 0xf5, 0x25, 0x21, 0xd8, 0x4d, 0x83, 0xa4, 0x5c, 0xf7, 0x90, 0xdb, 0xb9, 0xbb, 0xc0, - 0xad, 0x9f, 0x5a, 0xd2, 0xc2, 0xb5, 0xb9, 0x58, 0xdb, 0x5a, 0x93, 0x9b, 0x91, 0xb4, 0x71, 0x3d, - 0x0f, 0x16, 0x2b, 0x61, 0x97, 0x6c, 0xf2, 0x32, 0x10, 0x0f, 0xef, 0xe7, 0x22, 0x53, 0x12, 0x52, - 0xaf, 0xd6, 0x41, 0xbd, 0x1a, 0xdf, 0x45, 0x72, 0x82, 0x1b, 0xb1, 0x90, 0x51, 0xac, 0x3d, 0xb7, - 0x83, 0x7a, 0x75, 0x5e, 0xa5, 0xe1, 0xe8, 0xbd, 0xf0, 0xd1, 0xa6, 0xf0, 0xd1, 0x57, 0xe1, 0xa3, - 0xd7, 0xad, 0xef, 0x6c, 0xb6, 0xbe, 0xf3, 0xb1, 0xf5, 0x9d, 0xe7, 0xab, 0x48, 0xea, 0x78, 0x15, - 0xd2, 0x19, 0x24, 0x4c, 0x66, 0x52, 0xa5, 0x42, 0xb3, 0x19, 0x64, 0xa2, 0xaf, 0x5e, 0xe6, 0xfd, - 0x08, 0x98, 0x5e, 0x2f, 0x45, 0x75, 0xd0, 0xb0, 0x61, 0xef, 0x71, 0xf7, 0x1d, 0x00, 0x00, 0xff, - 0xff, 0xb5, 0x11, 0x28, 0x72, 0xe7, 0x01, 0x00, 0x00, + // 327 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x91, 0xc1, 0x4a, 0xeb, 0x40, + 0x14, 0x86, 0x33, 0xb7, 0x69, 0xaf, 0x1e, 0xbb, 0xa8, 0x43, 0x91, 0xe8, 0x22, 0x96, 0x2a, 0x58, + 0xd0, 0x4e, 0xa8, 0xee, 0x05, 0x8b, 0x8b, 0x16, 0x5d, 0x4d, 0xc1, 0x85, 0xbb, 0xa4, 0x0e, 0xc9, + 0xd0, 0x26, 0xa7, 0x64, 0xa6, 0x01, 0xdf, 0xc2, 0xd7, 0xf0, 0x4d, 0x5c, 0x76, 0xe9, 0x4a, 0x24, + 0x7d, 0x11, 0xc9, 0x4c, 0xbb, 0x51, 0x04, 0x77, 0xe7, 0x1f, 0xfe, 0xef, 0x9b, 0x03, 0x07, 0x4e, + 0xa6, 0xa8, 0x52, 0x54, 0x81, 0xd2, 0x98, 0x8b, 0xa0, 0x18, 0x44, 0x42, 0x87, 0x83, 0x40, 0x65, + 0xe1, 0x42, 0x25, 0xa8, 0xd9, 0x22, 0x47, 0x8d, 0xf4, 0xd0, 0x96, 0x58, 0x14, 0x2a, 0xc1, 0x4c, + 0x93, 0x6d, 0x9a, 0x47, 0xed, 0x18, 0x63, 0x34, 0xad, 0xa0, 0x9a, 0x2c, 0xd0, 0x7d, 0x25, 0xd0, + 0x9c, 0x6c, 0x1c, 0x63, 0x2d, 0x52, 0x7a, 0x0b, 0x75, 0xc3, 0x79, 0xa4, 0x43, 0x7a, 0x7b, 0x97, + 0x17, 0xec, 0x57, 0x23, 0xdb, 0x72, 0x93, 0xea, 0xb5, 0x82, 0x47, 0x0e, 0xb7, 0x30, 0xbd, 0x03, + 0x57, 0x86, 0xc5, 0xdc, 0xfb, 0x67, 0x24, 0xe7, 0x7f, 0x90, 0x8c, 0x6f, 0x1e, 0xee, 0x2b, 0xc7, + 0x70, 0xa7, 0xfc, 0x38, 0x76, 0xab, 0x34, 0x72, 0xb8, 0x91, 0x0c, 0x1b, 0xe0, 0x4a, 0x2d, 0xd2, + 0xee, 0x19, 0xec, 0xff, 0xf8, 0x92, 0x52, 0x70, 0xb3, 0x30, 0xb5, 0xeb, 0xee, 0x72, 0x33, 0x77, + 0xe7, 0xd0, 0xfa, 0xae, 0xa5, 0x2d, 0xa8, 0xcd, 0xc4, 0xb3, 0xa9, 0x35, 0x79, 0x35, 0xd2, 0x36, + 0xd4, 0x8b, 0x70, 0xbe, 0x14, 0x66, 0xc9, 0x26, 0xb7, 0x81, 0x7a, 0xf0, 0xbf, 0x10, 0xb9, 0x92, + 0x98, 0x79, 0xb5, 0x0e, 0xe9, 0xd5, 0xf8, 0x36, 0xd2, 0x03, 0x68, 0x24, 0x42, 0xc6, 0x89, 0xf6, + 0xdc, 0x0e, 0xe9, 0xd5, 0xf9, 0x26, 0x0d, 0xaf, 0xdf, 0x4a, 0x9f, 0xac, 0x4a, 0x9f, 0x7c, 0x96, + 0x3e, 0x79, 0x59, 0xfb, 0xce, 0x6a, 0xed, 0x3b, 0xef, 0x6b, 0xdf, 0x79, 0x3c, 0x8d, 0xa5, 0x4e, + 0x96, 0x11, 0x9b, 0x62, 0x1a, 0xc8, 0x5c, 0xaa, 0x4c, 0xe8, 0x60, 0x8a, 0xb9, 0xe8, 0xab, 0xa7, + 0x59, 0x3f, 0x46, 0x7b, 0xca, 0xa8, 0x61, 0x2e, 0x71, 0xf5, 0x15, 0x00, 0x00, 0xff, 0xff, 0x42, + 0x6a, 0x27, 0xce, 0xe1, 0x01, 0x00, 0x00, } func (m *SnapshotItem) Marshal() (dAtA []byte, err error) { diff --git a/store/types/snapshots/snapshot.pb.go b/store/types/snapshots/snapshot.pb.go index 102208f..2ef660f 100644 --- a/store/types/snapshots/snapshot.pb.go +++ b/store/types/snapshots/snapshot.pb.go @@ -5,8 +5,8 @@ package snapshots import ( fmt "fmt" + proto "github.com/cosmos/gogoproto/proto" _ "github.com/gogo/protobuf/gogoproto" - proto "github.com/gogo/protobuf/proto" io "io" math "math" math_bits "math/bits" @@ -155,26 +155,26 @@ func init() { } var fileDescriptor_d68466eaebf2e253 = []byte{ - // 291 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x7c, 0x90, 0x31, 0x4e, 0xc3, 0x30, - 0x14, 0x86, 0x63, 0x1a, 0xaa, 0xca, 0x2d, 0x8b, 0x85, 0x90, 0x85, 0x84, 0x09, 0x5d, 0x9a, 0xa5, - 0xb6, 0x0a, 0x37, 0xe8, 0x54, 0x06, 0x96, 0xb0, 0xb1, 0x20, 0x27, 0x35, 0x71, 0x54, 0x25, 0x8e, - 0xf2, 0x5c, 0x24, 0x6e, 0xc1, 0x55, 0xb8, 0x45, 0xc7, 0x8e, 0x4c, 0x08, 0x25, 0x17, 0x41, 0x71, - 0x42, 0xc4, 0xc4, 0xf6, 0xfe, 0xcf, 0xdf, 0xd3, 0xb3, 0x7e, 0xbc, 0x48, 0x0c, 0xe4, 0x06, 0x04, - 0x14, 0xb2, 0x04, 0x6d, 0x2c, 0x88, 0xd7, 0x55, 0xac, 0xac, 0x5c, 0x0d, 0x84, 0x97, 0x95, 0xb1, - 0x86, 0x5c, 0x75, 0x22, 0x8f, 0x25, 0x28, 0x3e, 0xd8, 0xbc, 0xb7, 0x2f, 0xcf, 0x53, 0x93, 0x1a, - 0x67, 0x8a, 0x76, 0xea, 0x96, 0xe6, 0x1f, 0x08, 0x4f, 0x1e, 0x7b, 0x97, 0x5c, 0xe0, 0xb1, 0x56, - 0x59, 0xaa, 0x2d, 0x45, 0x01, 0x0a, 0xfd, 0xa8, 0x4f, 0x2d, 0x7f, 0x31, 0x55, 0x2e, 0x2d, 0x3d, - 0x09, 0x50, 0x78, 0x16, 0xf5, 0xa9, 0xe5, 0x89, 0xde, 0x17, 0x3b, 0xa0, 0xa3, 0x8e, 0x77, 0x89, - 0x10, 0xec, 0x6b, 0x09, 0x9a, 0xfa, 0x01, 0x0a, 0x67, 0x91, 0x9b, 0xc9, 0x3d, 0x9e, 0xe4, 0xca, - 0xca, 0xad, 0xb4, 0x92, 0x9e, 0x06, 0x28, 0x9c, 0xde, 0x2e, 0xf8, 0xbf, 0x1f, 0xe6, 0x0f, 0xbd, - 0xbe, 0xf6, 0x0f, 0x5f, 0xd7, 0x5e, 0x34, 0xac, 0xcf, 0x97, 0x78, 0xf2, 0xfb, 0x46, 0x6e, 0xf0, - 0xcc, 0x1d, 0x7d, 0x6e, 0x8f, 0x28, 0xa0, 0x28, 0x18, 0x85, 0xb3, 0x68, 0xea, 0xd8, 0xc6, 0xa1, - 0xf5, 0xe6, 0x50, 0x33, 0x74, 0xac, 0x19, 0xfa, 0xae, 0x19, 0x7a, 0x6f, 0x98, 0x77, 0x6c, 0x98, - 0xf7, 0xd9, 0x30, 0xef, 0x89, 0xa7, 0x99, 0xd5, 0xfb, 0x98, 0x27, 0x26, 0x17, 0x59, 0x95, 0x41, - 0xa1, 0xac, 0x48, 0x4c, 0xa5, 0x96, 0xb0, 0xdd, 0x2d, 0x53, 0x23, 0xec, 0x5b, 0xa9, 0xfe, 0x14, - 0x1f, 0x8f, 0x5d, 0x67, 0x77, 0x3f, 0x01, 0x00, 0x00, 0xff, 0xff, 0x62, 0x63, 0xc8, 0xbc, 0x93, - 0x01, 0x00, 0x00, + // 297 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x7c, 0x90, 0xb1, 0x4e, 0xeb, 0x30, + 0x14, 0x86, 0xe3, 0xdb, 0xdc, 0xaa, 0x72, 0xcb, 0x62, 0x21, 0x64, 0x21, 0x61, 0x42, 0x97, 0x66, + 0xa9, 0xad, 0x02, 0x4f, 0xd0, 0x09, 0x06, 0x18, 0xc2, 0xc6, 0x82, 0x9c, 0xd4, 0xc4, 0x51, 0x95, + 0x9e, 0x2a, 0xc7, 0x45, 0xe2, 0x2d, 0x78, 0x15, 0xde, 0xa2, 0x63, 0x47, 0x26, 0x84, 0xda, 0x17, + 0x41, 0x71, 0x42, 0xc4, 0xc4, 0x76, 0xfe, 0xcf, 0xdf, 0xd1, 0xb1, 0x7e, 0x3a, 0xc9, 0x00, 0x4b, + 0x40, 0x85, 0x2b, 0xbd, 0x46, 0x0b, 0x0e, 0xd5, 0xcb, 0x2c, 0x35, 0x4e, 0xcf, 0x3a, 0x22, 0xd7, + 0x15, 0x38, 0x60, 0x67, 0x8d, 0x28, 0x53, 0x8d, 0x46, 0x76, 0xb6, 0x6c, 0xed, 0xd3, 0xe3, 0x1c, + 0x72, 0xf0, 0xa6, 0xaa, 0xa7, 0x66, 0x69, 0xfc, 0x4e, 0xe8, 0xe0, 0xa1, 0x75, 0xd9, 0x09, 0xed, + 0x5b, 0x53, 0xe4, 0xd6, 0x71, 0x12, 0x91, 0x38, 0x4c, 0xda, 0x54, 0xf3, 0x67, 0xa8, 0x4a, 0xed, + 0xf8, 0xbf, 0x88, 0xc4, 0x47, 0x49, 0x9b, 0x6a, 0x9e, 0xd9, 0xcd, 0x6a, 0x89, 0xbc, 0xd7, 0xf0, + 0x26, 0x31, 0x46, 0x43, 0xab, 0xd1, 0xf2, 0x30, 0x22, 0xf1, 0x28, 0xf1, 0x33, 0xbb, 0xa5, 0x83, + 0xd2, 0x38, 0xbd, 0xd0, 0x4e, 0xf3, 0xff, 0x11, 0x89, 0x87, 0x97, 0x13, 0xf9, 0xe7, 0x87, 0xe5, + 0x5d, 0xab, 0xcf, 0xc3, 0xed, 0xe7, 0x79, 0x90, 0x74, 0xeb, 0xe3, 0x29, 0x1d, 0xfc, 0xbc, 0xb1, + 0x0b, 0x3a, 0xf2, 0x47, 0x9f, 0xea, 0x23, 0x06, 0x39, 0x89, 0x7a, 0xf1, 0x28, 0x19, 0x7a, 0x76, + 0xe3, 0xd1, 0xfc, 0x7e, 0xbb, 0x17, 0x64, 0xb7, 0x17, 0xe4, 0x6b, 0x2f, 0xc8, 0xdb, 0x41, 0x04, + 0xbb, 0x83, 0x08, 0x3e, 0x0e, 0x22, 0x78, 0xbc, 0xce, 0x0b, 0x67, 0x37, 0xa9, 0xcc, 0xa0, 0x54, + 0x45, 0x55, 0xe0, 0xca, 0x38, 0x95, 0x41, 0x65, 0xa6, 0xb8, 0x58, 0x4e, 0x73, 0x50, 0xe8, 0xa0, + 0x32, 0xca, 0xbd, 0xae, 0xcd, 0xaf, 0xfa, 0xd3, 0xbe, 0x6f, 0xee, 0xea, 0x3b, 0x00, 0x00, 0xff, + 0xff, 0x4b, 0xce, 0xad, 0x18, 0x99, 0x01, 0x00, 0x00, } func (m *Snapshot) Marshal() (dAtA []byte, err error) { diff --git a/types/abci.pb.go b/types/abci.pb.go index 9bdfeff..1d9c19c 100644 --- a/types/abci.pb.go +++ b/types/abci.pb.go @@ -5,8 +5,8 @@ package types import ( fmt "fmt" + proto "github.com/cosmos/gogoproto/proto" _ "github.com/gogo/protobuf/gogoproto" - proto "github.com/gogo/protobuf/proto" types "github.com/irisnet/core-sdk-go/common/codec/types" types1 "github.com/tendermint/tendermint/abci/types" io "io" diff --git a/types/auth/auth.pb.go b/types/auth/auth.pb.go index 038f5eb..e0f01b9 100644 --- a/types/auth/auth.pb.go +++ b/types/auth/auth.pb.go @@ -5,8 +5,8 @@ package auth import ( fmt "fmt" + proto "github.com/cosmos/gogoproto/proto" _ "github.com/gogo/protobuf/gogoproto" - proto "github.com/gogo/protobuf/proto" types "github.com/irisnet/core-sdk-go/common/codec/types" _ "github.com/regen-network/cosmos-proto" io "io" diff --git a/types/auth/query.pb.go b/types/auth/query.pb.go index 694dae5..f224841 100644 --- a/types/auth/query.pb.go +++ b/types/auth/query.pb.go @@ -6,9 +6,9 @@ package auth import ( context "context" fmt "fmt" + grpc1 "github.com/cosmos/gogoproto/grpc" + proto "github.com/cosmos/gogoproto/proto" _ "github.com/gogo/protobuf/gogoproto" - grpc1 "github.com/gogo/protobuf/grpc" - proto "github.com/gogo/protobuf/proto" types "github.com/irisnet/core-sdk-go/common/codec/types" _ "github.com/regen-network/cosmos-proto" _ "google.golang.org/genproto/googleapis/api/annotations" diff --git a/types/client.go b/types/client.go index 39c6d09..648b959 100644 --- a/types/client.go +++ b/types/client.go @@ -8,12 +8,13 @@ import ( type TxManager interface { TmQuery + BroadcastTx(txBytes []byte, mode BroadcastMode) (res ResultTx, err Error) SendBatch(msgs Msgs, baseTx BaseTx) ([]ResultTx, Error) BuildAndSend(msg []Msg, baseTx BaseTx) (ResultTx, Error) BuildAndSign(msg []Msg, baseTx BaseTx) ([]byte, Error) BuildTxHash(msg []Msg, baseTx BaseTx) (string, Error) BuildAndSendWithAccount(addr string, accountNumber, sequence uint64, msg []Msg, baseTx BaseTx) (ResultTx, Error) - BuildAndSignWithAccount(addr string, accountNumber, sequence uint64, msg []Msg, baseTx BaseTx) ([]byte, Error) + BuildAndSignWithAccount(addr string, accountNumber, sequence uint64, msg []Msg, baseTx BaseTx) ([]byte, Error) } type Queries interface { diff --git a/types/coin.pb.go b/types/coin.pb.go index 38f8ec3..fc3862a 100644 --- a/types/coin.pb.go +++ b/types/coin.pb.go @@ -5,8 +5,8 @@ package types import ( fmt "fmt" + proto "github.com/cosmos/gogoproto/proto" _ "github.com/gogo/protobuf/gogoproto" - proto "github.com/gogo/protobuf/proto" io "io" math "math" math_bits "math/bits" diff --git a/types/kv/kv.pb.go b/types/kv/kv.pb.go index be1963c..137733d 100644 --- a/types/kv/kv.pb.go +++ b/types/kv/kv.pb.go @@ -5,8 +5,8 @@ package kv import ( fmt "fmt" + proto "github.com/cosmos/gogoproto/proto" _ "github.com/gogo/protobuf/gogoproto" - proto "github.com/gogo/protobuf/proto" io "io" math "math" math_bits "math/bits" diff --git a/types/query/pagination.pb.go b/types/query/pagination.pb.go index 04e3f1c..93154ea 100644 --- a/types/query/pagination.pb.go +++ b/types/query/pagination.pb.go @@ -5,7 +5,7 @@ package query import ( fmt "fmt" - proto "github.com/gogo/protobuf/proto" + proto "github.com/cosmos/gogoproto/proto" io "io" math "math" math_bits "math/bits" @@ -25,10 +25,10 @@ const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package // PageRequest is to be embedded in gRPC request messages for efficient // pagination. Ex: // -// message SomeRequest { -// Foo some_parameter = 1; -// PageRequest pagination = 2; -// } +// message SomeRequest { +// Foo some_parameter = 1; +// PageRequest pagination = 2; +// } type PageRequest struct { // key is a value returned in PageResponse.next_key to begin // querying the next page most efficiently. Only one of offset or key @@ -112,10 +112,10 @@ func (m *PageRequest) GetCountTotal() bool { // PageResponse is to be embedded in gRPC response messages where the // corresponding request message has used PageRequest. // -// message SomeResponse { -// repeated Bar results = 1; -// PageResponse page = 2; -// } +// message SomeResponse { +// repeated Bar results = 1; +// PageResponse page = 2; +// } type PageResponse struct { // next_key is the key to be passed to PageRequest.key to // query the next page most efficiently diff --git a/types/tx/builder.go b/types/tx/builder.go index dcea351..510509a 100644 --- a/types/tx/builder.go +++ b/types/tx/builder.go @@ -37,6 +37,7 @@ var ( // ExtensionOptionsTxBuilder defines a Factory that can also set extensions. type ExtensionOptionsTxBuilder interface { + sdk.TxBuilder SetExtensionOptions(...*codectypes.Any) SetNonCriticalExtensionOptions(...*codectypes.Any) } diff --git a/types/tx/signing/signing.pb.go b/types/tx/signing/signing.pb.go index e625e2c..767dc61 100644 --- a/types/tx/signing/signing.pb.go +++ b/types/tx/signing/signing.pb.go @@ -5,7 +5,7 @@ package signing import ( fmt "fmt" - proto "github.com/gogo/protobuf/proto" + proto "github.com/cosmos/gogoproto/proto" types "github.com/irisnet/core-sdk-go/common/codec/types" types1 "github.com/irisnet/core-sdk-go/common/crypto/types" io "io" @@ -184,6 +184,7 @@ type SignatureDescriptor_Data struct { // sum is the oneof that specifies whether this represents single or multi-signature data // // Types that are valid to be assigned to Sum: + // // *SignatureDescriptor_Data_Single_ // *SignatureDescriptor_Data_Multi_ Sum isSignatureDescriptor_Data_Sum `protobuf_oneof:"sum"` diff --git a/types/tx/tx.pb.go b/types/tx/tx.pb.go index 919827f..e64e251 100644 --- a/types/tx/tx.pb.go +++ b/types/tx/tx.pb.go @@ -5,8 +5,8 @@ package tx import ( fmt "fmt" + proto "github.com/cosmos/gogoproto/proto" _ "github.com/gogo/protobuf/gogoproto" - proto "github.com/gogo/protobuf/proto" types "github.com/irisnet/core-sdk-go/common/codec/types" types1 "github.com/irisnet/core-sdk-go/common/crypto/types" github_com_irisnet_core_sdk_go_types "github.com/irisnet/core-sdk-go/types" @@ -476,6 +476,7 @@ type ModeInfo struct { // multisig signer // // Types that are valid to be assigned to Sum: + // // *ModeInfo_Single_ // *ModeInfo_Multi_ Sum isModeInfo_Sum `protobuf_oneof:"sum"` From 18c6d890a7f097da8fee95468b371c9d9d644dbc Mon Sep 17 00:00:00 2001 From: aofengli <996177263@qq.com> Date: Mon, 13 Mar 2023 15:30:23 +0800 Subject: [PATCH 02/17] cache --- client.go | 2 +- common/codec/types/any.pb.go | 5 +++-- 2 files changed, 4 insertions(+), 3 deletions(-) diff --git a/client.go b/client.go index 3ff08a0..cf20517 100644 --- a/client.go +++ b/client.go @@ -106,7 +106,7 @@ func makeEncodingConfig() types.EncodingConfig { TxConfig: txCfg, Amino: amino, } - RegisterLegacyAminoCodec(encodingConfig.Amino) + //RegisterLegacyAminoCodec(encodingConfig.Amino) RegisterInterfaces(encodingConfig.InterfaceRegistry) return encodingConfig } diff --git a/common/codec/types/any.pb.go b/common/codec/types/any.pb.go index d084381..3e167f2 100644 --- a/common/codec/types/any.pb.go +++ b/common/codec/types/any.pb.go @@ -6,13 +6,14 @@ package types import ( bytes "bytes" fmt "fmt" - _ "github.com/gogo/protobuf/gogoproto" - proto "github.com/gogo/protobuf/proto" io "io" math "math" math_bits "math/bits" reflect "reflect" strings "strings" + + _ "github.com/gogo/protobuf/gogoproto" + proto "github.com/gogo/protobuf/proto" ) // Reference imports to suppress errors if they are not otherwise used. From d34d060387128f560bf45c6c0df9b71e246f065a Mon Sep 17 00:00:00 2001 From: aofengli <996177263@qq.com> Date: Mon, 13 Mar 2023 15:59:47 +0800 Subject: [PATCH 03/17] add evm broadcact --- bank/bank.pb.go | 2 +- bank/query.pb.go | 4 +- bank/tx.pb.go | 2 +- common/crypto/keys/ed25519/keys.pb.go | 2 +- common/crypto/keys/multisig/keys.pb.go | 2 +- common/crypto/keys/secp256k1/keys.pb.go | 2 +- common/crypto/types/multisig.pb.go | 2 +- ethermint/clinet_test.go | 30 ++++++++------ ethermint/x/evm/types/codec.go | 5 +-- ethermint/x/evm/types/evm.pb.go | 2 +- ethermint/x/evm/types/query.pb.go | 18 ++++----- ethermint/x/evm/types/tx.pb.go | 4 +- feegrant/feegrant.pb.go | 22 +++++------ feegrant/query.pb.go | 4 +- feegrant/tx.pb.go | 4 +- gov/gov.pb.go | 40 +++++++++---------- gov/query.pb.go | 4 +- gov/tx.pb.go | 4 +- ibc/clinet_test.go | 52 +++++++++++++++++++++++++ ibc/transfer/query.pb.go | 4 +- ibc/transfer/tx.pb.go | 4 +- staking/query.pb.go | 4 +- staking/staking.pb.go | 46 +++++++++++----------- staking/tx.pb.go | 18 ++++----- store/commit_info.pb.go | 2 +- store/listening.pb.go | 2 +- store/snapshot.pb.go | 2 +- store/types/snapshots/snapshot.pb.go | 2 +- types/abci.pb.go | 2 +- types/auth/auth.pb.go | 2 +- types/auth/query.pb.go | 4 +- types/coin.pb.go | 2 +- types/kv/kv.pb.go | 2 +- types/query/pagination.pb.go | 2 +- types/tx/signing/signing.pb.go | 2 +- types/tx/tx.pb.go | 2 +- 36 files changed, 182 insertions(+), 125 deletions(-) create mode 100644 ibc/clinet_test.go diff --git a/bank/bank.pb.go b/bank/bank.pb.go index 1936ca6..f2daa8e 100644 --- a/bank/bank.pb.go +++ b/bank/bank.pb.go @@ -5,8 +5,8 @@ package bank import ( fmt "fmt" - proto "github.com/cosmos/gogoproto/proto" _ "github.com/gogo/protobuf/gogoproto" + proto "github.com/gogo/protobuf/proto" github_com_irisnet_core_sdk_go_types "github.com/irisnet/core-sdk-go/types" types "github.com/irisnet/core-sdk-go/types" _ "github.com/regen-network/cosmos-proto" diff --git a/bank/query.pb.go b/bank/query.pb.go index fc7d02a..76f9d67 100644 --- a/bank/query.pb.go +++ b/bank/query.pb.go @@ -6,9 +6,9 @@ package bank import ( context "context" fmt "fmt" - grpc1 "github.com/cosmos/gogoproto/grpc" - proto "github.com/cosmos/gogoproto/proto" _ "github.com/gogo/protobuf/gogoproto" + grpc1 "github.com/gogo/protobuf/grpc" + proto "github.com/gogo/protobuf/proto" github_com_irisnet_core_sdk_go_types "github.com/irisnet/core-sdk-go/types" types "github.com/irisnet/core-sdk-go/types" query "github.com/irisnet/core-sdk-go/types/query" diff --git a/bank/tx.pb.go b/bank/tx.pb.go index c5d98b8..a911d3b 100644 --- a/bank/tx.pb.go +++ b/bank/tx.pb.go @@ -5,8 +5,8 @@ package bank import ( fmt "fmt" - proto "github.com/cosmos/gogoproto/proto" _ "github.com/gogo/protobuf/gogoproto" + proto "github.com/gogo/protobuf/proto" github_com_irisnet_core_sdk_go_types "github.com/irisnet/core-sdk-go/types" types "github.com/irisnet/core-sdk-go/types" io "io" diff --git a/common/crypto/keys/ed25519/keys.pb.go b/common/crypto/keys/ed25519/keys.pb.go index 9c5511f..8a263ce 100644 --- a/common/crypto/keys/ed25519/keys.pb.go +++ b/common/crypto/keys/ed25519/keys.pb.go @@ -5,8 +5,8 @@ package ed25519 import ( fmt "fmt" - proto "github.com/cosmos/gogoproto/proto" _ "github.com/gogo/protobuf/gogoproto" + proto "github.com/gogo/protobuf/proto" io "io" math "math" math_bits "math/bits" diff --git a/common/crypto/keys/multisig/keys.pb.go b/common/crypto/keys/multisig/keys.pb.go index 7cae8a7..cc3021e 100644 --- a/common/crypto/keys/multisig/keys.pb.go +++ b/common/crypto/keys/multisig/keys.pb.go @@ -5,8 +5,8 @@ package multisig import ( fmt "fmt" - proto "github.com/cosmos/gogoproto/proto" _ "github.com/gogo/protobuf/gogoproto" + proto "github.com/gogo/protobuf/proto" types "github.com/irisnet/core-sdk-go/common/codec/types" io "io" math "math" diff --git a/common/crypto/keys/secp256k1/keys.pb.go b/common/crypto/keys/secp256k1/keys.pb.go index cc7167a..72727e0 100644 --- a/common/crypto/keys/secp256k1/keys.pb.go +++ b/common/crypto/keys/secp256k1/keys.pb.go @@ -5,8 +5,8 @@ package secp256k1 import ( fmt "fmt" - proto "github.com/cosmos/gogoproto/proto" _ "github.com/gogo/protobuf/gogoproto" + proto "github.com/gogo/protobuf/proto" io "io" math "math" math_bits "math/bits" diff --git a/common/crypto/types/multisig.pb.go b/common/crypto/types/multisig.pb.go index e5c011f..6e506bb 100644 --- a/common/crypto/types/multisig.pb.go +++ b/common/crypto/types/multisig.pb.go @@ -5,8 +5,8 @@ package types import ( fmt "fmt" - proto "github.com/cosmos/gogoproto/proto" _ "github.com/gogo/protobuf/gogoproto" + proto "github.com/gogo/protobuf/proto" io "io" math "math" math_bits "math/bits" diff --git a/ethermint/clinet_test.go b/ethermint/clinet_test.go index 7013d57..f5bc1fc 100644 --- a/ethermint/clinet_test.go +++ b/ethermint/clinet_test.go @@ -1,7 +1,7 @@ package ethermint import ( - "fmt" + "context" "testing" sdk "github.com/irisnet/core-sdk-go" @@ -38,15 +38,21 @@ func TestClient(t *testing.T) { } sdkClient := sdk.NewClient(cfg) - fmt.Println(sdkClient.EncodingConfig().TxConfig) - - //cli := NewClient(nil, txCfg) - //txData := "0xf901470701831e8480941a6640c32b7e6413e839e9dfdb53970ee809b7fb80b8e4990711900000000000000000000000005892e7eeaea5ba624f5ba2900dbab8d2ea36d62b000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000a0000000000000000000000000000000000000000000000000000000000000001a687474703a2f2f6578616d706c652e636f6d2f746f6b656e2f33000000000000000000000000000000000000000000000000000000000000000000000000000974657374686173683200000000000000000000000000000000000000000000008209b2a05dc08aff9f0dac1ed240435510bdd53d8f8eb3f95c44a44f874e9e33ffd2407aa06090bf14d011822f2ff252081684c8e31a5e87d8735ee2f21acc32e87d28304f" - //feePayer := "0x4579DB44FD3A6F645194058914E0A8D5E8F20DB8" - //evmDenom := "ugas" - //rawTx, err := cli.BuildEvmTx(txData, feePayer, evmDenom) - //if err != nil { - // return - //} - //t.Log(rawTx) + + cli := NewClient(sdkClient.BaseClient, sdkClient.EncodingConfig().TxConfig) + txData := "0xf901470801831e8480941a6640c32b7e6413e839e9dfdb53970ee809b7fb80b8e4990711900000000000000000000000005892e7eeaea5ba624f5ba2900dbab8d2ea36d62b000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000a0000000000000000000000000000000000000000000000000000000000000001a687474703a2f2f6578616d706c652e636f6d2f746f6b656e2f35000000000000000000000000000000000000000000000000000000000000000000000000000974657374686173683600000000000000000000000000000000000000000000008209b2a050e1d159818efbae1c536b2c866920ac3c8c3720b9194b02c5ecea7717f85d2da05eabeb96aad81f432e1d7d3f84e6d38ce939e7a2d1f0bee3af2f20f507c91b96" + feePayer := "0x4579DB44FD3A6F645194058914E0A8D5E8F20DB8" + evmDenom := "ugas" + rawTx, err := cli.BuildEvmTx(txData, feePayer, evmDenom) + if err != nil { + t.Log(err) + return + } + + resp, err := cli.BroadcastTxSync(context.Background(), rawTx) + if err != nil { + t.Log(err) + return + } + t.Log(resp) } diff --git a/ethermint/x/evm/types/codec.go b/ethermint/x/evm/types/codec.go index 2dd0a3e..3fbfd96 100644 --- a/ethermint/x/evm/types/codec.go +++ b/ethermint/x/evm/types/codec.go @@ -5,7 +5,6 @@ import ( proto "github.com/gogo/protobuf/proto" "github.com/irisnet/core-sdk-go/common/codec" codectypes "github.com/irisnet/core-sdk-go/common/codec/types" - cryptocodec "github.com/irisnet/core-sdk-go/common/crypto/codec" sdktypes "github.com/irisnet/core-sdk-go/types" ) @@ -15,7 +14,7 @@ var ( ) func init() { - cryptocodec.RegisterCrypto(amino) + //cryptocodec.RegisterCrypto(amino) } type ( @@ -43,7 +42,7 @@ func RegisterInterfaces(registry codectypes.InterfaceRegistry) { } -// PackClientState constructs a new Any packed with the given tx data value. It returns +// PackTxData constructs a new Any packed with the given tx data value. It returns // an error if the client state can't be casted to a protobuf message or if the concrete // implemention is not registered to the protobuf codec. func PackTxData(txData TxData) (*codectypes.Any, error) { diff --git a/ethermint/x/evm/types/evm.pb.go b/ethermint/x/evm/types/evm.pb.go index d06837d..1529045 100644 --- a/ethermint/x/evm/types/evm.pb.go +++ b/ethermint/x/evm/types/evm.pb.go @@ -6,8 +6,8 @@ package types import ( fmt "fmt" github_com_cosmos_cosmos_sdk_types "github.com/cosmos/cosmos-sdk/types" - proto "github.com/cosmos/gogoproto/proto" _ "github.com/gogo/protobuf/gogoproto" + proto "github.com/gogo/protobuf/proto" io "io" math "math" math_bits "math/bits" diff --git a/ethermint/x/evm/types/query.pb.go b/ethermint/x/evm/types/query.pb.go index 3f92bb1..78ee630 100644 --- a/ethermint/x/evm/types/query.pb.go +++ b/ethermint/x/evm/types/query.pb.go @@ -6,10 +6,10 @@ package types import ( context "context" fmt "fmt" - grpc1 "github.com/cosmos/gogoproto/grpc" - proto "github.com/cosmos/gogoproto/proto" - github_com_cosmos_gogoproto_types "github.com/cosmos/gogoproto/types" _ "github.com/gogo/protobuf/gogoproto" + grpc1 "github.com/gogo/protobuf/grpc" + proto "github.com/gogo/protobuf/proto" + github_com_gogo_protobuf_types "github.com/gogo/protobuf/types" query "github.com/irisnet/core-sdk-go/types/query" _ "google.golang.org/genproto/googleapis/api/annotations" grpc "google.golang.org/grpc" @@ -2368,7 +2368,7 @@ func (m *QueryTraceTxRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { _ = i var l int _ = l - n4, err4 := github_com_cosmos_gogoproto_types.StdTimeMarshalTo(m.BlockTime, dAtA[i-github_com_cosmos_gogoproto_types.SizeOfStdTime(m.BlockTime):]) + n4, err4 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.BlockTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.BlockTime):]) if err4 != nil { return 0, err4 } @@ -2484,7 +2484,7 @@ func (m *QueryTraceBlockRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) _ = i var l int _ = l - n7, err7 := github_com_cosmos_gogoproto_types.StdTimeMarshalTo(m.BlockTime, dAtA[i-github_com_cosmos_gogoproto_types.SizeOfStdTime(m.BlockTime):]) + n7, err7 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.BlockTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.BlockTime):]) if err7 != nil { return 0, err7 } @@ -2867,7 +2867,7 @@ func (m *QueryTraceTxRequest) Size() (n int) { if l > 0 { n += 1 + l + sovQuery(uint64(l)) } - l = github_com_cosmos_gogoproto_types.SizeOfStdTime(m.BlockTime) + l = github_com_gogo_protobuf_types.SizeOfStdTime(m.BlockTime) n += 1 + l + sovQuery(uint64(l)) return n } @@ -2908,7 +2908,7 @@ func (m *QueryTraceBlockRequest) Size() (n int) { if l > 0 { n += 1 + l + sovQuery(uint64(l)) } - l = github_com_cosmos_gogoproto_types.SizeOfStdTime(m.BlockTime) + l = github_com_gogo_protobuf_types.SizeOfStdTime(m.BlockTime) n += 1 + l + sovQuery(uint64(l)) return n } @@ -4854,7 +4854,7 @@ func (m *QueryTraceTxRequest) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if err := github_com_cosmos_gogoproto_types.StdTimeUnmarshal(&m.BlockTime, dAtA[iNdEx:postIndex]); err != nil { + if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.BlockTime, dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -5142,7 +5142,7 @@ func (m *QueryTraceBlockRequest) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if err := github_com_cosmos_gogoproto_types.StdTimeUnmarshal(&m.BlockTime, dAtA[iNdEx:postIndex]); err != nil { + if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.BlockTime, dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex diff --git a/ethermint/x/evm/types/tx.pb.go b/ethermint/x/evm/types/tx.pb.go index 5a1d21d..e9d9177 100644 --- a/ethermint/x/evm/types/tx.pb.go +++ b/ethermint/x/evm/types/tx.pb.go @@ -8,9 +8,9 @@ import ( encoding_binary "encoding/binary" fmt "fmt" github_com_cosmos_cosmos_sdk_types "github.com/cosmos/cosmos-sdk/types" - grpc1 "github.com/cosmos/gogoproto/grpc" - proto "github.com/cosmos/gogoproto/proto" _ "github.com/gogo/protobuf/gogoproto" + grpc1 "github.com/gogo/protobuf/grpc" + proto "github.com/gogo/protobuf/proto" types "github.com/irisnet/core-sdk-go/common/codec/types" _ "github.com/regen-network/cosmos-proto" _ "google.golang.org/genproto/googleapis/api/annotations" diff --git a/feegrant/feegrant.pb.go b/feegrant/feegrant.pb.go index 229a9bc..b61e789 100644 --- a/feegrant/feegrant.pb.go +++ b/feegrant/feegrant.pb.go @@ -5,9 +5,9 @@ package feegrant import ( fmt "fmt" - proto "github.com/cosmos/gogoproto/proto" - github_com_cosmos_gogoproto_types "github.com/cosmos/gogoproto/types" _ "github.com/gogo/protobuf/gogoproto" + proto "github.com/gogo/protobuf/proto" + github_com_gogo_protobuf_types "github.com/gogo/protobuf/types" types1 "github.com/irisnet/core-sdk-go/common/codec/types" github_com_irisnet_core_sdk_go_types "github.com/irisnet/core-sdk-go/types" types "github.com/irisnet/core-sdk-go/types" @@ -354,7 +354,7 @@ func (m *BasicAllowance) MarshalToSizedBuffer(dAtA []byte) (int, error) { var l int _ = l if m.Expiration != nil { - n1, err1 := github_com_cosmos_gogoproto_types.StdTimeMarshalTo(*m.Expiration, dAtA[i-github_com_cosmos_gogoproto_types.SizeOfStdTime(*m.Expiration):]) + n1, err1 := github_com_gogo_protobuf_types.StdTimeMarshalTo(*m.Expiration, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(*m.Expiration):]) if err1 != nil { return 0, err1 } @@ -400,7 +400,7 @@ func (m *PeriodicAllowance) MarshalToSizedBuffer(dAtA []byte) (int, error) { _ = i var l int _ = l - n2, err2 := github_com_cosmos_gogoproto_types.StdTimeMarshalTo(m.PeriodReset, dAtA[i-github_com_cosmos_gogoproto_types.SizeOfStdTime(m.PeriodReset):]) + n2, err2 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.PeriodReset, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.PeriodReset):]) if err2 != nil { return 0, err2 } @@ -436,7 +436,7 @@ func (m *PeriodicAllowance) MarshalToSizedBuffer(dAtA []byte) (int, error) { dAtA[i] = 0x1a } } - n3, err3 := github_com_cosmos_gogoproto_types.StdDurationMarshalTo(m.Period, dAtA[i-github_com_cosmos_gogoproto_types.SizeOfStdDuration(m.Period):]) + n3, err3 := github_com_gogo_protobuf_types.StdDurationMarshalTo(m.Period, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdDuration(m.Period):]) if err3 != nil { return 0, err3 } @@ -574,7 +574,7 @@ func (m *BasicAllowance) Size() (n int) { } } if m.Expiration != nil { - l = github_com_cosmos_gogoproto_types.SizeOfStdTime(*m.Expiration) + l = github_com_gogo_protobuf_types.SizeOfStdTime(*m.Expiration) n += 1 + l + sovFeegrant(uint64(l)) } return n @@ -588,7 +588,7 @@ func (m *PeriodicAllowance) Size() (n int) { _ = l l = m.Basic.Size() n += 1 + l + sovFeegrant(uint64(l)) - l = github_com_cosmos_gogoproto_types.SizeOfStdDuration(m.Period) + l = github_com_gogo_protobuf_types.SizeOfStdDuration(m.Period) n += 1 + l + sovFeegrant(uint64(l)) if len(m.PeriodSpendLimit) > 0 { for _, e := range m.PeriodSpendLimit { @@ -602,7 +602,7 @@ func (m *PeriodicAllowance) Size() (n int) { n += 1 + l + sovFeegrant(uint64(l)) } } - l = github_com_cosmos_gogoproto_types.SizeOfStdTime(m.PeriodReset) + l = github_com_gogo_protobuf_types.SizeOfStdTime(m.PeriodReset) n += 1 + l + sovFeegrant(uint64(l)) return n } @@ -748,7 +748,7 @@ func (m *BasicAllowance) Unmarshal(dAtA []byte) error { if m.Expiration == nil { m.Expiration = new(time.Time) } - if err := github_com_cosmos_gogoproto_types.StdTimeUnmarshal(m.Expiration, dAtA[iNdEx:postIndex]); err != nil { + if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(m.Expiration, dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -864,7 +864,7 @@ func (m *PeriodicAllowance) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if err := github_com_cosmos_gogoproto_types.StdDurationUnmarshal(&m.Period, dAtA[iNdEx:postIndex]); err != nil { + if err := github_com_gogo_protobuf_types.StdDurationUnmarshal(&m.Period, dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -965,7 +965,7 @@ func (m *PeriodicAllowance) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if err := github_com_cosmos_gogoproto_types.StdTimeUnmarshal(&m.PeriodReset, dAtA[iNdEx:postIndex]); err != nil { + if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.PeriodReset, dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex diff --git a/feegrant/query.pb.go b/feegrant/query.pb.go index bcb553c..6a1d2f1 100644 --- a/feegrant/query.pb.go +++ b/feegrant/query.pb.go @@ -6,8 +6,8 @@ package feegrant import ( context "context" fmt "fmt" - grpc1 "github.com/cosmos/gogoproto/grpc" - proto "github.com/cosmos/gogoproto/proto" + grpc1 "github.com/gogo/protobuf/grpc" + proto "github.com/gogo/protobuf/proto" query "github.com/irisnet/core-sdk-go/types/query" _ "google.golang.org/genproto/googleapis/api/annotations" grpc "google.golang.org/grpc" diff --git a/feegrant/tx.pb.go b/feegrant/tx.pb.go index d4d8769..8591c56 100644 --- a/feegrant/tx.pb.go +++ b/feegrant/tx.pb.go @@ -6,9 +6,9 @@ package feegrant import ( context "context" fmt "fmt" - grpc1 "github.com/cosmos/gogoproto/grpc" - proto "github.com/cosmos/gogoproto/proto" _ "github.com/gogo/protobuf/gogoproto" + grpc1 "github.com/gogo/protobuf/grpc" + proto "github.com/gogo/protobuf/proto" types "github.com/irisnet/core-sdk-go/common/codec/types" _ "github.com/regen-network/cosmos-proto" grpc "google.golang.org/grpc" diff --git a/gov/gov.pb.go b/gov/gov.pb.go index e3beb5b..52402ea 100644 --- a/gov/gov.pb.go +++ b/gov/gov.pb.go @@ -5,9 +5,9 @@ package gov import ( fmt "fmt" - proto "github.com/cosmos/gogoproto/proto" - github_com_cosmos_gogoproto_types "github.com/cosmos/gogoproto/types" _ "github.com/gogo/protobuf/gogoproto" + proto "github.com/gogo/protobuf/proto" + github_com_gogo_protobuf_types "github.com/gogo/protobuf/types" types1 "github.com/irisnet/core-sdk-go/common/codec/types" github_com_irisnet_core_sdk_go_types "github.com/irisnet/core-sdk-go/types" types "github.com/irisnet/core-sdk-go/types" @@ -773,7 +773,7 @@ func (m *Proposal) MarshalToSizedBuffer(dAtA []byte) (int, error) { _ = i var l int _ = l - n1, err1 := github_com_cosmos_gogoproto_types.StdTimeMarshalTo(m.VotingEndTime, dAtA[i-github_com_cosmos_gogoproto_types.SizeOfStdTime(m.VotingEndTime):]) + n1, err1 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.VotingEndTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.VotingEndTime):]) if err1 != nil { return 0, err1 } @@ -781,7 +781,7 @@ func (m *Proposal) MarshalToSizedBuffer(dAtA []byte) (int, error) { i = encodeVarintGov(dAtA, i, uint64(n1)) i-- dAtA[i] = 0x4a - n2, err2 := github_com_cosmos_gogoproto_types.StdTimeMarshalTo(m.VotingStartTime, dAtA[i-github_com_cosmos_gogoproto_types.SizeOfStdTime(m.VotingStartTime):]) + n2, err2 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.VotingStartTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.VotingStartTime):]) if err2 != nil { return 0, err2 } @@ -803,7 +803,7 @@ func (m *Proposal) MarshalToSizedBuffer(dAtA []byte) (int, error) { dAtA[i] = 0x3a } } - n3, err3 := github_com_cosmos_gogoproto_types.StdTimeMarshalTo(m.DepositEndTime, dAtA[i-github_com_cosmos_gogoproto_types.SizeOfStdTime(m.DepositEndTime):]) + n3, err3 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.DepositEndTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.DepositEndTime):]) if err3 != nil { return 0, err3 } @@ -811,7 +811,7 @@ func (m *Proposal) MarshalToSizedBuffer(dAtA []byte) (int, error) { i = encodeVarintGov(dAtA, i, uint64(n3)) i-- dAtA[i] = 0x32 - n4, err4 := github_com_cosmos_gogoproto_types.StdTimeMarshalTo(m.SubmitTime, dAtA[i-github_com_cosmos_gogoproto_types.SizeOfStdTime(m.SubmitTime):]) + n4, err4 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.SubmitTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.SubmitTime):]) if err4 != nil { return 0, err4 } @@ -977,7 +977,7 @@ func (m *DepositParams) MarshalToSizedBuffer(dAtA []byte) (int, error) { _ = i var l int _ = l - n7, err7 := github_com_cosmos_gogoproto_types.StdDurationMarshalTo(m.MaxDepositPeriod, dAtA[i-github_com_cosmos_gogoproto_types.SizeOfStdDuration(m.MaxDepositPeriod):]) + n7, err7 := github_com_gogo_protobuf_types.StdDurationMarshalTo(m.MaxDepositPeriod, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdDuration(m.MaxDepositPeriod):]) if err7 != nil { return 0, err7 } @@ -1022,7 +1022,7 @@ func (m *VotingParams) MarshalToSizedBuffer(dAtA []byte) (int, error) { _ = i var l int _ = l - n8, err8 := github_com_cosmos_gogoproto_types.StdDurationMarshalTo(m.VotingPeriod, dAtA[i-github_com_cosmos_gogoproto_types.SizeOfStdDuration(m.VotingPeriod):]) + n8, err8 := github_com_gogo_protobuf_types.StdDurationMarshalTo(m.VotingPeriod, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdDuration(m.VotingPeriod):]) if err8 != nil { return 0, err8 } @@ -1154,9 +1154,9 @@ func (m *Proposal) Size() (n int) { } l = m.FinalTallyResult.Size() n += 1 + l + sovGov(uint64(l)) - l = github_com_cosmos_gogoproto_types.SizeOfStdTime(m.SubmitTime) + l = github_com_gogo_protobuf_types.SizeOfStdTime(m.SubmitTime) n += 1 + l + sovGov(uint64(l)) - l = github_com_cosmos_gogoproto_types.SizeOfStdTime(m.DepositEndTime) + l = github_com_gogo_protobuf_types.SizeOfStdTime(m.DepositEndTime) n += 1 + l + sovGov(uint64(l)) if len(m.TotalDeposit) > 0 { for _, e := range m.TotalDeposit { @@ -1164,9 +1164,9 @@ func (m *Proposal) Size() (n int) { n += 1 + l + sovGov(uint64(l)) } } - l = github_com_cosmos_gogoproto_types.SizeOfStdTime(m.VotingStartTime) + l = github_com_gogo_protobuf_types.SizeOfStdTime(m.VotingStartTime) n += 1 + l + sovGov(uint64(l)) - l = github_com_cosmos_gogoproto_types.SizeOfStdTime(m.VotingEndTime) + l = github_com_gogo_protobuf_types.SizeOfStdTime(m.VotingEndTime) n += 1 + l + sovGov(uint64(l)) return n } @@ -1219,7 +1219,7 @@ func (m *DepositParams) Size() (n int) { n += 1 + l + sovGov(uint64(l)) } } - l = github_com_cosmos_gogoproto_types.SizeOfStdDuration(m.MaxDepositPeriod) + l = github_com_gogo_protobuf_types.SizeOfStdDuration(m.MaxDepositPeriod) n += 1 + l + sovGov(uint64(l)) return n } @@ -1230,7 +1230,7 @@ func (m *VotingParams) Size() (n int) { } var l int _ = l - l = github_com_cosmos_gogoproto_types.SizeOfStdDuration(m.VotingPeriod) + l = github_com_gogo_protobuf_types.SizeOfStdDuration(m.VotingPeriod) n += 1 + l + sovGov(uint64(l)) return n } @@ -1670,7 +1670,7 @@ func (m *Proposal) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if err := github_com_cosmos_gogoproto_types.StdTimeUnmarshal(&m.SubmitTime, dAtA[iNdEx:postIndex]); err != nil { + if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.SubmitTime, dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -1703,7 +1703,7 @@ func (m *Proposal) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if err := github_com_cosmos_gogoproto_types.StdTimeUnmarshal(&m.DepositEndTime, dAtA[iNdEx:postIndex]); err != nil { + if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.DepositEndTime, dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -1770,7 +1770,7 @@ func (m *Proposal) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if err := github_com_cosmos_gogoproto_types.StdTimeUnmarshal(&m.VotingStartTime, dAtA[iNdEx:postIndex]); err != nil { + if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.VotingStartTime, dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -1803,7 +1803,7 @@ func (m *Proposal) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if err := github_com_cosmos_gogoproto_types.StdTimeUnmarshal(&m.VotingEndTime, dAtA[iNdEx:postIndex]); err != nil { + if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.VotingEndTime, dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -2226,7 +2226,7 @@ func (m *DepositParams) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if err := github_com_cosmos_gogoproto_types.StdDurationUnmarshal(&m.MaxDepositPeriod, dAtA[iNdEx:postIndex]); err != nil { + if err := github_com_gogo_protobuf_types.StdDurationUnmarshal(&m.MaxDepositPeriod, dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -2309,7 +2309,7 @@ func (m *VotingParams) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if err := github_com_cosmos_gogoproto_types.StdDurationUnmarshal(&m.VotingPeriod, dAtA[iNdEx:postIndex]); err != nil { + if err := github_com_gogo_protobuf_types.StdDurationUnmarshal(&m.VotingPeriod, dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex diff --git a/gov/query.pb.go b/gov/query.pb.go index ce7e182..8ef050d 100644 --- a/gov/query.pb.go +++ b/gov/query.pb.go @@ -6,9 +6,9 @@ package gov import ( context "context" fmt "fmt" - grpc1 "github.com/cosmos/gogoproto/grpc" - proto "github.com/cosmos/gogoproto/proto" _ "github.com/gogo/protobuf/gogoproto" + grpc1 "github.com/gogo/protobuf/grpc" + proto "github.com/gogo/protobuf/proto" query "github.com/irisnet/core-sdk-go/types/query" _ "google.golang.org/genproto/googleapis/api/annotations" grpc "google.golang.org/grpc" diff --git a/gov/tx.pb.go b/gov/tx.pb.go index 4d17926..eed6cdc 100644 --- a/gov/tx.pb.go +++ b/gov/tx.pb.go @@ -6,9 +6,9 @@ package gov import ( context "context" fmt "fmt" - grpc1 "github.com/cosmos/gogoproto/grpc" - proto "github.com/cosmos/gogoproto/proto" _ "github.com/gogo/protobuf/gogoproto" + grpc1 "github.com/gogo/protobuf/grpc" + proto "github.com/gogo/protobuf/proto" types "github.com/irisnet/core-sdk-go/common/codec/types" github_com_irisnet_core_sdk_go_types "github.com/irisnet/core-sdk-go/types" types1 "github.com/irisnet/core-sdk-go/types" diff --git a/ibc/clinet_test.go b/ibc/clinet_test.go new file mode 100644 index 0000000..7013d57 --- /dev/null +++ b/ibc/clinet_test.go @@ -0,0 +1,52 @@ +package ethermint + +import ( + "fmt" + "testing" + + sdk "github.com/irisnet/core-sdk-go" + "github.com/irisnet/core-sdk-go/common/crypto" + "github.com/irisnet/core-sdk-go/types" + sdktypes "github.com/irisnet/core-sdk-go/types" + "github.com/irisnet/core-sdk-go/types/store" +) + +func TestClient(t *testing.T) { + + nodeURI := "tcp://localhost:26657" + grpcAddr := "localhost:9090" + chainID := "wenchangchain" + + bech32AddressPrefix := sdktypes.AddrPrefixCfg{ + AccountAddr: "iaa", + ValidatorAddr: "iva", + ConsensusAddr: "ica", + AccountPub: "iap", + ValidatorPub: "ivp", + ConsensusPub: "icp", + } + options := []sdktypes.Option{ + sdktypes.KeyDAOOption(store.NewMemory(nil)), + sdktypes.TimeoutOption(10), + sdktypes.KeyManagerOption(crypto.NewKeyManager()), + sdktypes.Bech32AddressPrefixOption(&bech32AddressPrefix), + sdktypes.BIP44PathOption(""), + } + cfg, err := types.NewClientConfig(nodeURI, grpcAddr, chainID, options...) + if err != nil { + panic(err) + } + + sdkClient := sdk.NewClient(cfg) + fmt.Println(sdkClient.EncodingConfig().TxConfig) + + //cli := NewClient(nil, txCfg) + //txData := "0xf901470701831e8480941a6640c32b7e6413e839e9dfdb53970ee809b7fb80b8e4990711900000000000000000000000005892e7eeaea5ba624f5ba2900dbab8d2ea36d62b000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000a0000000000000000000000000000000000000000000000000000000000000001a687474703a2f2f6578616d706c652e636f6d2f746f6b656e2f33000000000000000000000000000000000000000000000000000000000000000000000000000974657374686173683200000000000000000000000000000000000000000000008209b2a05dc08aff9f0dac1ed240435510bdd53d8f8eb3f95c44a44f874e9e33ffd2407aa06090bf14d011822f2ff252081684c8e31a5e87d8735ee2f21acc32e87d28304f" + //feePayer := "0x4579DB44FD3A6F645194058914E0A8D5E8F20DB8" + //evmDenom := "ugas" + //rawTx, err := cli.BuildEvmTx(txData, feePayer, evmDenom) + //if err != nil { + // return + //} + //t.Log(rawTx) +} diff --git a/ibc/transfer/query.pb.go b/ibc/transfer/query.pb.go index eeae146..94ff16a 100644 --- a/ibc/transfer/query.pb.go +++ b/ibc/transfer/query.pb.go @@ -6,9 +6,9 @@ package transfer import ( context "context" fmt "fmt" - grpc1 "github.com/cosmos/gogoproto/grpc" - proto "github.com/cosmos/gogoproto/proto" _ "github.com/gogo/protobuf/gogoproto" + grpc1 "github.com/gogo/protobuf/grpc" + proto "github.com/gogo/protobuf/proto" query "github.com/irisnet/core-sdk-go/types/query" _ "google.golang.org/genproto/googleapis/api/annotations" grpc "google.golang.org/grpc" diff --git a/ibc/transfer/tx.pb.go b/ibc/transfer/tx.pb.go index ae84cec..7d6d683 100644 --- a/ibc/transfer/tx.pb.go +++ b/ibc/transfer/tx.pb.go @@ -6,9 +6,9 @@ package transfer import ( context "context" fmt "fmt" - grpc1 "github.com/cosmos/gogoproto/grpc" - proto "github.com/cosmos/gogoproto/proto" _ "github.com/gogo/protobuf/gogoproto" + grpc1 "github.com/gogo/protobuf/grpc" + proto "github.com/gogo/protobuf/proto" types "github.com/irisnet/core-sdk-go/types" grpc "google.golang.org/grpc" codes "google.golang.org/grpc/codes" diff --git a/staking/query.pb.go b/staking/query.pb.go index 814a56d..8754dd4 100644 --- a/staking/query.pb.go +++ b/staking/query.pb.go @@ -6,9 +6,9 @@ package staking import ( context "context" fmt "fmt" - grpc1 "github.com/cosmos/gogoproto/grpc" - proto "github.com/cosmos/gogoproto/proto" _ "github.com/gogo/protobuf/gogoproto" + grpc1 "github.com/gogo/protobuf/grpc" + proto "github.com/gogo/protobuf/proto" query "github.com/irisnet/core-sdk-go/types/query" _ "google.golang.org/genproto/googleapis/api/annotations" grpc "google.golang.org/grpc" diff --git a/staking/staking.pb.go b/staking/staking.pb.go index e8cc2bb..1f6398b 100644 --- a/staking/staking.pb.go +++ b/staking/staking.pb.go @@ -7,11 +7,11 @@ import ( bytes "bytes" compress_gzip "compress/gzip" fmt "fmt" - github_com_cosmos_gogoproto_proto "github.com/cosmos/gogoproto/proto" - proto "github.com/cosmos/gogoproto/proto" - github_com_cosmos_gogoproto_protoc_gen_gogo_descriptor "github.com/cosmos/gogoproto/protoc-gen-gogo/descriptor" - github_com_cosmos_gogoproto_types "github.com/cosmos/gogoproto/types" _ "github.com/gogo/protobuf/gogoproto" + github_com_gogo_protobuf_proto "github.com/gogo/protobuf/proto" + proto "github.com/gogo/protobuf/proto" + github_com_gogo_protobuf_protoc_gen_gogo_descriptor "github.com/gogo/protobuf/protoc-gen-gogo/descriptor" + github_com_gogo_protobuf_types "github.com/gogo/protobuf/types" types1 "github.com/irisnet/core-sdk-go/common/codec/types" github_com_irisnet_core_sdk_go_types "github.com/irisnet/core-sdk-go/types" types2 "github.com/irisnet/core-sdk-go/types" @@ -1210,11 +1210,11 @@ var fileDescriptor_64c30c6cf92913c9 = []byte{ 0x00, 0x00, 0xff, 0xff, 0x0f, 0x95, 0xb2, 0x5b, 0x09, 0x17, 0x00, 0x00, } -func (this *Pool) Description() (desc *github_com_cosmos_gogoproto_protoc_gen_gogo_descriptor.FileDescriptorSet) { +func (this *Pool) Description() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) { return StakingDescription() } -func StakingDescription() (desc *github_com_cosmos_gogoproto_protoc_gen_gogo_descriptor.FileDescriptorSet) { - d := &github_com_cosmos_gogoproto_protoc_gen_gogo_descriptor.FileDescriptorSet{} +func StakingDescription() (desc *github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet) { + d := &github_com_gogo_protobuf_protoc_gen_gogo_descriptor.FileDescriptorSet{} var gzipped = []byte{ // 9513 bytes of a gzipped FileDescriptorSet 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x7d, 0x6d, 0x70, 0x1c, 0xd9, @@ -1822,7 +1822,7 @@ func StakingDescription() (desc *github_com_cosmos_gogoproto_protoc_gen_gogo_des if err != nil { panic(err) } - if err := github_com_cosmos_gogoproto_proto.Unmarshal(ungzipped, d); err != nil { + if err := github_com_gogo_protobuf_proto.Unmarshal(ungzipped, d); err != nil { panic(err) } return d @@ -2196,7 +2196,7 @@ func (m *Commission) MarshalToSizedBuffer(dAtA []byte) (int, error) { _ = i var l int _ = l - n2, err2 := github_com_cosmos_gogoproto_types.StdTimeMarshalTo(m.UpdateTime, dAtA[i-github_com_cosmos_gogoproto_types.SizeOfStdTime(m.UpdateTime):]) + n2, err2 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.UpdateTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.UpdateTime):]) if err2 != nil { return 0, err2 } @@ -2315,7 +2315,7 @@ func (m *Validator) MarshalToSizedBuffer(dAtA []byte) (int, error) { } i-- dAtA[i] = 0x52 - n5, err5 := github_com_cosmos_gogoproto_types.StdTimeMarshalTo(m.UnbondingTime, dAtA[i-github_com_cosmos_gogoproto_types.SizeOfStdTime(m.UnbondingTime):]) + n5, err5 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.UnbondingTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.UnbondingTime):]) if err5 != nil { return 0, err5 } @@ -2720,7 +2720,7 @@ func (m *UnbondingDelegationEntry) MarshalToSizedBuffer(dAtA []byte) (int, error } i-- dAtA[i] = 0x1a - n8, err8 := github_com_cosmos_gogoproto_types.StdTimeMarshalTo(m.CompletionTime, dAtA[i-github_com_cosmos_gogoproto_types.SizeOfStdTime(m.CompletionTime):]) + n8, err8 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.CompletionTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.CompletionTime):]) if err8 != nil { return 0, err8 } @@ -2776,7 +2776,7 @@ func (m *RedelegationEntry) MarshalToSizedBuffer(dAtA []byte) (int, error) { } i-- dAtA[i] = 0x1a - n9, err9 := github_com_cosmos_gogoproto_types.StdTimeMarshalTo(m.CompletionTime, dAtA[i-github_com_cosmos_gogoproto_types.SizeOfStdTime(m.CompletionTime):]) + n9, err9 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.CompletionTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.CompletionTime):]) if err9 != nil { return 0, err9 } @@ -2892,7 +2892,7 @@ func (m *Params) MarshalToSizedBuffer(dAtA []byte) (int, error) { i-- dAtA[i] = 0x10 } - n10, err10 := github_com_cosmos_gogoproto_types.StdDurationMarshalTo(m.UnbondingTime, dAtA[i-github_com_cosmos_gogoproto_types.SizeOfStdDuration(m.UnbondingTime):]) + n10, err10 := github_com_gogo_protobuf_types.StdDurationMarshalTo(m.UnbondingTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdDuration(m.UnbondingTime):]) if err10 != nil { return 0, err10 } @@ -3130,7 +3130,7 @@ func (m *Commission) Size() (n int) { _ = l l = m.CommissionRates.Size() n += 1 + l + sovStaking(uint64(l)) - l = github_com_cosmos_gogoproto_types.SizeOfStdTime(m.UpdateTime) + l = github_com_gogo_protobuf_types.SizeOfStdTime(m.UpdateTime) n += 1 + l + sovStaking(uint64(l)) return n } @@ -3193,7 +3193,7 @@ func (m *Validator) Size() (n int) { if m.UnbondingHeight != 0 { n += 1 + sovStaking(uint64(m.UnbondingHeight)) } - l = github_com_cosmos_gogoproto_types.SizeOfStdTime(m.UnbondingTime) + l = github_com_gogo_protobuf_types.SizeOfStdTime(m.UnbondingTime) n += 1 + l + sovStaking(uint64(l)) l = m.Commission.Size() n += 1 + l + sovStaking(uint64(l)) @@ -3336,7 +3336,7 @@ func (m *UnbondingDelegationEntry) Size() (n int) { if m.CreationHeight != 0 { n += 1 + sovStaking(uint64(m.CreationHeight)) } - l = github_com_cosmos_gogoproto_types.SizeOfStdTime(m.CompletionTime) + l = github_com_gogo_protobuf_types.SizeOfStdTime(m.CompletionTime) n += 1 + l + sovStaking(uint64(l)) l = m.InitialBalance.Size() n += 1 + l + sovStaking(uint64(l)) @@ -3354,7 +3354,7 @@ func (m *RedelegationEntry) Size() (n int) { if m.CreationHeight != 0 { n += 1 + sovStaking(uint64(m.CreationHeight)) } - l = github_com_cosmos_gogoproto_types.SizeOfStdTime(m.CompletionTime) + l = github_com_gogo_protobuf_types.SizeOfStdTime(m.CompletionTime) n += 1 + l + sovStaking(uint64(l)) l = m.InitialBalance.Size() n += 1 + l + sovStaking(uint64(l)) @@ -3396,7 +3396,7 @@ func (m *Params) Size() (n int) { } var l int _ = l - l = github_com_cosmos_gogoproto_types.SizeOfStdDuration(m.UnbondingTime) + l = github_com_gogo_protobuf_types.SizeOfStdDuration(m.UnbondingTime) n += 1 + l + sovStaking(uint64(l)) if m.MaxValidators != 0 { n += 1 + sovStaking(uint64(m.MaxValidators)) @@ -3854,7 +3854,7 @@ func (m *Commission) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if err := github_com_cosmos_gogoproto_types.StdTimeUnmarshal(&m.UpdateTime, dAtA[iNdEx:postIndex]); err != nil { + if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.UpdateTime, dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -4374,7 +4374,7 @@ func (m *Validator) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if err := github_com_cosmos_gogoproto_types.StdTimeUnmarshal(&m.UnbondingTime, dAtA[iNdEx:postIndex]); err != nil { + if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.UnbondingTime, dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -5349,7 +5349,7 @@ func (m *UnbondingDelegationEntry) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if err := github_com_cosmos_gogoproto_types.StdTimeUnmarshal(&m.CompletionTime, dAtA[iNdEx:postIndex]); err != nil { + if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.CompletionTime, dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -5519,7 +5519,7 @@ func (m *RedelegationEntry) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if err := github_com_cosmos_gogoproto_types.StdTimeUnmarshal(&m.CompletionTime, dAtA[iNdEx:postIndex]); err != nil { + if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.CompletionTime, dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -5850,7 +5850,7 @@ func (m *Params) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if err := github_com_cosmos_gogoproto_types.StdDurationUnmarshal(&m.UnbondingTime, dAtA[iNdEx:postIndex]); err != nil { + if err := github_com_gogo_protobuf_types.StdDurationUnmarshal(&m.UnbondingTime, dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex diff --git a/staking/tx.pb.go b/staking/tx.pb.go index be4392e..1f55015 100644 --- a/staking/tx.pb.go +++ b/staking/tx.pb.go @@ -6,10 +6,10 @@ package staking import ( context "context" fmt "fmt" - grpc1 "github.com/cosmos/gogoproto/grpc" - proto "github.com/cosmos/gogoproto/proto" - github_com_cosmos_gogoproto_types "github.com/cosmos/gogoproto/types" _ "github.com/gogo/protobuf/gogoproto" + grpc1 "github.com/gogo/protobuf/grpc" + proto "github.com/gogo/protobuf/proto" + github_com_gogo_protobuf_types "github.com/gogo/protobuf/types" types "github.com/irisnet/core-sdk-go/common/codec/types" github_com_irisnet_core_sdk_go_types "github.com/irisnet/core-sdk-go/types" types1 "github.com/irisnet/core-sdk-go/types" @@ -1107,7 +1107,7 @@ func (m *MsgBeginRedelegateResponse) MarshalToSizedBuffer(dAtA []byte) (int, err _ = i var l int _ = l - n8, err8 := github_com_cosmos_gogoproto_types.StdTimeMarshalTo(m.CompletionTime, dAtA[i-github_com_cosmos_gogoproto_types.SizeOfStdTime(m.CompletionTime):]) + n8, err8 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.CompletionTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.CompletionTime):]) if err8 != nil { return 0, err8 } @@ -1185,7 +1185,7 @@ func (m *MsgUndelegateResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { _ = i var l int _ = l - n10, err10 := github_com_cosmos_gogoproto_types.StdTimeMarshalTo(m.CompletionTime, dAtA[i-github_com_cosmos_gogoproto_types.SizeOfStdTime(m.CompletionTime):]) + n10, err10 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.CompletionTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.CompletionTime):]) if err10 != nil { return 0, err10 } @@ -1334,7 +1334,7 @@ func (m *MsgBeginRedelegateResponse) Size() (n int) { } var l int _ = l - l = github_com_cosmos_gogoproto_types.SizeOfStdTime(m.CompletionTime) + l = github_com_gogo_protobuf_types.SizeOfStdTime(m.CompletionTime) n += 1 + l + sovTx(uint64(l)) return n } @@ -1364,7 +1364,7 @@ func (m *MsgUndelegateResponse) Size() (n int) { } var l int _ = l - l = github_com_cosmos_gogoproto_types.SizeOfStdTime(m.CompletionTime) + l = github_com_gogo_protobuf_types.SizeOfStdTime(m.CompletionTime) n += 1 + l + sovTx(uint64(l)) return n } @@ -2379,7 +2379,7 @@ func (m *MsgBeginRedelegateResponse) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if err := github_com_cosmos_gogoproto_types.StdTimeUnmarshal(&m.CompletionTime, dAtA[iNdEx:postIndex]); err != nil { + if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.CompletionTime, dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -2609,7 +2609,7 @@ func (m *MsgUndelegateResponse) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if err := github_com_cosmos_gogoproto_types.StdTimeUnmarshal(&m.CompletionTime, dAtA[iNdEx:postIndex]); err != nil { + if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.CompletionTime, dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex diff --git a/store/commit_info.pb.go b/store/commit_info.pb.go index bcfdeff..3008ee8 100644 --- a/store/commit_info.pb.go +++ b/store/commit_info.pb.go @@ -5,8 +5,8 @@ package store import ( fmt "fmt" - proto "github.com/cosmos/gogoproto/proto" _ "github.com/gogo/protobuf/gogoproto" + proto "github.com/gogo/protobuf/proto" io "io" math "math" math_bits "math/bits" diff --git a/store/listening.pb.go b/store/listening.pb.go index 46c8423..68a22d5 100644 --- a/store/listening.pb.go +++ b/store/listening.pb.go @@ -5,7 +5,7 @@ package store import ( fmt "fmt" - proto "github.com/cosmos/gogoproto/proto" + proto "github.com/gogo/protobuf/proto" io "io" math "math" math_bits "math/bits" diff --git a/store/snapshot.pb.go b/store/snapshot.pb.go index 83b1ce9..e7a318c 100644 --- a/store/snapshot.pb.go +++ b/store/snapshot.pb.go @@ -5,8 +5,8 @@ package store import ( fmt "fmt" - proto "github.com/cosmos/gogoproto/proto" _ "github.com/gogo/protobuf/gogoproto" + proto "github.com/gogo/protobuf/proto" io "io" math "math" math_bits "math/bits" diff --git a/store/types/snapshots/snapshot.pb.go b/store/types/snapshots/snapshot.pb.go index 2ef660f..3641f60 100644 --- a/store/types/snapshots/snapshot.pb.go +++ b/store/types/snapshots/snapshot.pb.go @@ -5,8 +5,8 @@ package snapshots import ( fmt "fmt" - proto "github.com/cosmos/gogoproto/proto" _ "github.com/gogo/protobuf/gogoproto" + proto "github.com/gogo/protobuf/proto" io "io" math "math" math_bits "math/bits" diff --git a/types/abci.pb.go b/types/abci.pb.go index 1d9c19c..9bdfeff 100644 --- a/types/abci.pb.go +++ b/types/abci.pb.go @@ -5,8 +5,8 @@ package types import ( fmt "fmt" - proto "github.com/cosmos/gogoproto/proto" _ "github.com/gogo/protobuf/gogoproto" + proto "github.com/gogo/protobuf/proto" types "github.com/irisnet/core-sdk-go/common/codec/types" types1 "github.com/tendermint/tendermint/abci/types" io "io" diff --git a/types/auth/auth.pb.go b/types/auth/auth.pb.go index e0f01b9..038f5eb 100644 --- a/types/auth/auth.pb.go +++ b/types/auth/auth.pb.go @@ -5,8 +5,8 @@ package auth import ( fmt "fmt" - proto "github.com/cosmos/gogoproto/proto" _ "github.com/gogo/protobuf/gogoproto" + proto "github.com/gogo/protobuf/proto" types "github.com/irisnet/core-sdk-go/common/codec/types" _ "github.com/regen-network/cosmos-proto" io "io" diff --git a/types/auth/query.pb.go b/types/auth/query.pb.go index f224841..694dae5 100644 --- a/types/auth/query.pb.go +++ b/types/auth/query.pb.go @@ -6,9 +6,9 @@ package auth import ( context "context" fmt "fmt" - grpc1 "github.com/cosmos/gogoproto/grpc" - proto "github.com/cosmos/gogoproto/proto" _ "github.com/gogo/protobuf/gogoproto" + grpc1 "github.com/gogo/protobuf/grpc" + proto "github.com/gogo/protobuf/proto" types "github.com/irisnet/core-sdk-go/common/codec/types" _ "github.com/regen-network/cosmos-proto" _ "google.golang.org/genproto/googleapis/api/annotations" diff --git a/types/coin.pb.go b/types/coin.pb.go index fc3862a..38f8ec3 100644 --- a/types/coin.pb.go +++ b/types/coin.pb.go @@ -5,8 +5,8 @@ package types import ( fmt "fmt" - proto "github.com/cosmos/gogoproto/proto" _ "github.com/gogo/protobuf/gogoproto" + proto "github.com/gogo/protobuf/proto" io "io" math "math" math_bits "math/bits" diff --git a/types/kv/kv.pb.go b/types/kv/kv.pb.go index 137733d..be1963c 100644 --- a/types/kv/kv.pb.go +++ b/types/kv/kv.pb.go @@ -5,8 +5,8 @@ package kv import ( fmt "fmt" - proto "github.com/cosmos/gogoproto/proto" _ "github.com/gogo/protobuf/gogoproto" + proto "github.com/gogo/protobuf/proto" io "io" math "math" math_bits "math/bits" diff --git a/types/query/pagination.pb.go b/types/query/pagination.pb.go index 93154ea..0550c87 100644 --- a/types/query/pagination.pb.go +++ b/types/query/pagination.pb.go @@ -5,7 +5,7 @@ package query import ( fmt "fmt" - proto "github.com/cosmos/gogoproto/proto" + proto "github.com/gogo/protobuf/proto" io "io" math "math" math_bits "math/bits" diff --git a/types/tx/signing/signing.pb.go b/types/tx/signing/signing.pb.go index 767dc61..75e668e 100644 --- a/types/tx/signing/signing.pb.go +++ b/types/tx/signing/signing.pb.go @@ -5,7 +5,7 @@ package signing import ( fmt "fmt" - proto "github.com/cosmos/gogoproto/proto" + proto "github.com/gogo/protobuf/proto" types "github.com/irisnet/core-sdk-go/common/codec/types" types1 "github.com/irisnet/core-sdk-go/common/crypto/types" io "io" diff --git a/types/tx/tx.pb.go b/types/tx/tx.pb.go index e64e251..dec3352 100644 --- a/types/tx/tx.pb.go +++ b/types/tx/tx.pb.go @@ -5,8 +5,8 @@ package tx import ( fmt "fmt" - proto "github.com/cosmos/gogoproto/proto" _ "github.com/gogo/protobuf/gogoproto" + proto "github.com/gogo/protobuf/proto" types "github.com/irisnet/core-sdk-go/common/codec/types" types1 "github.com/irisnet/core-sdk-go/common/crypto/types" github_com_irisnet_core_sdk_go_types "github.com/irisnet/core-sdk-go/types" From 6974c08df4726b7bfea6faa5d0162fd7cf6b75da Mon Sep 17 00:00:00 2001 From: aofengli <996177263@qq.com> Date: Thu, 16 Mar 2023 16:20:27 +0800 Subject: [PATCH 04/17] query tx add data feiled --- client/keys.go | 3 +++ client/tx.go | 1 + ethermint/clinet_test.go | 52 ++++++++++++++++++++++++++++++++++++---- types/event.go | 15 ++++++------ 4 files changed, 60 insertions(+), 11 deletions(-) diff --git a/client/keys.go b/client/keys.go index c94c131..4627294 100644 --- a/client/keys.go +++ b/client/keys.go @@ -131,6 +131,9 @@ func (k KeyManager) Import(name, password, armor string) (string, error) { Algo: k.Algo, } + fmt.Println(string(cryptoamino.MarshalPubkey(pubKey))) + fmt.Println(string(cryptoamino.MarshalPrivKey(priv))) + err = k.KeyDAO.Write(name, password, info) if err != nil { return "", err diff --git a/client/tx.go b/client/tx.go index 3e336b1..76b6322 100644 --- a/client/tx.go +++ b/client/tx.go @@ -232,6 +232,7 @@ func (base baseClient) parseTxResult(res *ctypes.ResultTx, resBlock *ctypes.Resu GasWanted: res.TxResult.GasWanted, GasUsed: res.TxResult.GasUsed, Events: sdk.StringifyEvents(res.TxResult.Events), + Data: res.TxResult.Data, }, Timestamp: resBlock.Block.Time.Format(time.RFC3339), }, nil diff --git a/ethermint/clinet_test.go b/ethermint/clinet_test.go index f5bc1fc..c44e462 100644 --- a/ethermint/clinet_test.go +++ b/ethermint/clinet_test.go @@ -4,18 +4,38 @@ import ( "context" "testing" + "github.com/gogo/protobuf/proto" + + "github.com/ethereum/go-ethereum/common" + sdk "github.com/irisnet/core-sdk-go" "github.com/irisnet/core-sdk-go/common/crypto" + evmtypes "github.com/irisnet/core-sdk-go/ethermint/x/evm/types" "github.com/irisnet/core-sdk-go/types" sdktypes "github.com/irisnet/core-sdk-go/types" "github.com/irisnet/core-sdk-go/types/store" ) +func TestError(t *testing.T) { + hex := "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" + bytesData := common.Hex2Bytes(hex) + resp := &evmtypes.MsgEthereumTxResponse{} + err := proto.Unmarshal(bytesData, resp) + if err != nil { + t.Fatal(err) + } + //revertErr := evmtypes.NewExecErrorWithReason(resp.Ret) + //t.Log(revertErr) +} + func TestClient(t *testing.T) { - nodeURI := "tcp://localhost:26657" - grpcAddr := "localhost:9090" - chainID := "wenchangchain" + //nodeURI := "tcp://localhost:26657" + //grpcAddr := "localhost:9090" + //chainID := "wenchangchain" + nodeURI := "tcp://192.168.0.160:26657" + grpcAddr := "192.168.0.160:9090" + chainID := "wenchangchain-qa" bech32AddressPrefix := sdktypes.AddrPrefixCfg{ AccountAddr: "iaa", @@ -40,6 +60,29 @@ func TestClient(t *testing.T) { sdkClient := sdk.NewClient(cfg) cli := NewClient(sdkClient.BaseClient, sdkClient.EncodingConfig().TxConfig) + cli.RegisterInterfaceTypes(sdkClient.EncodingConfig().InterfaceRegistry) + + resp1, err := sdkClient.QueryTx("CCF73180DFF268DE3E451B5A59CDE9FA8E4D2BEF925158FD73A86A4E64400077") + if err != nil { + panic(err) + } + txResponse, err := evmtypes.DecodeTxResponse(resp1.Result.Data) + if err != nil { + return + } + + if txResponse.Ret == nil { + return + } + + revetErr := evmtypes.NewExecErrorWithReason(txResponse.Ret) + if err != nil { + return + } + t.Log(revetErr) + + return + txData := "0xf901470801831e8480941a6640c32b7e6413e839e9dfdb53970ee809b7fb80b8e4990711900000000000000000000000005892e7eeaea5ba624f5ba2900dbab8d2ea36d62b000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000a0000000000000000000000000000000000000000000000000000000000000001a687474703a2f2f6578616d706c652e636f6d2f746f6b656e2f35000000000000000000000000000000000000000000000000000000000000000000000000000974657374686173683600000000000000000000000000000000000000000000008209b2a050e1d159818efbae1c536b2c866920ac3c8c3720b9194b02c5ecea7717f85d2da05eabeb96aad81f432e1d7d3f84e6d38ce939e7a2d1f0bee3af2f20f507c91b96" feePayer := "0x4579DB44FD3A6F645194058914E0A8D5E8F20DB8" evmDenom := "ugas" @@ -48,7 +91,8 @@ func TestClient(t *testing.T) { t.Log(err) return } - + priv := "-----BEGIN TENDERMINT PRIVATE KEY-----\nkdf: bcrypt\nsalt: 7FDD1E16A62E8B6AF914ECADCFF815FD\ntype: eth_secp256k1\n\nDHoFvjH6+FNcAj8be7oGXnpfQWlSnPG9o/yLezuDmnQWtkPcTqaAfizPG18PU3hq\nYWWxhh1a+/MNxF9u85h3Tv3vq/a7EebOsBf3AXI=\n=PI4S\n-----END TENDERMINT PRIVATE KEY-----" + sdkClient.Key.Import("test01", "12345678", priv) resp, err := cli.BroadcastTxSync(context.Background(), rawTx) if err != nil { t.Log(err) diff --git a/types/event.go b/types/event.go index 51fc0cf..2156ef4 100644 --- a/types/event.go +++ b/types/event.go @@ -58,6 +58,7 @@ type TxResult struct { GasWanted int64 `json:"gas_wanted"` GasUsed int64 `json:"gas_used"` Events StringEvents `json:"events"` + Data []byte `json:"data"` } type Attributes []Attribute @@ -90,7 +91,7 @@ func (a Attributes) String() string { type EventTxHandler func(EventDataTx) -//EventDataNewBlock for SubscribeNewBlock +// EventDataNewBlock for SubscribeNewBlock type EventDataNewBlock struct { Block Block `json:"block"` ResultBeginBlock ResultBeginBlock `json:"result_begin_block"` @@ -109,7 +110,7 @@ type PubKey struct { type EventNewBlockHandler func(EventDataNewBlock) -//EventDataNewBlockHeader for SubscribeNewBlockHeader +// EventDataNewBlockHeader for SubscribeNewBlockHeader type EventDataNewBlockHeader struct { Header Header `json:"header"` @@ -119,7 +120,7 @@ type EventDataNewBlockHeader struct { type EventNewBlockHeaderHandler func(EventDataNewBlockHeader) -//EventDataValidatorSetUpdates for SubscribeValidatorSetUpdates +// EventDataValidatorSetUpdates for SubscribeValidatorSetUpdates type Validator struct { Bech32Address string `json:"bech32_address"` Bech32PubKey string `json:"bech32_pubkey"` @@ -134,7 +135,7 @@ type EventDataValidatorSetUpdates struct { type EventValidatorSetUpdatesHandler func(EventDataValidatorSetUpdates) -//EventQueryBuilder for build query string +// EventQueryBuilder for build query string type condition struct { key EventKey value EventValue @@ -198,7 +199,7 @@ func (c *condition) String() string { } } -//EventQueryBuilder is responsible for constructing listening conditions +// EventQueryBuilder is responsible for constructing listening conditions type EventQueryBuilder struct { conditions []string } @@ -209,7 +210,7 @@ func NewEventQueryBuilder() *EventQueryBuilder { } } -//AddCondition is responsible for adding listening conditions +// AddCondition is responsible for adding listening conditions func (eqb *EventQueryBuilder) AddCondition(c *condition) *EventQueryBuilder { if c == nil { return nil @@ -218,7 +219,7 @@ func (eqb *EventQueryBuilder) AddCondition(c *condition) *EventQueryBuilder { return eqb } -//Build is responsible for constructing the listening condition into a listening instruction identified by tendermint +// Build is responsible for constructing the listening condition into a listening instruction identified by tendermint func (eqb *EventQueryBuilder) Build() string { var buf bytes.Buffer for _, condition := range eqb.conditions { From 58b3f4d8549887e4957fafbf7586912fdb145329 Mon Sep 17 00:00:00 2001 From: sxj Date: Fri, 17 Mar 2023 14:37:36 +0800 Subject: [PATCH 05/17] stash --- ethermint/clinet_test.go | 13 +++++++++---- 1 file changed, 9 insertions(+), 4 deletions(-) diff --git a/ethermint/clinet_test.go b/ethermint/clinet_test.go index c44e462..bad542a 100644 --- a/ethermint/clinet_test.go +++ b/ethermint/clinet_test.go @@ -2,6 +2,7 @@ package ethermint import ( "context" + "fmt" "testing" "github.com/gogo/protobuf/proto" @@ -62,7 +63,7 @@ func TestClient(t *testing.T) { cli := NewClient(sdkClient.BaseClient, sdkClient.EncodingConfig().TxConfig) cli.RegisterInterfaceTypes(sdkClient.EncodingConfig().InterfaceRegistry) - resp1, err := sdkClient.QueryTx("CCF73180DFF268DE3E451B5A59CDE9FA8E4D2BEF925158FD73A86A4E64400077") + resp1, err := sdkClient.QueryTx("51A728BAEA19FE27DC0F221B0F04C2A75D55C2D723F30FA67391AEDBF65F8049") if err != nil { panic(err) } @@ -71,11 +72,15 @@ func TestClient(t *testing.T) { return } - if txResponse.Ret == nil { - return - } + //if txResponse.Ret == nil { + // fmt.Println("no err") + // return + //} revetErr := evmtypes.NewExecErrorWithReason(txResponse.Ret) + fmt.Println(revetErr.ErrorData()) + fmt.Println(revetErr.ErrorCode()) + fmt.Println(revetErr.Error()) if err != nil { return } From 450db2ebf089581f46976db556dc2eebaf56e88b Mon Sep 17 00:00:00 2001 From: sxj Date: Tue, 16 May 2023 13:56:09 +0800 Subject: [PATCH 06/17] stash --- client/base_client.go | 30 ++++++++++++++ types/client.go | 2 + types/factory.go | 91 +++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 123 insertions(+) diff --git a/client/base_client.go b/client/base_client.go index 1c4ef74..b111f8f 100644 --- a/client/base_client.go +++ b/client/base_client.go @@ -279,6 +279,36 @@ func (base *baseClient) SendBatch(msgs sdktypes.Msgs, baseTx sdktypes.BaseTx) (r return rs, nil } +func (base *baseClient) BuildTx(msg []sdktypes.Msg, baseTx sdktypes.BaseTx) ([]byte, sdktypes.Error) { + builder, err := base.prepare(baseTx) + if err != nil { + return nil, sdktypes.Wrap(err) + } + + unsignedTxBytes, err := builder.BuildTx(baseTx.From, msg) + if err != nil { + return nil, sdktypes.Wrap(err) + } + + base.Logger().Debug("sign transaction success") + return unsignedTxBytes, nil +} + +func (base *baseClient) SetUnsignedTxSignature(msg []sdktypes.Msg, baseTx sdktypes.BaseTx, signedData []byte) ([]byte, sdktypes.Error) { + builder, err := base.prepare(baseTx) + if err != nil { + return nil, sdktypes.Wrap(err) + } + + txByte, err := builder.SetUnsignedTxSignature(baseTx.From, msg, signedData) + if err != nil { + return nil, sdktypes.Wrap(err) + } + + base.Logger().Debug("sign transaction success") + return txByte, nil +} + func (base baseClient) QueryWithResponse(path string, data interface{}, result sdktypes.Response) error { res, err := base.Query(path, data) if err != nil { diff --git a/types/client.go b/types/client.go index 1b96057..d5a93e2 100644 --- a/types/client.go +++ b/types/client.go @@ -14,6 +14,8 @@ type TxManager interface { BuildTxHash(msg []Msg, baseTx BaseTx) (string, Error) BuildAndSendWithAccount(addr string, accountNumber, sequence uint64, msg []Msg, baseTx BaseTx) (ResultTx, Error) BuildAndSignWithAccount(addr string, accountNumber, sequence uint64, msg []Msg, baseTx BaseTx) ([]byte, Error) + BuildTx(msg []Msg, baseTx BaseTx) ([]byte, Error) + SetUnsignedTxSignature(msg []Msg, baseTx BaseTx, signedData []byte) ([]byte, Error) } type Queries interface { diff --git a/types/factory.go b/types/factory.go index 9f281de..efce60a 100644 --- a/types/factory.go +++ b/types/factory.go @@ -213,6 +213,97 @@ func (f *Factory) BuildAndSign(name string, msgs []Msg, json bool) ([]byte, erro return txBytes, nil } +func (f *Factory) BuildTx(name string, msgs []Msg) ([]byte, error) { + tx, err := f.BuildUnsignedTx(msgs) + if err != nil { + return []byte{}, err + } + + signMode := f.signMode + if signMode == signing.SignMode_SIGN_MODE_UNSPECIFIED { + // use the SignModeHandler's default mode if unspecified + signMode = f.txConfig.SignModeHandler().DefaultMode() + } + signerData := SignerData{ + ChainID: f.chainID, + AccountNumber: f.accountNumber, + Sequence: f.sequence, + } + + pubkey, _, err := f.keyManager.Find(name, f.password) + if err != nil { + return []byte{}, err + } + + // For SIGN_MODE_DIRECT, calling SetSignatures calls setSignerInfos on + // Factory under the hood, and SignerInfos is needed to generated the + // sign bytes. This is the reason for setting SetSignatures here, with a + // nil signature. + // + // Note: this line is not needed for SIGN_MODE_LEGACY_AMINO, but putting it + // also doesn't affect its generated sign bytes, so for code's simplicity + // sake, we put it here. + sigData := signing.SingleSignatureData{ + SignMode: signMode, + Signature: nil, + } + sig := signing.SignatureV2{ + PubKey: pubkey, + Data: &sigData, + Sequence: f.Sequence(), + } + if err := tx.SetSignatures(sig); err != nil { + return []byte{}, err + } + + // Generate the bytes to be signed. + signBytes, err := f.signModeHandler.GetSignBytes(signMode, signerData, tx.GetTx()) + if err != nil { + return []byte{}, err + } + + return signBytes, nil +} + +func (f *Factory) SetUnsignedTxSignature(name string, msgs []Msg, signedData []byte) ([]byte, error) { + tx, err := f.BuildUnsignedTx(msgs) + if err != nil { + return []byte{}, err + } + + signMode := f.signMode + if signMode == signing.SignMode_SIGN_MODE_UNSPECIFIED { + // use the SignModeHandler's default mode if unspecified + signMode = f.txConfig.SignModeHandler().DefaultMode() + } + + pubkey, _, err := f.keyManager.Find(name, f.password) + if err != nil { + return []byte{}, err + } + + // Construct the SignatureV2 struct + sigData := signing.SingleSignatureData{ + SignMode: signMode, + Signature: signedData, + } + sig := signing.SignatureV2{ + PubKey: pubkey, + Data: &sigData, + Sequence: f.Sequence(), + } + + // And here the tx is populated with the signature + tx.SetSignatures(sig) + + txBytes, err := f.txConfig.TxEncoder()(tx.GetTx()) + if err != nil { + return nil, err + } + + return txBytes, nil +} + func (f *Factory) BuildUnsignedTx(msgs []Msg) (TxBuilder, error) { if f.chainID == "" { return nil, fmt.Errorf("chain ID required but not specified") From 16966eae22c2d3c877a350871bd0cfb104e385c6 Mon Sep 17 00:00:00 2001 From: sxj Date: Tue, 16 May 2023 14:42:00 +0800 Subject: [PATCH 07/17] stash --- client/base_client.go | 8 ++++---- types/client.go | 4 ++-- 2 files changed, 6 insertions(+), 6 deletions(-) diff --git a/client/base_client.go b/client/base_client.go index b111f8f..9e0c97c 100644 --- a/client/base_client.go +++ b/client/base_client.go @@ -279,8 +279,8 @@ func (base *baseClient) SendBatch(msgs sdktypes.Msgs, baseTx sdktypes.BaseTx) (r return rs, nil } -func (base *baseClient) BuildTx(msg []sdktypes.Msg, baseTx sdktypes.BaseTx) ([]byte, sdktypes.Error) { - builder, err := base.prepare(baseTx) +func (base *baseClient) BuildTx(addr string, sequence, accountNumber uint64, msg []sdktypes.Msg, baseTx sdktypes.BaseTx) ([]byte, sdktypes.Error) { + builder, err := base.prepareWithAccount(addr, sequence, accountNumber, baseTx) if err != nil { return nil, sdktypes.Wrap(err) } @@ -294,8 +294,8 @@ func (base *baseClient) BuildTx(msg []sdktypes.Msg, baseTx sdktypes.BaseTx) ([]b return unsignedTxBytes, nil } -func (base *baseClient) SetUnsignedTxSignature(msg []sdktypes.Msg, baseTx sdktypes.BaseTx, signedData []byte) ([]byte, sdktypes.Error) { - builder, err := base.prepare(baseTx) +func (base *baseClient) SetUnsignedTxSignature(addr string, sequence, accountNumber uint64, msg []sdktypes.Msg, baseTx sdktypes.BaseTx, signedData []byte) ([]byte, sdktypes.Error) { + builder, err := base.prepareWithAccount(addr, sequence, accountNumber, baseTx) if err != nil { return nil, sdktypes.Wrap(err) } diff --git a/types/client.go b/types/client.go index d5a93e2..7af1e7e 100644 --- a/types/client.go +++ b/types/client.go @@ -14,8 +14,8 @@ type TxManager interface { BuildTxHash(msg []Msg, baseTx BaseTx) (string, Error) BuildAndSendWithAccount(addr string, accountNumber, sequence uint64, msg []Msg, baseTx BaseTx) (ResultTx, Error) BuildAndSignWithAccount(addr string, accountNumber, sequence uint64, msg []Msg, baseTx BaseTx) ([]byte, Error) - BuildTx(msg []Msg, baseTx BaseTx) ([]byte, Error) - SetUnsignedTxSignature(msg []Msg, baseTx BaseTx, signedData []byte) ([]byte, Error) + BuildTx(addr string, sequence, accountNumber uint64, msg []Msg, baseTx BaseTx) ([]byte, Error) + SetUnsignedTxSignature(addr string, sequence, accountNumber uint64, msg []Msg, baseTx BaseTx, signedData []byte) ([]byte, Error) } type Queries interface { From 1841085556514a0d6c87e7f36bfdf0b4d5e851c4 Mon Sep 17 00:00:00 2001 From: sxj Date: Tue, 16 May 2023 16:21:18 +0800 Subject: [PATCH 08/17] stash --- client/base_client.go | 2 +- types/client.go | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/client/base_client.go b/client/base_client.go index 9e0c97c..5cbcc84 100644 --- a/client/base_client.go +++ b/client/base_client.go @@ -294,7 +294,7 @@ func (base *baseClient) BuildTx(addr string, sequence, accountNumber uint64, msg return unsignedTxBytes, nil } -func (base *baseClient) SetUnsignedTxSignature(addr string, sequence, accountNumber uint64, msg []sdktypes.Msg, baseTx sdktypes.BaseTx, signedData []byte) ([]byte, sdktypes.Error) { +func (base *baseClient) SetTxSignature(addr string, sequence, accountNumber uint64, msg []sdktypes.Msg, baseTx sdktypes.BaseTx, signedData []byte) ([]byte, sdktypes.Error) { builder, err := base.prepareWithAccount(addr, sequence, accountNumber, baseTx) if err != nil { return nil, sdktypes.Wrap(err) diff --git a/types/client.go b/types/client.go index 7af1e7e..826b08d 100644 --- a/types/client.go +++ b/types/client.go @@ -15,7 +15,7 @@ type TxManager interface { BuildAndSendWithAccount(addr string, accountNumber, sequence uint64, msg []Msg, baseTx BaseTx) (ResultTx, Error) BuildAndSignWithAccount(addr string, accountNumber, sequence uint64, msg []Msg, baseTx BaseTx) ([]byte, Error) BuildTx(addr string, sequence, accountNumber uint64, msg []Msg, baseTx BaseTx) ([]byte, Error) - SetUnsignedTxSignature(addr string, sequence, accountNumber uint64, msg []Msg, baseTx BaseTx, signedData []byte) ([]byte, Error) + SetTxSignature(addr string, sequence, accountNumber uint64, msg []Msg, baseTx BaseTx, signedData []byte) ([]byte, Error) } type Queries interface { From 37ff93e6406a74b741530b4506ecfca9b4d86445 Mon Sep 17 00:00:00 2001 From: sxj Date: Tue, 16 May 2023 18:41:30 +0800 Subject: [PATCH 09/17] add buildtx for avata --- types/factory.go | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/types/factory.go b/types/factory.go index efce60a..adefb05 100644 --- a/types/factory.go +++ b/types/factory.go @@ -3,6 +3,7 @@ package types import ( "errors" "fmt" + "github.com/ethereum/go-ethereum/crypto" "github.com/irisnet/core-sdk-go/types/tx/signing" ) @@ -262,7 +263,7 @@ func (f *Factory) BuildTx(name string, msgs []Msg) ([]byte, error) { return []byte{}, err } - return signBytes, nil + return crypto.Keccak256Hash(signBytes).Bytes(), nil } func (f *Factory) SetUnsignedTxSignature(name string, msgs []Msg, signedData []byte) ([]byte, error) { From 22a04f7d51bcd86bd8f9bb341016e9c85b381cf9 Mon Sep 17 00:00:00 2001 From: sxj Date: Mon, 22 May 2023 11:34:12 +0800 Subject: [PATCH 10/17] fix key_dao --- client/base_client.go | 4 ++-- go.mod | 2 +- go.sum | 8 -------- types/client.go | 2 +- types/factory.go | 20 ++++++++------------ 5 files changed, 12 insertions(+), 24 deletions(-) diff --git a/client/base_client.go b/client/base_client.go index f90763e..79da810 100644 --- a/client/base_client.go +++ b/client/base_client.go @@ -284,13 +284,13 @@ func (base *baseClient) SendBatch(msgs sdktypes.Msgs, baseTx sdktypes.BaseTx) (r return rs, nil } -func (base *baseClient) BuildTx(addr string, sequence, accountNumber uint64, msg []sdktypes.Msg, baseTx sdktypes.BaseTx) ([]byte, sdktypes.Error) { +func (base *baseClient) BuildTx(addr string, pubkey []byte, algo string, sequence, accountNumber uint64, msg []sdktypes.Msg, baseTx sdktypes.BaseTx) ([]byte, sdktypes.Error) { builder, err := base.prepareWithAccount(addr, sequence, accountNumber, baseTx) if err != nil { return nil, sdktypes.Wrap(err) } - unsignedTxBytes, err := builder.BuildTx(baseTx.From, msg) + unsignedTxBytes, err := builder.BuildTxWithoutKeyDao(pubkey, algo, msg) if err != nil { return nil, sdktypes.Wrap(err) } diff --git a/go.mod b/go.mod index 6cf1d3a..38aa178 100644 --- a/go.mod +++ b/go.mod @@ -13,7 +13,6 @@ require ( github.com/btcsuite/btcutil v1.0.3-0.20201208143702-a53e38424cce github.com/cosmos/cosmos-sdk v0.44.3 github.com/cosmos/go-bip39 v1.0.0 - github.com/cosmos/gogoproto v1.4.6 github.com/dvsekhvalnov/jose2go v0.0.0-20201001154944-b09cfaf05951 github.com/ethereum/go-ethereum v1.10.16 github.com/gogo/protobuf v1.3.3 @@ -43,6 +42,7 @@ require ( github.com/tklauser/go-sysconf v0.3.7 // indirect go.etcd.io/bbolt v1.3.6 // indirect golang.org/x/crypto v0.1.0 + golang.org/x/net v0.6.0 // indirect google.golang.org/genproto v0.0.0-20230110181048-76db0878b65f google.golang.org/grpc v1.53.0 google.golang.org/protobuf v1.28.1 diff --git a/go.sum b/go.sum index 98862ac..0c69339 100644 --- a/go.sum +++ b/go.sum @@ -565,8 +565,6 @@ github.com/cosmos/cosmos-sdk v0.44.3/go.mod h1:bA3+VenaR/l/vDiYzaiwbWvRPWHMBX2jG github.com/cosmos/go-bip39 v0.0.0-20180819234021-555e2067c45d/go.mod h1:tSxLoYXyBmiFeKpvmq4dzayMdCjCnu8uqmCysIGBT2Y= github.com/cosmos/go-bip39 v1.0.0 h1:pcomnQdrdH22njcAatO0yWojsUnCO3y2tNoV1cb6hHY= github.com/cosmos/go-bip39 v1.0.0/go.mod h1:RNJv0H/pOIVgxw6KS7QeX2a0Uo0aKUlfhZ4xuwvCdJw= -github.com/cosmos/gogoproto v1.4.6 h1:Ee7z15dWJaGlgM2rWrK8N2IX7PQcuccu8oG68jp5RL4= -github.com/cosmos/gogoproto v1.4.6/go.mod h1:VS/ASYmPgv6zkPKLjR9EB91lwbLHOzaGCirmKKhncfI= github.com/cosmos/iavl v0.15.0-rc5/go.mod h1:WqoPL9yPTQ85QBMT45OOUzPxG/U/JcJoN7uMjgxke/I= github.com/cosmos/iavl v0.17.1 h1:b/Cl8h1PRMvsu24+TYNlKchIu7W6tmxIBGe6E9u2Ybw= github.com/cosmos/iavl v0.17.1/go.mod h1:7aisPZK8yCpQdy3PMvKeO+bhq1NwDjUwjzxwwROUxFk= @@ -1439,8 +1437,6 @@ golang.org/x/exp v0.0.0-20200119233911-0405dc783f0a/go.mod h1:2RIsYlXP63K8oxa1u0 golang.org/x/exp v0.0.0-20200207192155-f17229e696bd/go.mod h1:J/WKrq2StrnmMY6+EHIKF9dgMWnmCNThgcyBT1FY9mM= golang.org/x/exp v0.0.0-20200224162631-6cc2880d07d6/go.mod h1:3jZMyOhIsHpP37uCMkUooju7aAi5cS1Q23tOzKc+0MU= golang.org/x/exp v0.0.0-20200331195152-e8c3332aa8e5/go.mod h1:4M0jN8W1tt0AVLNr8HDosyJCDCDuyL9N9+3m7wDWgKw= -golang.org/x/exp v0.0.0-20230131160201-f062dba9d201 h1:BEABXpNXLEz0WxtA+6CQIz2xkg80e+1zrhWyMcq8VzE= -golang.org/x/exp v0.0.0-20230131160201-f062dba9d201/go.mod h1:CxIveKay+FTh1D0yPZemJVgC/95VzuuOLq5Qi4xnoYc= golang.org/x/image v0.0.0-20180708004352-c73c2afc3b81/go.mod h1:ux5Hcp/YLpHSI86hEcLt0YII63i6oz57MZXIpbrjZUs= golang.org/x/image v0.0.0-20190227222117-0694c2d4d067/go.mod h1:kZ7UVZpmo3dzQBMxlp+ypCbDeSB+sBbTgSJuh5dn5js= golang.org/x/image v0.0.0-20190802002840-cff245a6509b/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0= @@ -1471,9 +1467,7 @@ golang.org/x/mod v0.4.1/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= golang.org/x/mod v0.5.0/go.mod h1:5OXOZSfqPIIbmVBIIKWRFfZjPR0E5r58TLhUjH0a2Ro= golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4= -golang.org/x/mod v0.6.0/go.mod h1:4mET923SAdbXp2ki8ey+zGs1SLqsuM2Y0uvdZR/fUNI= golang.org/x/mod v0.7.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs= -golang.org/x/mod v0.8.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs= golang.org/x/net v0.0.0-20180719180050-a680a1efc54d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= 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= @@ -1804,9 +1798,7 @@ golang.org/x/tools v0.1.3/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk= golang.org/x/tools v0.1.4/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk= golang.org/x/tools v0.1.5/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk= golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc= -golang.org/x/tools v0.2.0/go.mod h1:y4OqIKeOV/fWJetJ8bXPU1sEVniLMIyDAZWeHdV+NTA= golang.org/x/tools v0.3.0/go.mod h1:/rWhSS2+zyEVwoJf8YAX6L2f0ntZ7Kn/mGgAWcipA5k= -golang.org/x/tools v0.6.0/go.mod h1:Xwgl3UAJ/d3gWutnCtw505GrjyAbvKui8lOU390QaIU= 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= diff --git a/types/client.go b/types/client.go index 4ae02f4..13d680f 100644 --- a/types/client.go +++ b/types/client.go @@ -15,7 +15,7 @@ type TxManager interface { BuildTxHash(msg []Msg, baseTx BaseTx) (string, Error) BuildAndSendWithAccount(addr string, accountNumber, sequence uint64, msg []Msg, baseTx BaseTx) (ResultTx, Error) BuildAndSignWithAccount(addr string, accountNumber, sequence uint64, msg []Msg, baseTx BaseTx) ([]byte, Error) - BuildTx(addr string, sequence, accountNumber uint64, msg []Msg, baseTx BaseTx) ([]byte, Error) + BuildTx(addr string, pubkey []byte, algo string, sequence, accountNumber uint64, msg []Msg, baseTx BaseTx) ([]byte, Error) SetTxSignature(addr string, sequence, accountNumber uint64, msg []Msg, baseTx BaseTx, signedData []byte) ([]byte, Error) } diff --git a/types/factory.go b/types/factory.go index adefb05..8970a7f 100644 --- a/types/factory.go +++ b/types/factory.go @@ -4,6 +4,8 @@ import ( "errors" "fmt" "github.com/ethereum/go-ethereum/crypto" + keys "github.com/irisnet/core-sdk-go/client" + cryptoamino "github.com/irisnet/core-sdk-go/common/crypto/codec" "github.com/irisnet/core-sdk-go/types/tx/signing" ) @@ -214,7 +216,7 @@ func (f *Factory) BuildAndSign(name string, msgs []Msg, json bool) ([]byte, erro return txBytes, nil } -func (f *Factory) BuildTx(name string, msgs []Msg) ([]byte, error) { +func (f *Factory) BuildTxWithoutKeyDao(pubkey []byte, algo string, msgs []Msg) ([]byte, error) { tx, err := f.BuildUnsignedTx(msgs) if err != nil { return []byte{}, err @@ -231,25 +233,19 @@ func (f *Factory) BuildTx(name string, msgs []Msg) ([]byte, error) { Sequence: f.sequence, } - pubkey, _, err := f.keyManager.Find(name, f.password) + pubKey, err := cryptoamino.PubKeyFromBytes(pubkey) if err != nil { - return []byte{}, err + return nil, nil } - // For SIGN_MODE_DIRECT, calling SetSignatures calls setSignerInfos on - // Factory under the hood, and SignerInfos is needed to generated the - // sign bytes. This is the reason for setting SetSignatures here, with a - // nil signature. - // - // Note: this line is not needed for SIGN_MODE_LEGACY_AMINO, but putting it - // also doesn't affect its generated sign bytes, so for code's simplicity - // sake, we put it here. + publicKey := keys.FromTmPubKey(algo, pubKey) + sigData := signing.SingleSignatureData{ SignMode: signMode, Signature: nil, } sig := signing.SignatureV2{ - PubKey: pubkey, + PubKey: publicKey, Data: &sigData, Sequence: f.Sequence(), } From de5fc874a91a2f9a9fec0c1bcaf153ca6f953389 Mon Sep 17 00:00:00 2001 From: sxj Date: Mon, 22 May 2023 13:46:24 +0800 Subject: [PATCH 11/17] fix buildtxwithoutkeydao --- types/factory.go | 19 +++++++++++++++++-- 1 file changed, 17 insertions(+), 2 deletions(-) diff --git a/types/factory.go b/types/factory.go index 8970a7f..81966ea 100644 --- a/types/factory.go +++ b/types/factory.go @@ -4,9 +4,12 @@ import ( "errors" "fmt" "github.com/ethereum/go-ethereum/crypto" - keys "github.com/irisnet/core-sdk-go/client" cryptoamino "github.com/irisnet/core-sdk-go/common/crypto/codec" + "github.com/irisnet/core-sdk-go/common/crypto/keys/secp256k1" + "github.com/irisnet/core-sdk-go/common/crypto/keys/sm2" + commoncryptotypes "github.com/irisnet/core-sdk-go/common/crypto/types" "github.com/irisnet/core-sdk-go/types/tx/signing" + tmcrypto "github.com/tendermint/tendermint/crypto" ) // Factory defines a client transaction factory that facilitates generating and @@ -238,7 +241,7 @@ func (f *Factory) BuildTxWithoutKeyDao(pubkey []byte, algo string, msgs []Msg) ( return nil, nil } - publicKey := keys.FromTmPubKey(algo, pubKey) + publicKey := FromTmPubKey(algo, pubKey) sigData := signing.SingleSignatureData{ SignMode: signMode, @@ -408,3 +411,15 @@ func (f *Factory) Sign(name string, txBuilder TxBuilder) error { // And here the tx is populated with the signature return txBuilder.SetSignatures(sig) } + +func FromTmPubKey(Algo string, pubKey tmcrypto.PubKey) commoncryptotypes.PubKey { + var pubkey commoncryptotypes.PubKey + pubkeyBytes := pubKey.Bytes() + switch Algo { + case "sm2": + pubkey = &sm2.PubKey{Key: pubkeyBytes} + case "secp256k1": + pubkey = &secp256k1.PubKey{Key: pubkeyBytes} + } + return pubkey +} From 79648fd2aed1681ee91476ecad9dedd0e600d1d0 Mon Sep 17 00:00:00 2001 From: sxj Date: Mon, 22 May 2023 17:23:10 +0800 Subject: [PATCH 12/17] fix buildtxwithoutkeydao --- types/factory.go | 3 +++ 1 file changed, 3 insertions(+) diff --git a/types/factory.go b/types/factory.go index 81966ea..621d3cd 100644 --- a/types/factory.go +++ b/types/factory.go @@ -5,6 +5,7 @@ import ( "fmt" "github.com/ethereum/go-ethereum/crypto" cryptoamino "github.com/irisnet/core-sdk-go/common/crypto/codec" + ethsecp256k1 "github.com/irisnet/core-sdk-go/common/crypto/keys/eth_secp256k1" "github.com/irisnet/core-sdk-go/common/crypto/keys/secp256k1" "github.com/irisnet/core-sdk-go/common/crypto/keys/sm2" commoncryptotypes "github.com/irisnet/core-sdk-go/common/crypto/types" @@ -420,6 +421,8 @@ func FromTmPubKey(Algo string, pubKey tmcrypto.PubKey) commoncryptotypes.PubKey pubkey = &sm2.PubKey{Key: pubkeyBytes} case "secp256k1": pubkey = &secp256k1.PubKey{Key: pubkeyBytes} + case "eth_secp256k1": + pubkey = ðsecp256k1.PubKey{Key: pubkeyBytes} } return pubkey } From 338823e70efadec921fa78b211aae054b74bc9c3 Mon Sep 17 00:00:00 2001 From: sxj Date: Mon, 22 May 2023 17:28:53 +0800 Subject: [PATCH 13/17] fix buildtxwithoutkeydao --- client/base_client.go | 4 ++-- types/client.go | 2 +- types/factory.go | 10 ++++++---- 3 files changed, 9 insertions(+), 7 deletions(-) diff --git a/client/base_client.go b/client/base_client.go index 79da810..0c4afe2 100644 --- a/client/base_client.go +++ b/client/base_client.go @@ -299,13 +299,13 @@ func (base *baseClient) BuildTx(addr string, pubkey []byte, algo string, sequenc return unsignedTxBytes, nil } -func (base *baseClient) SetTxSignature(addr string, sequence, accountNumber uint64, msg []sdktypes.Msg, baseTx sdktypes.BaseTx, signedData []byte) ([]byte, sdktypes.Error) { +func (base *baseClient) SetTxSignature(addr string, pubkey []byte, algo string, sequence, accountNumber uint64, msg []sdktypes.Msg, baseTx sdktypes.BaseTx, signedData []byte) ([]byte, sdktypes.Error) { builder, err := base.prepareWithAccount(addr, sequence, accountNumber, baseTx) if err != nil { return nil, sdktypes.Wrap(err) } - txByte, err := builder.SetUnsignedTxSignature(baseTx.From, msg, signedData) + txByte, err := builder.SetUnsignedTxSignature(pubkey, algo, msg, signedData) if err != nil { return nil, sdktypes.Wrap(err) } diff --git a/types/client.go b/types/client.go index 13d680f..fdb97d2 100644 --- a/types/client.go +++ b/types/client.go @@ -16,7 +16,7 @@ type TxManager interface { BuildAndSendWithAccount(addr string, accountNumber, sequence uint64, msg []Msg, baseTx BaseTx) (ResultTx, Error) BuildAndSignWithAccount(addr string, accountNumber, sequence uint64, msg []Msg, baseTx BaseTx) ([]byte, Error) BuildTx(addr string, pubkey []byte, algo string, sequence, accountNumber uint64, msg []Msg, baseTx BaseTx) ([]byte, Error) - SetTxSignature(addr string, sequence, accountNumber uint64, msg []Msg, baseTx BaseTx, signedData []byte) ([]byte, Error) + SetTxSignature(addr string, pubkey []byte, algo string, sequence, accountNumber uint64, msg []Msg, baseTx BaseTx, signedData []byte) ([]byte, Error) } type Queries interface { diff --git a/types/factory.go b/types/factory.go index 621d3cd..763dbc2 100644 --- a/types/factory.go +++ b/types/factory.go @@ -266,7 +266,7 @@ func (f *Factory) BuildTxWithoutKeyDao(pubkey []byte, algo string, msgs []Msg) ( return crypto.Keccak256Hash(signBytes).Bytes(), nil } -func (f *Factory) SetUnsignedTxSignature(name string, msgs []Msg, signedData []byte) ([]byte, error) { +func (f *Factory) SetUnsignedTxSignature(pubkey []byte, algo string, msgs []Msg, signedData []byte) ([]byte, error) { tx, err := f.BuildUnsignedTx(msgs) if err != nil { return []byte{}, err @@ -278,18 +278,20 @@ func (f *Factory) SetUnsignedTxSignature(name string, msgs []Msg, signedData []b signMode = f.txConfig.SignModeHandler().DefaultMode() } - pubkey, _, err := f.keyManager.Find(name, f.password) + pubKey, err := cryptoamino.PubKeyFromBytes(pubkey) if err != nil { - return []byte{}, err + return nil, nil } + publicKey := FromTmPubKey(algo, pubKey) + // Construct the SignatureV2 struct sigData := signing.SingleSignatureData{ SignMode: signMode, Signature: signedData, } sig := signing.SignatureV2{ - PubKey: pubkey, + PubKey: publicKey, Data: &sigData, Sequence: f.Sequence(), } From 68bd86b68f2ee2d3ac4585dbebcc717cd3be0eeb Mon Sep 17 00:00:00 2001 From: sxj Date: Tue, 23 May 2023 15:04:06 +0800 Subject: [PATCH 14/17] stash --- client/base_client.go | 4 ++-- types/factory.go | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/client/base_client.go b/client/base_client.go index 0c4afe2..92a0137 100644 --- a/client/base_client.go +++ b/client/base_client.go @@ -285,7 +285,7 @@ func (base *baseClient) SendBatch(msgs sdktypes.Msgs, baseTx sdktypes.BaseTx) (r } func (base *baseClient) BuildTx(addr string, pubkey []byte, algo string, sequence, accountNumber uint64, msg []sdktypes.Msg, baseTx sdktypes.BaseTx) ([]byte, sdktypes.Error) { - builder, err := base.prepareWithAccount(addr, sequence, accountNumber, baseTx) + builder, err := base.prepareWithAccount(addr, accountNumber, sequence, baseTx) if err != nil { return nil, sdktypes.Wrap(err) } @@ -300,7 +300,7 @@ func (base *baseClient) BuildTx(addr string, pubkey []byte, algo string, sequenc } func (base *baseClient) SetTxSignature(addr string, pubkey []byte, algo string, sequence, accountNumber uint64, msg []sdktypes.Msg, baseTx sdktypes.BaseTx, signedData []byte) ([]byte, sdktypes.Error) { - builder, err := base.prepareWithAccount(addr, sequence, accountNumber, baseTx) + builder, err := base.prepareWithAccount(addr, accountNumber, sequence, baseTx) if err != nil { return nil, sdktypes.Wrap(err) } diff --git a/types/factory.go b/types/factory.go index 763dbc2..69fa1b6 100644 --- a/types/factory.go +++ b/types/factory.go @@ -239,7 +239,7 @@ func (f *Factory) BuildTxWithoutKeyDao(pubkey []byte, algo string, msgs []Msg) ( pubKey, err := cryptoamino.PubKeyFromBytes(pubkey) if err != nil { - return nil, nil + return []byte{}, err } publicKey := FromTmPubKey(algo, pubKey) @@ -280,7 +280,7 @@ func (f *Factory) SetUnsignedTxSignature(pubkey []byte, algo string, msgs []Msg, pubKey, err := cryptoamino.PubKeyFromBytes(pubkey) if err != nil { - return nil, nil + return []byte{}, err } publicKey := FromTmPubKey(algo, pubKey) From 041b7fff6ae37f2066c6933b7909d0f56a81ae89 Mon Sep 17 00:00:00 2001 From: sxj Date: Tue, 23 May 2023 16:56:33 +0800 Subject: [PATCH 15/17] fix buildtxwithoutkeydao --- go.mod | 5 - go.sum | 713 +++++++++++++++++++++++++++++++++++++++++++++-- types/factory.go | 9 +- 3 files changed, 693 insertions(+), 34 deletions(-) diff --git a/go.mod b/go.mod index 4607363..a95d1c7 100644 --- a/go.mod +++ b/go.mod @@ -26,7 +26,6 @@ require ( github.com/rcrowley/go-metrics v0.0.0-20201227073835-cf1acfcdf475 github.com/regen-network/cosmos-proto v0.3.1 github.com/sirupsen/logrus v1.7.0 - github.com/stretchr/testify v1.7.0 github.com/spf13/viper v1.9.0 // indirect github.com/stretchr/testify v1.8.1 github.com/tendermint/crypto v0.0.0-20191022145703-50d29ede1e15 @@ -34,10 +33,6 @@ require ( github.com/tendermint/tendermint v0.34.14 github.com/tendermint/tm-db v0.6.4 github.com/tjfoc/gmsm v1.4.0 - golang.org/x/crypto v0.0.0-20211115234514-b4de73f9ece8 - google.golang.org/genproto v0.0.0-20211116182654-e63d96a377c4 - google.golang.org/grpc v1.41.0 - google.golang.org/protobuf v1.27.1 github.com/tklauser/go-sysconf v0.3.7 // indirect go.etcd.io/bbolt v1.3.6 // indirect golang.org/x/crypto v0.1.0 diff --git a/go.sum b/go.sum index 49be24e..e53722f 100644 --- a/go.sum +++ b/go.sum @@ -4,6 +4,7 @@ cloud.google.com/go v0.38.0/go.mod h1:990N+gfupTy94rShfmMCWGDn0LpTmnzTp2qbd1dvSR cloud.google.com/go v0.43.0/go.mod h1:BOSR3VbTLkk6FDC/TcffxP4NF/FFBGA5ku+jvKOP7pg= cloud.google.com/go v0.44.1/go.mod h1:iSa0KzasP4Uvy3f1mN/7PiObzGgflwredwwASm/v6AU= cloud.google.com/go v0.44.2/go.mod h1:60680Gw3Yr4ikxnPRS/oxxkBccT6SA1yMk63TGekxKY= +cloud.google.com/go v0.44.3/go.mod h1:60680Gw3Yr4ikxnPRS/oxxkBccT6SA1yMk63TGekxKY= cloud.google.com/go v0.45.1/go.mod h1:RpBamKRgapWJb87xiFSdk4g1CME7QZg3uwTez+TSTjc= cloud.google.com/go v0.46.3/go.mod h1:a6bKKbmY7er1mI7TEI4lsAkts/mkhTSZK8w33B4RAg0= cloud.google.com/go v0.50.0/go.mod h1:r9sluTvynVuxRIOHXQEHMFffphuXHOMZMycpNR5e6To= @@ -17,28 +18,377 @@ cloud.google.com/go v0.62.0/go.mod h1:jmCYTdRCQuc1PHIIJ/maLInMho30T/Y0M4hTdTShOY cloud.google.com/go v0.65.0/go.mod h1:O5N8zS7uWy9vkA9vayVHs65eM1ubvY4h553ofrNHObY= cloud.google.com/go v0.72.0/go.mod h1:M+5Vjvlc2wnp6tjzE102Dw08nGShTscUx2nZMufOKPI= cloud.google.com/go v0.74.0/go.mod h1:VV1xSbzvo+9QJOxLDaJfTjx5e+MePCpCWwvftOeQmWk= +cloud.google.com/go v0.75.0/go.mod h1:VGuuCn7PG0dwsd5XPVm2Mm3wlh3EL55/79EKB6hlPTY= cloud.google.com/go v0.78.0/go.mod h1:QjdrLG0uq+YwhjoVOLsS1t7TW8fs36kLs4XO5R5ECHg= cloud.google.com/go v0.79.0/go.mod h1:3bzgcEeQlzbuEAYu4mrWhKqWjmpprinYgKJLgKHnbb8= cloud.google.com/go v0.81.0/go.mod h1:mk/AM35KwGk/Nm2YSeZbxXdrNK3KZOYHmLkOqC2V6E0= +cloud.google.com/go v0.83.0/go.mod h1:Z7MJUsANfY0pYPdw0lbnivPx4/vhy/e2FEkSkF7vAVY= +cloud.google.com/go v0.84.0/go.mod h1:RazrYuxIK6Kb7YrzzhPoLmCVzl7Sup4NrbKPg8KHSUM= +cloud.google.com/go v0.87.0/go.mod h1:TpDYlFy7vuLzZMMZ+B6iRiELaY7z/gJPaqbMx6mlWcY= +cloud.google.com/go v0.90.0/go.mod h1:kRX0mNRHe0e2rC6oNakvwQqzyDmg57xJ+SZU1eT2aDQ= +cloud.google.com/go v0.93.3/go.mod h1:8utlLll2EF5XMAV15woO4lSbWQlk8rer9aLOfLh7+YI= +cloud.google.com/go v0.94.1/go.mod h1:qAlAugsXlC+JWO+Bke5vCtc9ONxjQT3drlTTnAplMW4= +cloud.google.com/go v0.97.0/go.mod h1:GF7l59pYBVlXQIBLx3a761cZ41F9bBH3JUlihCt2Udc= +cloud.google.com/go v0.99.0/go.mod h1:w0Xx2nLzqWJPuozYQX+hFfCSI8WioryfRDzkoI/Y2ZA= +cloud.google.com/go v0.100.1/go.mod h1:fs4QogzfH5n2pBXBP9vRiU+eCny7lD2vmFZy79Iuw1U= +cloud.google.com/go v0.100.2/go.mod h1:4Xra9TjzAeYHrl5+oeLlzbM2k3mjVhZh4UqTZ//w99A= +cloud.google.com/go v0.102.0/go.mod h1:oWcCzKlqJ5zgHQt9YsaeTY9KzIvjyy0ArmiBUgpQ+nc= +cloud.google.com/go v0.102.1/go.mod h1:XZ77E9qnTEnrgEOvr4xzfdX5TRo7fB4T2F4O6+34hIU= +cloud.google.com/go v0.104.0/go.mod h1:OO6xxXdJyvuJPcEPBLN9BJPD+jep5G1+2U5B5gkRYtA= +cloud.google.com/go v0.105.0/go.mod h1:PrLgOJNe5nfE9UMxKxgXj4mD3voiP+YQ6gdt6KMFOKM= +cloud.google.com/go v0.107.0/go.mod h1:wpc2eNrD7hXUTy8EKS10jkxpZBjASrORK7goS+3YX2I= +cloud.google.com/go/accessapproval v1.4.0/go.mod h1:zybIuC3KpDOvotz59lFe5qxRZx6C75OtwbisN56xYB4= +cloud.google.com/go/accessapproval v1.5.0/go.mod h1:HFy3tuiGvMdcd/u+Cu5b9NkO1pEICJ46IR82PoUdplw= +cloud.google.com/go/accesscontextmanager v1.3.0/go.mod h1:TgCBehyr5gNMz7ZaH9xubp+CE8dkrszb4oK9CWyvD4o= +cloud.google.com/go/accesscontextmanager v1.4.0/go.mod h1:/Kjh7BBu/Gh83sv+K60vN9QE5NJcd80sU33vIe2IFPE= +cloud.google.com/go/aiplatform v1.22.0/go.mod h1:ig5Nct50bZlzV6NvKaTwmplLLddFx0YReh9WfTO5jKw= +cloud.google.com/go/aiplatform v1.24.0/go.mod h1:67UUvRBKG6GTayHKV8DBv2RtR1t93YRu5B1P3x99mYY= +cloud.google.com/go/aiplatform v1.27.0/go.mod h1:Bvxqtl40l0WImSb04d0hXFU7gDOiq9jQmorivIiWcKg= +cloud.google.com/go/analytics v0.11.0/go.mod h1:DjEWCu41bVbYcKyvlws9Er60YE4a//bK6mnhWvQeFNI= +cloud.google.com/go/analytics v0.12.0/go.mod h1:gkfj9h6XRf9+TS4bmuhPEShsh3hH8PAZzm/41OOhQd4= +cloud.google.com/go/apigateway v1.3.0/go.mod h1:89Z8Bhpmxu6AmUxuVRg/ECRGReEdiP3vQtk4Z1J9rJk= +cloud.google.com/go/apigateway v1.4.0/go.mod h1:pHVY9MKGaH9PQ3pJ4YLzoj6U5FUDeDFBllIz7WmzJoc= +cloud.google.com/go/apigeeconnect v1.3.0/go.mod h1:G/AwXFAKo0gIXkPTVfZDd2qA1TxBXJ3MgMRBQkIi9jc= +cloud.google.com/go/apigeeconnect v1.4.0/go.mod h1:kV4NwOKqjvt2JYR0AoIWo2QGfoRtn/pkS3QlHp0Ni04= +cloud.google.com/go/appengine v1.4.0/go.mod h1:CS2NhuBuDXM9f+qscZ6V86m1MIIqPj3WC/UoEuR1Sno= +cloud.google.com/go/appengine v1.5.0/go.mod h1:TfasSozdkFI0zeoxW3PTBLiNqRmzraodCWatWI9Dmak= +cloud.google.com/go/area120 v0.5.0/go.mod h1:DE/n4mp+iqVyvxHN41Vf1CR602GiHQjFPusMFW6bGR4= +cloud.google.com/go/area120 v0.6.0/go.mod h1:39yFJqWVgm0UZqWTOdqkLhjoC7uFfgXRC8g/ZegeAh0= +cloud.google.com/go/artifactregistry v1.6.0/go.mod h1:IYt0oBPSAGYj/kprzsBjZ/4LnG/zOcHyFHjWPCi6SAQ= +cloud.google.com/go/artifactregistry v1.7.0/go.mod h1:mqTOFOnGZx8EtSqK/ZWcsm/4U8B77rbcLP6ruDU2Ixk= +cloud.google.com/go/artifactregistry v1.8.0/go.mod h1:w3GQXkJX8hiKN0v+at4b0qotwijQbYUqF2GWkZzAhC0= +cloud.google.com/go/artifactregistry v1.9.0/go.mod h1:2K2RqvA2CYvAeARHRkLDhMDJ3OXy26h3XW+3/Jh2uYc= +cloud.google.com/go/asset v1.5.0/go.mod h1:5mfs8UvcM5wHhqtSv8J1CtxxaQq3AdBxxQi2jGW/K4o= +cloud.google.com/go/asset v1.7.0/go.mod h1:YbENsRK4+xTiL+Ofoj5Ckf+O17kJtgp3Y3nn4uzZz5s= +cloud.google.com/go/asset v1.8.0/go.mod h1:mUNGKhiqIdbr8X7KNayoYvyc4HbbFO9URsjbytpUaW0= +cloud.google.com/go/asset v1.9.0/go.mod h1:83MOE6jEJBMqFKadM9NLRcs80Gdw76qGuHn8m3h8oHQ= +cloud.google.com/go/asset v1.10.0/go.mod h1:pLz7uokL80qKhzKr4xXGvBQXnzHn5evJAEAtZiIb0wY= +cloud.google.com/go/assuredworkloads v1.5.0/go.mod h1:n8HOZ6pff6re5KYfBXcFvSViQjDwxFkAkmUFffJRbbY= +cloud.google.com/go/assuredworkloads v1.6.0/go.mod h1:yo2YOk37Yc89Rsd5QMVECvjaMKymF9OP+QXWlKXUkXw= +cloud.google.com/go/assuredworkloads v1.7.0/go.mod h1:z/736/oNmtGAyU47reJgGN+KVoYoxeLBoj4XkKYscNI= +cloud.google.com/go/assuredworkloads v1.8.0/go.mod h1:AsX2cqyNCOvEQC8RMPnoc0yEarXQk6WEKkxYfL6kGIo= +cloud.google.com/go/assuredworkloads v1.9.0/go.mod h1:kFuI1P78bplYtT77Tb1hi0FMxM0vVpRC7VVoJC3ZoT0= +cloud.google.com/go/automl v1.5.0/go.mod h1:34EjfoFGMZ5sgJ9EoLsRtdPSNZLcfflJR39VbVNS2M0= +cloud.google.com/go/automl v1.6.0/go.mod h1:ugf8a6Fx+zP0D59WLhqgTDsQI9w07o64uf/Is3Nh5p8= +cloud.google.com/go/automl v1.7.0/go.mod h1:RL9MYCCsJEOmt0Wf3z9uzG0a7adTT1fe+aObgSpkCt8= +cloud.google.com/go/automl v1.8.0/go.mod h1:xWx7G/aPEe/NP+qzYXktoBSDfjO+vnKMGgsApGJJquM= +cloud.google.com/go/baremetalsolution v0.3.0/go.mod h1:XOrocE+pvK1xFfleEnShBlNAXf+j5blPPxrhjKgnIFc= +cloud.google.com/go/baremetalsolution v0.4.0/go.mod h1:BymplhAadOO/eBa7KewQ0Ppg4A4Wplbn+PsFKRLo0uI= +cloud.google.com/go/batch v0.3.0/go.mod h1:TR18ZoAekj1GuirsUsR1ZTKN3FC/4UDnScjT8NXImFE= +cloud.google.com/go/batch v0.4.0/go.mod h1:WZkHnP43R/QCGQsZ+0JyG4i79ranE2u8xvjq/9+STPE= +cloud.google.com/go/beyondcorp v0.2.0/go.mod h1:TB7Bd+EEtcw9PCPQhCJtJGjk/7TC6ckmnSFS+xwTfm4= +cloud.google.com/go/beyondcorp v0.3.0/go.mod h1:E5U5lcrcXMsCuoDNyGrpyTm/hn7ne941Jz2vmksAxW8= cloud.google.com/go/bigquery v1.0.1/go.mod h1:i/xbL2UlR5RvWAURpBYZTtm/cXjCha9lbfbpx4poX+o= cloud.google.com/go/bigquery v1.3.0/go.mod h1:PjpwJnslEMmckchkHFfq+HTD2DmtT67aNFKH1/VBDHE= cloud.google.com/go/bigquery v1.4.0/go.mod h1:S8dzgnTigyfTmLBfrtrhyYhwRxG72rYxvftPBK2Dvzc= cloud.google.com/go/bigquery v1.5.0/go.mod h1:snEHRnqQbz117VIFhE8bmtwIDY80NLUZUMb4Nv6dBIg= cloud.google.com/go/bigquery v1.7.0/go.mod h1://okPTzCYNXSlb24MZs83e2Do+h+VXtc4gLoIoXIAPc= cloud.google.com/go/bigquery v1.8.0/go.mod h1:J5hqkt3O0uAFnINi6JXValWIb1v0goeZM77hZzJN/fQ= +cloud.google.com/go/bigquery v1.42.0/go.mod h1:8dRTJxhtG+vwBKzE5OseQn/hiydoQN3EedCaOdYmxRA= +cloud.google.com/go/bigquery v1.43.0/go.mod h1:ZMQcXHsl+xmU1z36G2jNGZmKp9zNY5BUua5wDgmNCfw= +cloud.google.com/go/bigquery v1.44.0/go.mod h1:0Y33VqXTEsbamHJvJHdFmtqHvMIY28aK1+dFsvaChGc= cloud.google.com/go/bigtable v1.2.0/go.mod h1:JcVAOl45lrTmQfLj7T6TxyMzIN/3FGGcFm+2xVAli2o= +cloud.google.com/go/billing v1.4.0/go.mod h1:g9IdKBEFlItS8bTtlrZdVLWSSdSyFUZKXNS02zKMOZY= +cloud.google.com/go/billing v1.5.0/go.mod h1:mztb1tBc3QekhjSgmpf/CV4LzWXLzCArwpLmP2Gm88s= +cloud.google.com/go/billing v1.6.0/go.mod h1:WoXzguj+BeHXPbKfNWkqVtDdzORazmCjraY+vrxcyvI= +cloud.google.com/go/billing v1.7.0/go.mod h1:q457N3Hbj9lYwwRbnlD7vUpyjq6u5U1RAOArInEiD5Y= +cloud.google.com/go/binaryauthorization v1.1.0/go.mod h1:xwnoWu3Y84jbuHa0zd526MJYmtnVXn0syOjaJgy4+dM= +cloud.google.com/go/binaryauthorization v1.2.0/go.mod h1:86WKkJHtRcv5ViNABtYMhhNWRrD1Vpi//uKEy7aYEfI= +cloud.google.com/go/binaryauthorization v1.3.0/go.mod h1:lRZbKgjDIIQvzYQS1p99A7/U1JqvqeZg0wiI5tp6tg0= +cloud.google.com/go/binaryauthorization v1.4.0/go.mod h1:tsSPQrBd77VLplV70GUhBf/Zm3FsKmgSqgm4UmiDItk= +cloud.google.com/go/certificatemanager v1.3.0/go.mod h1:n6twGDvcUBFu9uBgt4eYvvf3sQ6My8jADcOVwHmzadg= +cloud.google.com/go/certificatemanager v1.4.0/go.mod h1:vowpercVFyqs8ABSmrdV+GiFf2H/ch3KyudYQEMM590= +cloud.google.com/go/channel v1.8.0/go.mod h1:W5SwCXDJsq/rg3tn3oG0LOxpAo6IMxNa09ngphpSlnk= +cloud.google.com/go/channel v1.9.0/go.mod h1:jcu05W0my9Vx4mt3/rEHpfxc9eKi9XwsdDL8yBMbKUk= +cloud.google.com/go/cloudbuild v1.3.0/go.mod h1:WequR4ULxlqvMsjDEEEFnOG5ZSRSgWOywXYDb1vPE6U= +cloud.google.com/go/cloudbuild v1.4.0/go.mod h1:5Qwa40LHiOXmz3386FrjrYM93rM/hdRr7b53sySrTqA= +cloud.google.com/go/clouddms v1.3.0/go.mod h1:oK6XsCDdW4Ib3jCCBugx+gVjevp2TMXFtgxvPSee3OM= +cloud.google.com/go/clouddms v1.4.0/go.mod h1:Eh7sUGCC+aKry14O1NRljhjyrr0NFC0G2cjwX0cByRk= +cloud.google.com/go/cloudtasks v1.5.0/go.mod h1:fD92REy1x5woxkKEkLdvavGnPJGEn8Uic9nWuLzqCpY= +cloud.google.com/go/cloudtasks v1.6.0/go.mod h1:C6Io+sxuke9/KNRkbQpihnW93SWDU3uXt92nu85HkYI= +cloud.google.com/go/cloudtasks v1.7.0/go.mod h1:ImsfdYWwlWNJbdgPIIGJWC+gemEGTBK/SunNQQNCAb4= +cloud.google.com/go/cloudtasks v1.8.0/go.mod h1:gQXUIwCSOI4yPVK7DgTVFiiP0ZW/eQkydWzwVMdHxrI= +cloud.google.com/go/compute v0.1.0/go.mod h1:GAesmwr110a34z04OlxYkATPBEfVhkymfTBXtfbBFow= +cloud.google.com/go/compute v1.3.0/go.mod h1:cCZiE1NHEtai4wiufUhW8I8S1JKkAnhnQJWM7YD99wM= +cloud.google.com/go/compute v1.5.0/go.mod h1:9SMHyhJlzhlkJqrPAc839t2BZFTSk6Jdj6mkzQJeu0M= +cloud.google.com/go/compute v1.6.0/go.mod h1:T29tfhtVbq1wvAPo0E3+7vhgmkOYeXjhFvz/FMzPu0s= +cloud.google.com/go/compute v1.6.1/go.mod h1:g85FgpzFvNULZ+S8AYq87axRKuf2Kh7deLqV/jJ3thU= +cloud.google.com/go/compute v1.7.0/go.mod h1:435lt8av5oL9P3fv1OEzSbSUe+ybHXGMPQHHZWZxy9U= +cloud.google.com/go/compute v1.10.0/go.mod h1:ER5CLbMxl90o2jtNbGSbtfOpQKR0t15FOtRsugnLrlU= +cloud.google.com/go/compute v1.12.0/go.mod h1:e8yNOBcBONZU1vJKCvCoDw/4JQsA0dpM4x/6PIIOocU= +cloud.google.com/go/compute v1.12.1/go.mod h1:e8yNOBcBONZU1vJKCvCoDw/4JQsA0dpM4x/6PIIOocU= +cloud.google.com/go/compute v1.13.0/go.mod h1:5aPTS0cUNMIc1CE546K+Th6weJUNQErARyZtRXDJ8GE= +cloud.google.com/go/compute v1.14.0/go.mod h1:YfLtxrj9sU4Yxv+sXzZkyPjEyPBZfXHUvjxega5vAdo= +cloud.google.com/go/compute v1.15.1/go.mod h1:bjjoF/NtFUrkD/urWfdHaKuOPDR5nWIs63rR+SXhcpA= +cloud.google.com/go/compute/metadata v0.1.0/go.mod h1:Z1VN+bulIf6bt4P/C37K4DyZYZEXYonfTBHHFPO/4UU= +cloud.google.com/go/compute/metadata v0.2.0/go.mod h1:zFmK7XCadkQkj6TtorcaGlCW1hT1fIilQDwofLpJ20k= +cloud.google.com/go/compute/metadata v0.2.1/go.mod h1:jgHgmJd2RKBGzXqF5LR2EZMGxBkeanZ9wwa75XHJgOM= +cloud.google.com/go/compute/metadata v0.2.3/go.mod h1:VAV5nSsACxMJvgaAuX6Pk2AawlZn8kiOGuCv6gTkwuA= +cloud.google.com/go/contactcenterinsights v1.3.0/go.mod h1:Eu2oemoePuEFc/xKFPjbTuPSj0fYJcPls9TFlPNnHHY= +cloud.google.com/go/contactcenterinsights v1.4.0/go.mod h1:L2YzkGbPsv+vMQMCADxJoT9YiTTnSEd6fEvCeHTYVck= +cloud.google.com/go/container v1.6.0/go.mod h1:Xazp7GjJSeUYo688S+6J5V+n/t+G5sKBTFkKNudGRxg= +cloud.google.com/go/container v1.7.0/go.mod h1:Dp5AHtmothHGX3DwwIHPgq45Y8KmNsgN3amoYfxVkLo= +cloud.google.com/go/containeranalysis v0.5.1/go.mod h1:1D92jd8gRR/c0fGMlymRgxWD3Qw9C1ff6/T7mLgVL8I= +cloud.google.com/go/containeranalysis v0.6.0/go.mod h1:HEJoiEIu+lEXM+k7+qLCci0h33lX3ZqoYFdmPcoO7s4= +cloud.google.com/go/datacatalog v1.3.0/go.mod h1:g9svFY6tuR+j+hrTw3J2dNcmI0dzmSiyOzm8kpLq0a0= +cloud.google.com/go/datacatalog v1.5.0/go.mod h1:M7GPLNQeLfWqeIm3iuiruhPzkt65+Bx8dAKvScX8jvs= +cloud.google.com/go/datacatalog v1.6.0/go.mod h1:+aEyF8JKg+uXcIdAmmaMUmZ3q1b/lKLtXCmXdnc0lbc= +cloud.google.com/go/datacatalog v1.7.0/go.mod h1:9mEl4AuDYWw81UGc41HonIHH7/sn52H0/tc8f8ZbZIE= +cloud.google.com/go/datacatalog v1.8.0/go.mod h1:KYuoVOv9BM8EYz/4eMFxrr4DUKhGIOXxZoKYF5wdISM= +cloud.google.com/go/dataflow v0.6.0/go.mod h1:9QwV89cGoxjjSR9/r7eFDqqjtvbKxAK2BaYU6PVk9UM= +cloud.google.com/go/dataflow v0.7.0/go.mod h1:PX526vb4ijFMesO1o202EaUmouZKBpjHsTlCtB4parQ= +cloud.google.com/go/dataform v0.3.0/go.mod h1:cj8uNliRlHpa6L3yVhDOBrUXH+BPAO1+KFMQQNSThKo= +cloud.google.com/go/dataform v0.4.0/go.mod h1:fwV6Y4Ty2yIFL89huYlEkwUPtS7YZinZbzzj5S9FzCE= +cloud.google.com/go/dataform v0.5.0/go.mod h1:GFUYRe8IBa2hcomWplodVmUx/iTL0FrsauObOM3Ipr0= +cloud.google.com/go/datafusion v1.4.0/go.mod h1:1Zb6VN+W6ALo85cXnM1IKiPw+yQMKMhB9TsTSRDo/38= +cloud.google.com/go/datafusion v1.5.0/go.mod h1:Kz+l1FGHB0J+4XF2fud96WMmRiq/wj8N9u007vyXZ2w= +cloud.google.com/go/datalabeling v0.5.0/go.mod h1:TGcJ0G2NzcsXSE/97yWjIZO0bXj0KbVlINXMG9ud42I= +cloud.google.com/go/datalabeling v0.6.0/go.mod h1:WqdISuk/+WIGeMkpw/1q7bK/tFEZxsrFJOJdY2bXvTQ= +cloud.google.com/go/dataplex v1.3.0/go.mod h1:hQuRtDg+fCiFgC8j0zV222HvzFQdRd+SVX8gdmFcZzA= +cloud.google.com/go/dataplex v1.4.0/go.mod h1:X51GfLXEMVJ6UN47ESVqvlsRplbLhcsAt0kZCCKsU0A= +cloud.google.com/go/dataproc v1.7.0/go.mod h1:CKAlMjII9H90RXaMpSxQ8EU6dQx6iAYNPcYPOkSbi8s= +cloud.google.com/go/dataproc v1.8.0/go.mod h1:5OW+zNAH0pMpw14JVrPONsxMQYMBqJuzORhIBfBn9uI= +cloud.google.com/go/dataqna v0.5.0/go.mod h1:90Hyk596ft3zUQ8NkFfvICSIfHFh1Bc7C4cK3vbhkeo= +cloud.google.com/go/dataqna v0.6.0/go.mod h1:1lqNpM7rqNLVgWBJyk5NF6Uen2PHym0jtVJonplVsDA= cloud.google.com/go/datastore v1.0.0/go.mod h1:LXYbyblFSglQ5pkeyhO+Qmw7ukd3C+pD7TKLgZqpHYE= cloud.google.com/go/datastore v1.1.0/go.mod h1:umbIZjpQpHh4hmRpGhH4tLFup+FVzqBi1b3c64qFpCk= +cloud.google.com/go/datastore v1.10.0/go.mod h1:PC5UzAmDEkAmkfaknstTYbNpgE49HAgW2J1gcgUfmdM= +cloud.google.com/go/datastream v1.2.0/go.mod h1:i/uTP8/fZwgATHS/XFu0TcNUhuA0twZxxQ3EyCUQMwo= +cloud.google.com/go/datastream v1.3.0/go.mod h1:cqlOX8xlyYF/uxhiKn6Hbv6WjwPPuI9W2M9SAXwaLLQ= +cloud.google.com/go/datastream v1.4.0/go.mod h1:h9dpzScPhDTs5noEMQVWP8Wx8AFBRyS0s8KWPx/9r0g= +cloud.google.com/go/datastream v1.5.0/go.mod h1:6TZMMNPwjUqZHBKPQ1wwXpb0d5VDVPl2/XoS5yi88q4= +cloud.google.com/go/deploy v1.4.0/go.mod h1:5Xghikd4VrmMLNaF6FiRFDlHb59VM59YoDQnOUdsH/c= +cloud.google.com/go/deploy v1.5.0/go.mod h1:ffgdD0B89tToyW/U/D2eL0jN2+IEV/3EMuXHA0l4r+s= +cloud.google.com/go/dialogflow v1.15.0/go.mod h1:HbHDWs33WOGJgn6rfzBW1Kv807BE3O1+xGbn59zZWI4= +cloud.google.com/go/dialogflow v1.16.1/go.mod h1:po6LlzGfK+smoSmTBnbkIZY2w8ffjz/RcGSS+sh1el0= +cloud.google.com/go/dialogflow v1.17.0/go.mod h1:YNP09C/kXA1aZdBgC/VtXX74G/TKn7XVCcVumTflA+8= +cloud.google.com/go/dialogflow v1.18.0/go.mod h1:trO7Zu5YdyEuR+BhSNOqJezyFQ3aUzz0njv7sMx/iek= +cloud.google.com/go/dialogflow v1.19.0/go.mod h1:JVmlG1TwykZDtxtTXujec4tQ+D8SBFMoosgy+6Gn0s0= +cloud.google.com/go/dlp v1.6.0/go.mod h1:9eyB2xIhpU0sVwUixfBubDoRwP+GjeUoxxeueZmqvmM= +cloud.google.com/go/dlp v1.7.0/go.mod h1:68ak9vCiMBjbasxeVD17hVPxDEck+ExiHavX8kiHG+Q= +cloud.google.com/go/documentai v1.7.0/go.mod h1:lJvftZB5NRiFSX4moiye1SMxHx0Bc3x1+p9e/RfXYiU= +cloud.google.com/go/documentai v1.8.0/go.mod h1:xGHNEB7CtsnySCNrCFdCyyMz44RhFEEX2Q7UD0c5IhU= +cloud.google.com/go/documentai v1.9.0/go.mod h1:FS5485S8R00U10GhgBC0aNGrJxBP8ZVpEeJ7PQDZd6k= +cloud.google.com/go/documentai v1.10.0/go.mod h1:vod47hKQIPeCfN2QS/jULIvQTugbmdc0ZvxxfQY1bg4= +cloud.google.com/go/domains v0.6.0/go.mod h1:T9Rz3GasrpYk6mEGHh4rymIhjlnIuB4ofT1wTxDeT4Y= +cloud.google.com/go/domains v0.7.0/go.mod h1:PtZeqS1xjnXuRPKE/88Iru/LdfoRyEHYA9nFQf4UKpg= +cloud.google.com/go/edgecontainer v0.1.0/go.mod h1:WgkZ9tp10bFxqO8BLPqv2LlfmQF1X8lZqwW4r1BTajk= +cloud.google.com/go/edgecontainer v0.2.0/go.mod h1:RTmLijy+lGpQ7BXuTDa4C4ssxyXT34NIuHIgKuP4s5w= +cloud.google.com/go/errorreporting v0.3.0/go.mod h1:xsP2yaAp+OAW4OIm60An2bbLpqIhKXdWR/tawvl7QzU= +cloud.google.com/go/essentialcontacts v1.3.0/go.mod h1:r+OnHa5jfj90qIfZDO/VztSFqbQan7HV75p8sA+mdGI= +cloud.google.com/go/essentialcontacts v1.4.0/go.mod h1:8tRldvHYsmnBCHdFpvU+GL75oWiBKl80BiqlFh9tp+8= +cloud.google.com/go/eventarc v1.7.0/go.mod h1:6ctpF3zTnaQCxUjHUdcfgcA1A2T309+omHZth7gDfmc= +cloud.google.com/go/eventarc v1.8.0/go.mod h1:imbzxkyAU4ubfsaKYdQg04WS1NvncblHEup4kvF+4gw= +cloud.google.com/go/filestore v1.3.0/go.mod h1:+qbvHGvXU1HaKX2nD0WEPo92TP/8AQuCVEBXNY9z0+w= +cloud.google.com/go/filestore v1.4.0/go.mod h1:PaG5oDfo9r224f8OYXURtAsY+Fbyq/bLYoINEK8XQAI= cloud.google.com/go/firestore v1.1.0/go.mod h1:ulACoGHTpvq5r8rxGJ4ddJZBZqakUQqClKRT5SZwBmk= +cloud.google.com/go/firestore v1.6.0/go.mod h1:afJwI0vaXwAG54kI7A//lP/lSPDkQORQuMkv56TxEPU= +cloud.google.com/go/firestore v1.9.0/go.mod h1:HMkjKHNTtRyZNiMzu7YAsLr9K3X2udY2AMwDaMEQiiE= +cloud.google.com/go/functions v1.6.0/go.mod h1:3H1UA3qiIPRWD7PeZKLvHZ9SaQhR26XIJcC0A5GbvAk= +cloud.google.com/go/functions v1.7.0/go.mod h1:+d+QBcWM+RsrgZfV9xo6KfA1GlzJfxcfZcRPEhDDfzg= +cloud.google.com/go/functions v1.8.0/go.mod h1:RTZ4/HsQjIqIYP9a9YPbU+QFoQsAlYgrwOXJWHn1POY= +cloud.google.com/go/functions v1.9.0/go.mod h1:Y+Dz8yGguzO3PpIjhLTbnqV1CWmgQ5UwtlpzoyquQ08= +cloud.google.com/go/gaming v1.5.0/go.mod h1:ol7rGcxP/qHTRQE/RO4bxkXq+Fix0j6D4LFPzYTIrDM= +cloud.google.com/go/gaming v1.6.0/go.mod h1:YMU1GEvA39Qt3zWGyAVA9bpYz/yAhTvaQ1t2sK4KPUA= +cloud.google.com/go/gaming v1.7.0/go.mod h1:LrB8U7MHdGgFG851iHAfqUdLcKBdQ55hzXy9xBJz0+w= +cloud.google.com/go/gaming v1.8.0/go.mod h1:xAqjS8b7jAVW0KFYeRUxngo9My3f33kFmua++Pi+ggM= +cloud.google.com/go/gkebackup v0.2.0/go.mod h1:XKvv/4LfG829/B8B7xRkk8zRrOEbKtEam6yNfuQNH60= +cloud.google.com/go/gkebackup v0.3.0/go.mod h1:n/E671i1aOQvUxT541aTkCwExO/bTer2HDlj4TsBRAo= +cloud.google.com/go/gkeconnect v0.5.0/go.mod h1:c5lsNAg5EwAy7fkqX/+goqFsU1Da/jQFqArp+wGNr/o= +cloud.google.com/go/gkeconnect v0.6.0/go.mod h1:Mln67KyU/sHJEBY8kFZ0xTeyPtzbq9StAVvEULYK16A= +cloud.google.com/go/gkehub v0.9.0/go.mod h1:WYHN6WG8w9bXU0hqNxt8rm5uxnk8IH+lPY9J2TV7BK0= +cloud.google.com/go/gkehub v0.10.0/go.mod h1:UIPwxI0DsrpsVoWpLB0stwKCP+WFVG9+y977wO+hBH0= +cloud.google.com/go/gkemulticloud v0.3.0/go.mod h1:7orzy7O0S+5kq95e4Hpn7RysVA7dPs8W/GgfUtsPbrA= +cloud.google.com/go/gkemulticloud v0.4.0/go.mod h1:E9gxVBnseLWCk24ch+P9+B2CoDFJZTyIgLKSalC7tuI= +cloud.google.com/go/grafeas v0.2.0/go.mod h1:KhxgtF2hb0P191HlY5besjYm6MqTSTj3LSI+M+ByZHc= +cloud.google.com/go/gsuiteaddons v1.3.0/go.mod h1:EUNK/J1lZEZO8yPtykKxLXI6JSVN2rg9bN8SXOa0bgM= +cloud.google.com/go/gsuiteaddons v1.4.0/go.mod h1:rZK5I8hht7u7HxFQcFei0+AtfS9uSushomRlg+3ua1o= +cloud.google.com/go/iam v0.1.0/go.mod h1:vcUNEa0pEm0qRVpmWepWaFMIAI8/hjB9mO8rNCJtF6c= +cloud.google.com/go/iam v0.3.0/go.mod h1:XzJPvDayI+9zsASAFO68Hk07u3z+f+JrT2xXNdp4bnY= +cloud.google.com/go/iam v0.5.0/go.mod h1:wPU9Vt0P4UmCux7mqtRu6jcpPAb74cP1fh50J3QpkUc= +cloud.google.com/go/iam v0.6.0/go.mod h1:+1AH33ueBne5MzYccyMHtEKqLE4/kJOibtffMHDMFMc= +cloud.google.com/go/iam v0.7.0/go.mod h1:H5Br8wRaDGNc8XP3keLc4unfUUZeyH3Sfl9XpQEYOeg= +cloud.google.com/go/iam v0.8.0/go.mod h1:lga0/y3iH6CX7sYqypWJ33hf7kkfXJag67naqGESjkE= +cloud.google.com/go/iap v1.4.0/go.mod h1:RGFwRJdihTINIe4wZ2iCP0zF/qu18ZwyKxrhMhygBEc= +cloud.google.com/go/iap v1.5.0/go.mod h1:UH/CGgKd4KyohZL5Pt0jSKE4m3FR51qg6FKQ/z/Ix9A= +cloud.google.com/go/ids v1.1.0/go.mod h1:WIuwCaYVOzHIj2OhN9HAwvW+DBdmUAdcWlFxRl+KubM= +cloud.google.com/go/ids v1.2.0/go.mod h1:5WXvp4n25S0rA/mQWAg1YEEBBq6/s+7ml1RDCW1IrcY= +cloud.google.com/go/iot v1.3.0/go.mod h1:r7RGh2B61+B8oz0AGE+J72AhA0G7tdXItODWsaA2oLs= +cloud.google.com/go/iot v1.4.0/go.mod h1:dIDxPOn0UvNDUMD8Ger7FIaTuvMkj+aGk94RPP0iV+g= +cloud.google.com/go/kms v1.4.0/go.mod h1:fajBHndQ+6ubNw6Ss2sSd+SWvjL26RNo/dr7uxsnnOA= +cloud.google.com/go/kms v1.5.0/go.mod h1:QJS2YY0eJGBg3mnDfuaCyLauWwBJiHRboYxJ++1xJNg= +cloud.google.com/go/kms v1.6.0/go.mod h1:Jjy850yySiasBUDi6KFUwUv2n1+o7QZFyuUJg6OgjA0= +cloud.google.com/go/language v1.4.0/go.mod h1:F9dRpNFQmJbkaop6g0JhSBXCNlO90e1KWx5iDdxbWic= +cloud.google.com/go/language v1.6.0/go.mod h1:6dJ8t3B+lUYfStgls25GusK04NLh3eDLQnWM3mdEbhI= +cloud.google.com/go/language v1.7.0/go.mod h1:DJ6dYN/W+SQOjF8e1hLQXMF21AkH2w9wiPzPCJa2MIE= +cloud.google.com/go/language v1.8.0/go.mod h1:qYPVHf7SPoNNiCL2Dr0FfEFNil1qi3pQEyygwpgVKB8= +cloud.google.com/go/lifesciences v0.5.0/go.mod h1:3oIKy8ycWGPUyZDR/8RNnTOYevhaMLqh5vLUXs9zvT8= +cloud.google.com/go/lifesciences v0.6.0/go.mod h1:ddj6tSX/7BOnhxCSd3ZcETvtNr8NZ6t/iPhY2Tyfu08= +cloud.google.com/go/logging v1.6.1/go.mod h1:5ZO0mHHbvm8gEmeEUHrmDlTDSu5imF6MUP9OfilNXBw= +cloud.google.com/go/longrunning v0.1.1/go.mod h1:UUFxuDWkv22EuY93jjmDMFT5GPQKeFVJBIF6QlTqdsE= +cloud.google.com/go/longrunning v0.3.0/go.mod h1:qth9Y41RRSUE69rDcOn6DdK3HfQfsUI0YSmW3iIlLJc= +cloud.google.com/go/managedidentities v1.3.0/go.mod h1:UzlW3cBOiPrzucO5qWkNkh0w33KFtBJU281hacNvsdE= +cloud.google.com/go/managedidentities v1.4.0/go.mod h1:NWSBYbEMgqmbZsLIyKvxrYbtqOsxY1ZrGM+9RgDqInM= +cloud.google.com/go/maps v0.1.0/go.mod h1:BQM97WGyfw9FWEmQMpZ5T6cpovXXSd1cGmFma94eubI= +cloud.google.com/go/mediatranslation v0.5.0/go.mod h1:jGPUhGTybqsPQn91pNXw0xVHfuJ3leR1wj37oU3y1f4= +cloud.google.com/go/mediatranslation v0.6.0/go.mod h1:hHdBCTYNigsBxshbznuIMFNe5QXEowAuNmmC7h8pu5w= +cloud.google.com/go/memcache v1.4.0/go.mod h1:rTOfiGZtJX1AaFUrOgsMHX5kAzaTQ8azHiuDoTPzNsE= +cloud.google.com/go/memcache v1.5.0/go.mod h1:dk3fCK7dVo0cUU2c36jKb4VqKPS22BTkf81Xq617aWM= +cloud.google.com/go/memcache v1.6.0/go.mod h1:XS5xB0eQZdHtTuTF9Hf8eJkKtR3pVRCcvJwtm68T3rA= +cloud.google.com/go/memcache v1.7.0/go.mod h1:ywMKfjWhNtkQTxrWxCkCFkoPjLHPW6A7WOTVI8xy3LY= +cloud.google.com/go/metastore v1.5.0/go.mod h1:2ZNrDcQwghfdtCwJ33nM0+GrBGlVuh8rakL3vdPY3XY= +cloud.google.com/go/metastore v1.6.0/go.mod h1:6cyQTls8CWXzk45G55x57DVQ9gWg7RiH65+YgPsNh9s= +cloud.google.com/go/metastore v1.7.0/go.mod h1:s45D0B4IlsINu87/AsWiEVYbLaIMeUSoxlKKDqBGFS8= +cloud.google.com/go/metastore v1.8.0/go.mod h1:zHiMc4ZUpBiM7twCIFQmJ9JMEkDSyZS9U12uf7wHqSI= +cloud.google.com/go/monitoring v1.7.0/go.mod h1:HpYse6kkGo//7p6sT0wsIC6IBDET0RhIsnmlA53dvEk= +cloud.google.com/go/monitoring v1.8.0/go.mod h1:E7PtoMJ1kQXWxPjB6mv2fhC5/15jInuulFdYYtlcvT4= +cloud.google.com/go/networkconnectivity v1.4.0/go.mod h1:nOl7YL8odKyAOtzNX73/M5/mGZgqqMeryi6UPZTk/rA= +cloud.google.com/go/networkconnectivity v1.5.0/go.mod h1:3GzqJx7uhtlM3kln0+x5wyFvuVH1pIBJjhCpjzSt75o= +cloud.google.com/go/networkconnectivity v1.6.0/go.mod h1:OJOoEXW+0LAxHh89nXd64uGG+FbQoeH8DtxCHVOMlaM= +cloud.google.com/go/networkconnectivity v1.7.0/go.mod h1:RMuSbkdbPwNMQjB5HBWD5MpTBnNm39iAVpC3TmsExt8= +cloud.google.com/go/networkmanagement v1.4.0/go.mod h1:Q9mdLLRn60AsOrPc8rs8iNV6OHXaGcDdsIQe1ohekq8= +cloud.google.com/go/networkmanagement v1.5.0/go.mod h1:ZnOeZ/evzUdUsnvRt792H0uYEnHQEMaz+REhhzJRcf4= +cloud.google.com/go/networksecurity v0.5.0/go.mod h1:xS6fOCoqpVC5zx15Z/MqkfDwH4+m/61A3ODiDV1xmiQ= +cloud.google.com/go/networksecurity v0.6.0/go.mod h1:Q5fjhTr9WMI5mbpRYEbiexTzROf7ZbDzvzCrNl14nyU= +cloud.google.com/go/notebooks v1.2.0/go.mod h1:9+wtppMfVPUeJ8fIWPOq1UnATHISkGXGqTkxeieQ6UY= +cloud.google.com/go/notebooks v1.3.0/go.mod h1:bFR5lj07DtCPC7YAAJ//vHskFBxA5JzYlH68kXVdk34= +cloud.google.com/go/notebooks v1.4.0/go.mod h1:4QPMngcwmgb6uw7Po99B2xv5ufVoIQ7nOGDyL4P8AgA= +cloud.google.com/go/notebooks v1.5.0/go.mod h1:q8mwhnP9aR8Hpfnrc5iN5IBhrXUy8S2vuYs+kBJ/gu0= +cloud.google.com/go/optimization v1.1.0/go.mod h1:5po+wfvX5AQlPznyVEZjGJTMr4+CAkJf2XSTQOOl9l4= +cloud.google.com/go/optimization v1.2.0/go.mod h1:Lr7SOHdRDENsh+WXVmQhQTrzdu9ybg0NecjHidBq6xs= +cloud.google.com/go/orchestration v1.3.0/go.mod h1:Sj5tq/JpWiB//X/q3Ngwdl5K7B7Y0KZ7bfv0wL6fqVA= +cloud.google.com/go/orchestration v1.4.0/go.mod h1:6W5NLFWs2TlniBphAViZEVhrXRSMgUGDfW7vrWKvsBk= +cloud.google.com/go/orgpolicy v1.4.0/go.mod h1:xrSLIV4RePWmP9P3tBl8S93lTmlAxjm06NSm2UTmKvE= +cloud.google.com/go/orgpolicy v1.5.0/go.mod h1:hZEc5q3wzwXJaKrsx5+Ewg0u1LxJ51nNFlext7Tanwc= +cloud.google.com/go/osconfig v1.7.0/go.mod h1:oVHeCeZELfJP7XLxcBGTMBvRO+1nQ5tFG9VQTmYS2Fs= +cloud.google.com/go/osconfig v1.8.0/go.mod h1:EQqZLu5w5XA7eKizepumcvWx+m8mJUhEwiPqWiZeEdg= +cloud.google.com/go/osconfig v1.9.0/go.mod h1:Yx+IeIZJ3bdWmzbQU4fxNl8xsZ4amB+dygAwFPlvnNo= +cloud.google.com/go/osconfig v1.10.0/go.mod h1:uMhCzqC5I8zfD9zDEAfvgVhDS8oIjySWh+l4WK6GnWw= +cloud.google.com/go/oslogin v1.4.0/go.mod h1:YdgMXWRaElXz/lDk1Na6Fh5orF7gvmJ0FGLIs9LId4E= +cloud.google.com/go/oslogin v1.5.0/go.mod h1:D260Qj11W2qx/HVF29zBg+0fd6YCSjSqLUkY/qEenQU= +cloud.google.com/go/oslogin v1.6.0/go.mod h1:zOJ1O3+dTU8WPlGEkFSh7qeHPPSoxrcMbbK1Nm2iX70= +cloud.google.com/go/oslogin v1.7.0/go.mod h1:e04SN0xO1UNJ1M5GP0vzVBFicIe4O53FOfcixIqTyXo= +cloud.google.com/go/phishingprotection v0.5.0/go.mod h1:Y3HZknsK9bc9dMi+oE8Bim0lczMU6hrX0UpADuMefr0= +cloud.google.com/go/phishingprotection v0.6.0/go.mod h1:9Y3LBLgy0kDTcYET8ZH3bq/7qni15yVUoAxiFxnlSUA= +cloud.google.com/go/policytroubleshooter v1.3.0/go.mod h1:qy0+VwANja+kKrjlQuOzmlvscn4RNsAc0e15GGqfMxg= +cloud.google.com/go/policytroubleshooter v1.4.0/go.mod h1:DZT4BcRw3QoO8ota9xw/LKtPa8lKeCByYeKTIf/vxdE= +cloud.google.com/go/privatecatalog v0.5.0/go.mod h1:XgosMUvvPyxDjAVNDYxJ7wBW8//hLDDYmnsNcMGq1K0= +cloud.google.com/go/privatecatalog v0.6.0/go.mod h1:i/fbkZR0hLN29eEWiiwue8Pb+GforiEIBnV9yrRUOKI= cloud.google.com/go/pubsub v1.0.1/go.mod h1:R0Gpsv3s54REJCy4fxDixWD93lHJMoZTyQ2kNxGRt3I= cloud.google.com/go/pubsub v1.1.0/go.mod h1:EwwdRX2sKPjnvnqCa270oGRyludottCI76h+R3AArQw= cloud.google.com/go/pubsub v1.2.0/go.mod h1:jhfEVHT8odbXTkndysNHCcx0awwzvfOlguIAii9o8iA= cloud.google.com/go/pubsub v1.3.1/go.mod h1:i+ucay31+CNRpDW4Lu78I4xXG+O1r/MAHgjpRVR+TSU= +cloud.google.com/go/pubsub v1.26.0/go.mod h1:QgBH3U/jdJy/ftjPhTkyXNj543Tin1pRYcdcPRnFIRI= +cloud.google.com/go/pubsub v1.27.1/go.mod h1:hQN39ymbV9geqBnfQq6Xf63yNhUAhv9CZhzp5O6qsW0= +cloud.google.com/go/pubsublite v1.5.0/go.mod h1:xapqNQ1CuLfGi23Yda/9l4bBCKz/wC3KIJ5gKcxveZg= +cloud.google.com/go/recaptchaenterprise v1.3.1/go.mod h1:OdD+q+y4XGeAlxRaMn1Y7/GveP6zmq76byL6tjPE7d4= +cloud.google.com/go/recaptchaenterprise/v2 v2.1.0/go.mod h1:w9yVqajwroDNTfGuhmOjPDN//rZGySaf6PtFVcSCa7o= +cloud.google.com/go/recaptchaenterprise/v2 v2.2.0/go.mod h1:/Zu5jisWGeERrd5HnlS3EUGb/D335f9k51B/FVil0jk= +cloud.google.com/go/recaptchaenterprise/v2 v2.3.0/go.mod h1:O9LwGCjrhGHBQET5CA7dd5NwwNQUErSgEDit1DLNTdo= +cloud.google.com/go/recaptchaenterprise/v2 v2.4.0/go.mod h1:Am3LHfOuBstrLrNCBrlI5sbwx9LBg3te2N6hGvHn2mE= +cloud.google.com/go/recaptchaenterprise/v2 v2.5.0/go.mod h1:O8LzcHXN3rz0j+LBC91jrwI3R+1ZSZEWrfL7XHgNo9U= +cloud.google.com/go/recommendationengine v0.5.0/go.mod h1:E5756pJcVFeVgaQv3WNpImkFP8a+RptV6dDLGPILjvg= +cloud.google.com/go/recommendationengine v0.6.0/go.mod h1:08mq2umu9oIqc7tDy8sx+MNJdLG0fUi3vaSVbztHgJ4= +cloud.google.com/go/recommender v1.5.0/go.mod h1:jdoeiBIVrJe9gQjwd759ecLJbxCDED4A6p+mqoqDvTg= +cloud.google.com/go/recommender v1.6.0/go.mod h1:+yETpm25mcoiECKh9DEScGzIRyDKpZ0cEhWGo+8bo+c= +cloud.google.com/go/recommender v1.7.0/go.mod h1:XLHs/W+T8olwlGOgfQenXBTbIseGclClff6lhFVe9Bs= +cloud.google.com/go/recommender v1.8.0/go.mod h1:PkjXrTT05BFKwxaUxQmtIlrtj0kph108r02ZZQ5FE70= +cloud.google.com/go/redis v1.7.0/go.mod h1:V3x5Jq1jzUcg+UNsRvdmsfuFnit1cfe3Z/PGyq/lm4Y= +cloud.google.com/go/redis v1.8.0/go.mod h1:Fm2szCDavWzBk2cDKxrkmWBqoCiL1+Ctwq7EyqBCA/A= +cloud.google.com/go/redis v1.9.0/go.mod h1:HMYQuajvb2D0LvMgZmLDZW8V5aOC/WxstZHiy4g8OiA= +cloud.google.com/go/redis v1.10.0/go.mod h1:ThJf3mMBQtW18JzGgh41/Wld6vnDDc/F/F35UolRZPM= +cloud.google.com/go/resourcemanager v1.3.0/go.mod h1:bAtrTjZQFJkiWTPDb1WBjzvc6/kifjj4QBYuKCCoqKA= +cloud.google.com/go/resourcemanager v1.4.0/go.mod h1:MwxuzkumyTX7/a3n37gmsT3py7LIXwrShilPh3P1tR0= +cloud.google.com/go/resourcesettings v1.3.0/go.mod h1:lzew8VfESA5DQ8gdlHwMrqZs1S9V87v3oCnKCWoOuQU= +cloud.google.com/go/resourcesettings v1.4.0/go.mod h1:ldiH9IJpcrlC3VSuCGvjR5of/ezRrOxFtpJoJo5SmXg= +cloud.google.com/go/retail v1.8.0/go.mod h1:QblKS8waDmNUhghY2TI9O3JLlFk8jybHeV4BF19FrE4= +cloud.google.com/go/retail v1.9.0/go.mod h1:g6jb6mKuCS1QKnH/dpu7isX253absFl6iE92nHwlBUY= +cloud.google.com/go/retail v1.10.0/go.mod h1:2gDk9HsL4HMS4oZwz6daui2/jmKvqShXKQuB2RZ+cCc= +cloud.google.com/go/retail v1.11.0/go.mod h1:MBLk1NaWPmh6iVFSz9MeKG/Psyd7TAgm6y/9L2B4x9Y= +cloud.google.com/go/run v0.2.0/go.mod h1:CNtKsTA1sDcnqqIFR3Pb5Tq0usWxJJvsWOCPldRU3Do= +cloud.google.com/go/run v0.3.0/go.mod h1:TuyY1+taHxTjrD0ZFk2iAR+xyOXEA0ztb7U3UNA0zBo= +cloud.google.com/go/scheduler v1.4.0/go.mod h1:drcJBmxF3aqZJRhmkHQ9b3uSSpQoltBPGPxGAWROx6s= +cloud.google.com/go/scheduler v1.5.0/go.mod h1:ri073ym49NW3AfT6DZi21vLZrG07GXr5p3H1KxN5QlI= +cloud.google.com/go/scheduler v1.6.0/go.mod h1:SgeKVM7MIwPn3BqtcBntpLyrIJftQISRrYB5ZtT+KOk= +cloud.google.com/go/scheduler v1.7.0/go.mod h1:jyCiBqWW956uBjjPMMuX09n3x37mtyPJegEWKxRsn44= +cloud.google.com/go/secretmanager v1.6.0/go.mod h1:awVa/OXF6IiyaU1wQ34inzQNc4ISIDIrId8qE5QGgKA= +cloud.google.com/go/secretmanager v1.8.0/go.mod h1:hnVgi/bN5MYHd3Gt0SPuTPPp5ENina1/LxM+2W9U9J4= +cloud.google.com/go/secretmanager v1.9.0/go.mod h1:b71qH2l1yHmWQHt9LC80akm86mX8AL6X1MA01dW8ht4= +cloud.google.com/go/security v1.5.0/go.mod h1:lgxGdyOKKjHL4YG3/YwIL2zLqMFCKs0UbQwgyZmfJl4= +cloud.google.com/go/security v1.7.0/go.mod h1:mZklORHl6Bg7CNnnjLH//0UlAlaXqiG7Lb9PsPXLfD0= +cloud.google.com/go/security v1.8.0/go.mod h1:hAQOwgmaHhztFhiQ41CjDODdWP0+AE1B3sX4OFlq+GU= +cloud.google.com/go/security v1.9.0/go.mod h1:6Ta1bO8LXI89nZnmnsZGp9lVoVWXqsVbIq/t9dzI+2Q= +cloud.google.com/go/security v1.10.0/go.mod h1:QtOMZByJVlibUT2h9afNDWRZ1G96gVywH8T5GUSb9IA= +cloud.google.com/go/securitycenter v1.13.0/go.mod h1:cv5qNAqjY84FCN6Y9z28WlkKXyWsgLO832YiWwkCWcU= +cloud.google.com/go/securitycenter v1.14.0/go.mod h1:gZLAhtyKv85n52XYWt6RmeBdydyxfPeTrpToDPw4Auc= +cloud.google.com/go/securitycenter v1.15.0/go.mod h1:PeKJ0t8MoFmmXLXWm41JidyzI3PJjd8sXWaVqg43WWk= +cloud.google.com/go/securitycenter v1.16.0/go.mod h1:Q9GMaLQFUD+5ZTabrbujNWLtSLZIZF7SAR0wWECrjdk= +cloud.google.com/go/servicecontrol v1.4.0/go.mod h1:o0hUSJ1TXJAmi/7fLJAedOovnujSEvjKCAFNXPQ1RaU= +cloud.google.com/go/servicecontrol v1.5.0/go.mod h1:qM0CnXHhyqKVuiZnGKrIurvVImCs8gmqWsDoqe9sU1s= +cloud.google.com/go/servicedirectory v1.4.0/go.mod h1:gH1MUaZCgtP7qQiI+F+A+OpeKF/HQWgtAddhTbhL2bs= +cloud.google.com/go/servicedirectory v1.5.0/go.mod h1:QMKFL0NUySbpZJ1UZs3oFAmdvVxhhxB6eJ/Vlp73dfg= +cloud.google.com/go/servicedirectory v1.6.0/go.mod h1:pUlbnWsLH9c13yGkxCmfumWEPjsRs1RlmJ4pqiNjVL4= +cloud.google.com/go/servicedirectory v1.7.0/go.mod h1:5p/U5oyvgYGYejufvxhgwjL8UVXjkuw7q5XcG10wx1U= +cloud.google.com/go/servicemanagement v1.4.0/go.mod h1:d8t8MDbezI7Z2R1O/wu8oTggo3BI2GKYbdG4y/SJTco= +cloud.google.com/go/servicemanagement v1.5.0/go.mod h1:XGaCRe57kfqu4+lRxaFEAuqmjzF0r+gWHjWqKqBvKFo= +cloud.google.com/go/serviceusage v1.3.0/go.mod h1:Hya1cozXM4SeSKTAgGXgj97GlqUvF5JaoXacR1JTP/E= +cloud.google.com/go/serviceusage v1.4.0/go.mod h1:SB4yxXSaYVuUBYUml6qklyONXNLt83U0Rb+CXyhjEeU= +cloud.google.com/go/shell v1.3.0/go.mod h1:VZ9HmRjZBsjLGXusm7K5Q5lzzByZmJHf1d0IWHEN5X4= +cloud.google.com/go/shell v1.4.0/go.mod h1:HDxPzZf3GkDdhExzD/gs8Grqk+dmYcEjGShZgYa9URw= +cloud.google.com/go/spanner v1.41.0/go.mod h1:MLYDBJR/dY4Wt7ZaMIQ7rXOTLjYrmxLE/5ve9vFfWos= +cloud.google.com/go/speech v1.6.0/go.mod h1:79tcr4FHCimOp56lwC01xnt/WPJZc4v3gzyT7FoBkCM= +cloud.google.com/go/speech v1.7.0/go.mod h1:KptqL+BAQIhMsj1kOP2la5DSEEerPDuOP/2mmkhHhZQ= +cloud.google.com/go/speech v1.8.0/go.mod h1:9bYIl1/tjsAnMgKGHKmBZzXKEkGgtU+MpdDPTE9f7y0= +cloud.google.com/go/speech v1.9.0/go.mod h1:xQ0jTcmnRFFM2RfX/U+rk6FQNUF6DQlydUSyoooSpco= cloud.google.com/go/storage v1.0.0/go.mod h1:IhtSnM/ZTZV8YYJWCY8RULGVqBDmpoyjwiyrjsg+URw= cloud.google.com/go/storage v1.5.0/go.mod h1:tpKbwo567HUNpVclU5sGELwQWBDZ8gh0ZeosJ0Rtdos= cloud.google.com/go/storage v1.6.0/go.mod h1:N7U0C8pVQ/+NIKOBQyamJIeKQKkZ+mxpohlUTyfDhBk= cloud.google.com/go/storage v1.8.0/go.mod h1:Wv1Oy7z6Yz3DshWRJFhqM/UCfaWIRTdp0RXyy7KQOVs= cloud.google.com/go/storage v1.10.0/go.mod h1:FLPqc6j+Ki4BU591ie1oL6qBQGu2Bl/tZ9ullr3+Kg0= +cloud.google.com/go/storage v1.14.0/go.mod h1:GrKmX003DSIwi9o29oFT7YDnHYwZoctc3fOKtUw0Xmo= +cloud.google.com/go/storage v1.22.1/go.mod h1:S8N1cAStu7BOeFfE8KAQzmyyLkK8p/vmRq6kuBTW58Y= +cloud.google.com/go/storage v1.23.0/go.mod h1:vOEEDNFnciUMhBeT6hsJIn3ieU5cFRmzeLgDvXzfIXc= +cloud.google.com/go/storage v1.27.0/go.mod h1:x9DOL8TK/ygDUMieqwfhdpQryTeEkhGKMi80i/iqR2s= +cloud.google.com/go/storagetransfer v1.5.0/go.mod h1:dxNzUopWy7RQevYFHewchb29POFv3/AaBgnhqzqiK0w= +cloud.google.com/go/storagetransfer v1.6.0/go.mod h1:y77xm4CQV/ZhFZH75PLEXY0ROiS7Gh6pSKrM8dJyg6I= +cloud.google.com/go/talent v1.1.0/go.mod h1:Vl4pt9jiHKvOgF9KoZo6Kob9oV4lwd/ZD5Cto54zDRw= +cloud.google.com/go/talent v1.2.0/go.mod h1:MoNF9bhFQbiJ6eFD3uSsg0uBALw4n4gaCaEjBw9zo8g= +cloud.google.com/go/talent v1.3.0/go.mod h1:CmcxwJ/PKfRgd1pBjQgU6W3YBwiewmUzQYH5HHmSCmM= +cloud.google.com/go/talent v1.4.0/go.mod h1:ezFtAgVuRf8jRsvyE6EwmbTK5LKciD4KVnHuDEFmOOA= +cloud.google.com/go/texttospeech v1.4.0/go.mod h1:FX8HQHA6sEpJ7rCMSfXuzBcysDAuWusNNNvN9FELDd8= +cloud.google.com/go/texttospeech v1.5.0/go.mod h1:oKPLhR4n4ZdQqWKURdwxMy0uiTS1xU161C8W57Wkea4= +cloud.google.com/go/tpu v1.3.0/go.mod h1:aJIManG0o20tfDQlRIej44FcwGGl/cD0oiRyMKG19IQ= +cloud.google.com/go/tpu v1.4.0/go.mod h1:mjZaX8p0VBgllCzF6wcU2ovUXN9TONFLd7iz227X2Xg= +cloud.google.com/go/trace v1.3.0/go.mod h1:FFUE83d9Ca57C+K8rDl/Ih8LwOzWIV1krKgxg6N0G28= +cloud.google.com/go/trace v1.4.0/go.mod h1:UG0v8UBqzusp+z63o7FK74SdFE+AXpCLdFb1rshXG+Y= +cloud.google.com/go/translate v1.3.0/go.mod h1:gzMUwRjvOqj5i69y/LYLd8RrNQk+hOmIXTi9+nb3Djs= +cloud.google.com/go/translate v1.4.0/go.mod h1:06Dn/ppvLD6WvA5Rhdp029IX2Mi3Mn7fpMRLPvXT5Wg= +cloud.google.com/go/video v1.8.0/go.mod h1:sTzKFc0bUSByE8Yoh8X0mn8bMymItVGPfTuUBUyRgxk= +cloud.google.com/go/video v1.9.0/go.mod h1:0RhNKFRF5v92f8dQt0yhaHrEuH95m068JYOvLZYnJSw= +cloud.google.com/go/videointelligence v1.6.0/go.mod h1:w0DIDlVRKtwPCn/C4iwZIJdvC69yInhW0cfi+p546uU= +cloud.google.com/go/videointelligence v1.7.0/go.mod h1:k8pI/1wAhjznARtVT9U1llUaFNPh7muw8QyOUpavru4= +cloud.google.com/go/videointelligence v1.8.0/go.mod h1:dIcCn4gVDdS7yte/w+koiXn5dWVplOZkE+xwG9FgK+M= +cloud.google.com/go/videointelligence v1.9.0/go.mod h1:29lVRMPDYHikk3v8EdPSaL8Ku+eMzDljjuvRs105XoU= +cloud.google.com/go/vision v1.2.0/go.mod h1:SmNwgObm5DpFBme2xpyOyasvBc1aPdjvMk2bBk0tKD0= +cloud.google.com/go/vision/v2 v2.2.0/go.mod h1:uCdV4PpN1S0jyCyq8sIM42v2Y6zOLkZs+4R9LrGYwFo= +cloud.google.com/go/vision/v2 v2.3.0/go.mod h1:UO61abBx9QRMFkNBbf1D8B1LXdS2cGiiCRx0vSpZoUo= +cloud.google.com/go/vision/v2 v2.4.0/go.mod h1:VtI579ll9RpVTrdKdkMzckdnwMyX2JILb+MhPqRbPsY= +cloud.google.com/go/vision/v2 v2.5.0/go.mod h1:MmaezXOOE+IWa+cS7OhRRLK2cNv1ZL98zhqFFZaaH2E= +cloud.google.com/go/vmmigration v1.2.0/go.mod h1:IRf0o7myyWFSmVR1ItrBSFLFD/rJkfDCUTO4vLlJvsE= +cloud.google.com/go/vmmigration v1.3.0/go.mod h1:oGJ6ZgGPQOFdjHuocGcLqX4lc98YQ7Ygq8YQwHh9A7g= +cloud.google.com/go/vmwareengine v0.1.0/go.mod h1:RsdNEf/8UDvKllXhMz5J40XxDrNJNN4sagiox+OI208= +cloud.google.com/go/vpcaccess v1.4.0/go.mod h1:aQHVbTWDYUR1EbTApSVvMq1EnT57ppDmQzZ3imqIk4w= +cloud.google.com/go/vpcaccess v1.5.0/go.mod h1:drmg4HLk9NkZpGfCmZ3Tz0Bwnm2+DKqViEpeEpOq0m8= +cloud.google.com/go/webrisk v1.4.0/go.mod h1:Hn8X6Zr+ziE2aNd8SliSDWpEnSS1u4R9+xXZmFiHmGE= +cloud.google.com/go/webrisk v1.5.0/go.mod h1:iPG6fr52Tv7sGk0H6qUFzmL3HHZev1htXuWDEEsqMTg= +cloud.google.com/go/webrisk v1.6.0/go.mod h1:65sW9V9rOosnc9ZY7A7jsy1zoHS5W9IAXv6dGqhMQMc= +cloud.google.com/go/webrisk v1.7.0/go.mod h1:mVMHgEYH0r337nmt1JyLthzMr6YxwN1aAIEc2fTcq7A= +cloud.google.com/go/websecurityscanner v1.3.0/go.mod h1:uImdKm2wyeXQevQJXeh8Uun/Ym1VqworNDlBXQevGMo= +cloud.google.com/go/websecurityscanner v1.4.0/go.mod h1:ebit/Fp0a+FWu5j4JOmJEV8S8CzdTkAS77oDsiSqYWQ= +cloud.google.com/go/workflows v1.6.0/go.mod h1:6t9F5h/unJz41YqfBmqSASJSXccBLtD1Vwf+KmJENM0= +cloud.google.com/go/workflows v1.7.0/go.mod h1:JhSrZuVZWuiDfKEFxU0/F1PQjmpnpcoISEXH2bcHC3M= +cloud.google.com/go/workflows v1.8.0/go.mod h1:ysGhmEajwZxGn1OhGOGKsTXc5PyxOc0vfKf5Af+to4M= +cloud.google.com/go/workflows v1.9.0/go.mod h1:ZGkj1aFIOd9c8Gerkjjq7OW7I5+l6cSvT3ujaO/WwSA= collectd.org v0.3.0/go.mod h1:A/8DzQBkF6abtvrT2j/AU/4tiBgJWYyh0y/oB/4MlWE= dmitri.shuralyov.com/gpu/mtl v0.0.0-20190408044501-666a987793e9/go.mod h1:H6x//7gZCb22OMCxBHrMx7a5I7Hp++hsVxbQ4BYO7hU= filippo.io/edwards25519 v1.0.0-beta.2 h1:/BZRNzm8N4K4eWfK28dL4yescorxtO7YG1yun8fy+pI= @@ -90,6 +440,7 @@ github.com/alecthomas/template v0.0.0-20190718012654-fb15b899a751/go.mod h1:LOuy github.com/alecthomas/units v0.0.0-20151022065526-2efee857e7cf/go.mod h1:ybxpYRFXyAe+OPACYpWeL0wqObRcbAqCMya13uyzqw0= github.com/alecthomas/units v0.0.0-20190717042225-c3de453c63f4/go.mod h1:ybxpYRFXyAe+OPACYpWeL0wqObRcbAqCMya13uyzqw0= github.com/alecthomas/units v0.0.0-20190924025748-f65c72e2690d/go.mod h1:rBZYJk541a8SKzHPHnH3zbiI+7dagKZ0cgpgrD7Fyho= +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/andreyvit/diff v0.0.0-20170406064948-c7f18ee00883/go.mod h1:rCTlJbsFo29Kk6CurOXKm700vrz8f0KW0JNfpkRJY/8= github.com/antihax/optional v1.0.0/go.mod h1:uupD/76wgC+ih3iEmQUL+0Ugr19nfwCT1kdvxnR2qWY= @@ -103,6 +454,7 @@ github.com/armon/go-metrics v0.0.0-20180917152333-f0300d1749da/go.mod h1:Q73ZrmV github.com/armon/go-metrics v0.3.9 h1:O2sNqxBdvq8Eq5xmzljcYzAORli6RWCvEym4cJf9m18= github.com/armon/go-metrics v0.3.9/go.mod h1:4O98XIr/9W0sxpJ8UaYkvjk10Iff7SnFrb4QAOwNTFc= github.com/armon/go-radix v0.0.0-20180808171621-7fddfc383310/go.mod h1:ufUuZ+zHj4x4TnLV4JWEpy2hxWSpsRywHrMgIH9cCH8= +github.com/armon/go-radix v1.0.0/go.mod h1:ufUuZ+zHj4x4TnLV4JWEpy2hxWSpsRywHrMgIH9cCH8= github.com/aryann/difflib v0.0.0-20170710044230-e206f873d14a/go.mod h1:DAHtR1m6lCRdSC2Tm3DSWRPvIPr6xNKyeHdqDQSQT+A= github.com/avast/retry-go v3.0.0+incompatible h1:4SOWQ7Qs+oroOTQOYnAHqelpCO0biHSxpiH9JdtuBj0= github.com/avast/retry-go v3.0.0+incompatible/go.mod h1:XtSnn+n/sHqQIpZ10K1qAevBhOOCWBLXXy3hyiqqBrY= @@ -158,11 +510,14 @@ github.com/c-bata/go-prompt v0.2.2/go.mod h1:VzqtzE2ksDBcdln8G7mk2RX9QyGjH+OVqOC github.com/casbin/casbin/v2 v2.1.2/go.mod h1:YcPU1XXisHhLzuxH9coDNf2FbKpjGlbCg3n9yuLkIJQ= github.com/cenkalti/backoff v2.2.1+incompatible/go.mod h1:90ReRw6GdpyfrHakVjL/QHaoyV4aDUVVkXQJJJ3NXXM= github.com/census-instrumentation/opencensus-proto v0.2.1/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU= +github.com/census-instrumentation/opencensus-proto v0.3.0/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU= +github.com/census-instrumentation/opencensus-proto v0.4.1/go.mod h1:4T9NM4+4Vw91VeyqjLS6ao50K5bOcLKN6Q42XnYaRYw= github.com/cespare/cp v0.1.0/go.mod h1:SOGHArjBr4JWaSDEVpWpo/hNg6RoKrls6Oh40hiwW+s= github.com/cespare/xxhash v1.1.0 h1:a6HrQnmkObjyL+Gs60czilIUGqrzKutQD6XZog3p+ko= github.com/cespare/xxhash v1.1.0/go.mod h1:XrSqR1VqqWfGrhpAt58auRo0WTKS1nRRg3ghfAqPWnc= -github.com/cespare/xxhash/v2 v2.1.1 h1:6MnRN8NT7+YBpUIWxHtefFZOKTAPgGjpQSxqLNn0+qY= github.com/cespare/xxhash/v2 v2.1.1/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= +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/chzyer/logex v1.1.10/go.mod h1:+Ywpsq7O8HXn0nuIou7OrIPyXbp3wmkHB+jjWRnGsAI= github.com/chzyer/readline v0.0.0-20180603132655-2972be24d48e/go.mod h1:nSuG5e5PlCu98SY8svDHJxuZscDgtXS6KTTbou5AhLI= github.com/chzyer/test v0.0.0-20180213035817-a1ea475d72b1/go.mod h1:Q3SI9o4m/ZMnBNeIyt5eFwwo7qiLfzFZmjNmxjkiQlU= @@ -175,8 +530,15 @@ github.com/cloudflare/cloudflare-go v0.14.0/go.mod h1:EnwdgGMaFOruiPZRFSgn+TsQ3h github.com/cncf/udpa/go v0.0.0-20191209042840-269d4d468f6f/go.mod h1:M8M6+tZqaGXZJjfX53e64911xZQV5JYwmTeXPW+k8Sc= github.com/cncf/udpa/go v0.0.0-20200629203442-efcf912fb354/go.mod h1:WmhPx2Nbnhtbo57+VJT5O0JRkEi1Wbu0z5j0R8u5Hbk= github.com/cncf/udpa/go v0.0.0-20201120205902-5459f2c99403/go.mod h1:WmhPx2Nbnhtbo57+VJT5O0JRkEi1Wbu0z5j0R8u5Hbk= +github.com/cncf/udpa/go v0.0.0-20210930031921-04548b0d99d4/go.mod h1:6pvJx4me5XPnfI9Z40ddWsdw2W/uZgQLFXToKeRcDiI= +github.com/cncf/udpa/go v0.0.0-20220112060539-c52dc94e7fbe/go.mod h1:6pvJx4me5XPnfI9Z40ddWsdw2W/uZgQLFXToKeRcDiI= github.com/cncf/xds/go v0.0.0-20210312221358-fbca930ec8ed/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs= github.com/cncf/xds/go v0.0.0-20210805033703-aa0b78936158/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs= +github.com/cncf/xds/go v0.0.0-20210922020428-25de7278fc84/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs= +github.com/cncf/xds/go v0.0.0-20211001041855-01bcc9b48dfe/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs= +github.com/cncf/xds/go v0.0.0-20211011173535-cb28da3451f1/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs= +github.com/cncf/xds/go v0.0.0-20220314180256-7f1daf1720fc/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs= +github.com/cncf/xds/go v0.0.0-20230105202645-06c439db220b/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs= github.com/cockroachdb/datadriven v0.0.0-20190809214429-80d97fb3cbaa/go.mod h1:zn76sxSg3SzpJ0PPJaLDCu+Bu0Lg3sKTORVIj19EIF8= github.com/codahale/hdrhistogram v0.0.0-20161010025455-3a0bb77429bd/go.mod h1:sE/e/2PUdi/liOCUjSTXgM1o87ZssimdTWN964YiIeI= github.com/coinbase/rosetta-sdk-go v0.6.10/go.mod h1:J/JFMsfcePrjJZkwQFLh+hJErkAmdm9Iyy3D5Y0LfXo= @@ -222,6 +584,7 @@ github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSs github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/deckarep/golang-set v0.0.0-20180603214616-504e848d77ea/go.mod h1:93vsz/8Wt4joVM7c2AVqh+YRMiUSc14yDtF28KmMOgQ= +github.com/deckarep/golang-set v1.8.0 h1:sk9/l/KqpunDwP7pSjUg0keiOOLEnOBHzykLrsPppp4= github.com/deckarep/golang-set v1.8.0/go.mod h1:5nI87KwE7wgsBU1F4GKAw2Qod7p5kyS383rP6+o6qqo= github.com/decred/dcrd/lru v1.0.0/go.mod h1:mxKOwFd7lFjN2GZYsiz/ecgqR6kkYAl+0pz0tEMk218= github.com/deepmap/oapi-codegen v1.6.0/go.mod h1:ryDa9AgbELGeB+YEXE1dR53yAjHwFvE9iAUlWl9Al3M= @@ -256,6 +619,7 @@ github.com/eapache/go-xerial-snappy v0.0.0-20180814174437-776d5712da21/go.mod h1 github.com/eapache/queue v1.1.0/go.mod h1:6eCeP0CKFpHLu8blIFXhExK/dRa7WDZfr6jVFPTqq+I= github.com/eclipse/paho.mqtt.golang v1.2.0/go.mod h1:H9keYFcgq3Qr5OUJm/JZI/i6U7joQ8SYLhZwfeOo6Ts= github.com/edsrzf/mmap-go v0.0.0-20160512033002-935e0e8a636c/go.mod h1:YO35OhQPt3KJa3ryjFM5Bs14WD66h8eGKpfaBNrHW5M= +github.com/edsrzf/mmap-go v1.0.0 h1:CEBF7HpRnUCSJgGUb5h1Gm7e3VkmVDrR8lvWVLtrOFw= github.com/edsrzf/mmap-go v1.0.0/go.mod h1:YO35OhQPt3KJa3ryjFM5Bs14WD66h8eGKpfaBNrHW5M= github.com/enigmampc/btcutil v1.0.3-0.20200723161021-e2fb6adb2a25 h1:2vLKys4RBU4pn2T/hjXMbvwTr1Cvy5THHrQkbeY9HRk= github.com/enigmampc/btcutil v1.0.3-0.20200723161021-e2fb6adb2a25/go.mod h1:hTr8+TLQmkUkgcuh3mcr5fjrT9c64ZzsBCdCEC6UppY= @@ -268,7 +632,11 @@ github.com/envoyproxy/go-control-plane v0.9.9-0.20201210154907-fd9021fe5dad/go.m github.com/envoyproxy/go-control-plane v0.9.9-0.20210217033140-668b12f5399d/go.mod h1:cXg6YxExXjJnVBQHBLXeUAgxn2UodCpnH306RInaBQk= github.com/envoyproxy/go-control-plane v0.9.9-0.20210512163311-63b5d3c536b0/go.mod h1:hliV/p42l8fGbc6Y9bQ70uLwIvmJyVE5k4iMKlh8wCQ= github.com/envoyproxy/go-control-plane v0.9.10-0.20210907150352-cf90f659a021/go.mod h1:AFq3mo9L8Lqqiid3OhADV3RfLJnjiw63cSpi+fDTRC0= +github.com/envoyproxy/go-control-plane v0.10.2-0.20220325020618-49ff273808a1/go.mod h1:KJwIaB5Mv44NWtYuAOFCVOjcI94vtpEz2JU/D2v6IjE= +github.com/envoyproxy/go-control-plane v0.10.3/go.mod h1:fJJn/j26vwOu972OllsvAgJJM//w9BV6Fxbg2LuVd34= github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c= +github.com/envoyproxy/protoc-gen-validate v0.6.7/go.mod h1:dyJXwwfPK2VSqiB9Klm1J6romD608Ba7Hij42vrOBCo= +github.com/envoyproxy/protoc-gen-validate v0.9.1/go.mod h1:OKNgG7TCp5pF4d6XftA0++PMirau2/yoOwVac3AbF2w= github.com/ethereum/go-ethereum v1.9.25/go.mod h1:vMkFiYLHI4tgPw4k2j4MHKoovchFE8plZ0M9VMk4/oM= github.com/ethereum/go-ethereum v1.10.16 h1:3oPrumn0bCW/idjcxMn5YYVCdK7VzJYIvwGZUGLEaoc= github.com/ethereum/go-ethereum v1.10.16/go.mod h1:Anj6cxczl+AHy63o4X9O8yWNHuN5wMpfb8MAnHkWn7Y= @@ -280,6 +648,7 @@ github.com/facebookgo/subset v0.0.0-20150612182917-8dac2c3c4870 h1:E2s37DuLxFhQD github.com/facebookgo/subset v0.0.0-20150612182917-8dac2c3c4870/go.mod h1:5tD+neXqOorC30/tWg0LCSkrqj/AR6gu8yY8/fpw1q0= github.com/fatih/color v1.3.0/go.mod h1:Zm6kSWBoL9eyXnKyktHP6abPY2pDugNf5KwzbycvMj4= github.com/fatih/color v1.7.0/go.mod h1:Zm6kSWBoL9eyXnKyktHP6abPY2pDugNf5KwzbycvMj4= +github.com/fatih/color v1.9.0/go.mod h1:eQcE1qtQxscV5RaZvpXrrb8Drkc3/DdQ+uUYCNjL+zU= github.com/fatih/color v1.10.0/go.mod h1:ELkj/draVOlAH/xkhN6mQ50Qd0MPOk5AAr3maGEBuJM= github.com/felixge/httpsnoop v1.0.1 h1:lvB5Jl89CsZtGIWuTcDM1E/vkVs49/Ml7JJe07l8SPQ= github.com/felixge/httpsnoop v1.0.1/go.mod h1:m8KPJKqk1gH5J9DgRY2ASl2lWCfGKXixSwevea8zH2U= @@ -291,8 +660,9 @@ github.com/fortytw2/leaktest v1.3.0/go.mod h1:jDsjWgpAGjm2CA7WthBh/CdZYEPF31XHqu github.com/franela/goblin v0.0.0-20200105215937-c9ffbefa60db/go.mod h1:7dvUGVsVBjqR7JHJk0brhHOZYGmfBYOrK0ZhYMEtBr4= github.com/franela/goreq v0.0.0-20171204163338-bcd34c9993f8/go.mod h1:ZhphrRTfi2rbfLwlschooIH4+wKKDR4Pdxhh+TRoA20= github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo= -github.com/fsnotify/fsnotify v1.4.9 h1:hsms1Qyu0jgnwNXIxa+/V/PDsU6CfLf6CNO8H7IWoS4= github.com/fsnotify/fsnotify v1.4.9/go.mod h1:znqG4EE+3YCdAaPaxE2ZRY/06pZUdp0tY4IgpuI1SZQ= +github.com/fsnotify/fsnotify v1.5.1 h1:mZcQUHVQUQWoPXXtuf9yuEXKudkV2sx1E06UadKWpgI= +github.com/fsnotify/fsnotify v1.5.1/go.mod h1:T3375wBYaZdLLcVNkcVbzGHY7f1l/uK5T5Ai1i3InKU= github.com/gballet/go-libpcsclite v0.0.0-20190607065134-2772fd86a8ff/go.mod h1:x7DCsMOv1taUwEWCzT4cmDeAkigA5/QCwUodaVOe8Ww= github.com/getkin/kin-openapi v0.53.0/go.mod h1:7Yn5whZr5kJi6t+kShccXS8ae1APpYTW6yheSwk8Yi4= github.com/getkin/kin-openapi v0.61.0/go.mod h1:7Yn5whZr5kJi6t+kShccXS8ae1APpYTW6yheSwk8Yi4= @@ -342,6 +712,7 @@ github.com/gogo/googleapis v1.1.0/go.mod h1:gf4bu3Q80BeJ6H1S1vYPm8/ELATdvryBaNFG github.com/golang/freetype v0.0.0-20170609003504-e2365dfdc4a0/go.mod h1:E/TSTwGwJL78qG/PmXZO1EjYhfJinVAhrmmHX6Z8B9k= github.com/golang/geo v0.0.0-20190916061304-5b978397cfec/go.mod h1:QZ0nwyI2jOfgRAoBvP+ab5aRr7c9x7lhGEJrKvBwjWI= github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q= +github.com/golang/glog v1.0.0/go.mod h1:EWib/APOK0SL3dFbYqvxE3UYd8E6s1ouQ7iEp/0LWV4= github.com/golang/groupcache v0.0.0-20160516000752-02826c3e7903/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc= github.com/golang/groupcache v0.0.0-20190129154638-5b532d6fd5ef/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc= github.com/golang/groupcache v0.0.0-20190702054246-869f871628b6/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc= @@ -355,6 +726,7 @@ github.com/golang/mock v1.4.1/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt github.com/golang/mock v1.4.3/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt3cw= github.com/golang/mock v1.4.4/go.mod h1:l3mdAwkq5BuhzHwde/uurv3sEJeZMXNpwsxVWU71h+4= github.com/golang/mock v1.5.0/go.mod h1:CWnOUgYIOo4TcNZ0wHX3YZCqsaM1I1Jvs6v3mP3KVu8= +github.com/golang/mock v1.6.0 h1:ErTB+efbowRARo13NNdxyJji2egdxLGQhRaY+DUumQc= github.com/golang/mock v1.6.0/go.mod h1:p6yTPP+5HYm5mzsMV8JkE6ZKdX+/wYM6Hr+LicevLPs= github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= github.com/golang/protobuf v1.3.0/go.mod h1:Qd/q+1AKNOZr9uGQzbzCmRO6sUih6GTPZv6a1/R87v0= @@ -396,8 +768,12 @@ github.com/google/go-cmp v0.5.1/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/ github.com/google/go-cmp v0.5.2/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.3/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= -github.com/google/go-cmp v0.5.5 h1:Khx7svrCpmxxtHBq5j2mp/xVjsi8hQMfNLvJFAlrGgU= github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= +github.com/google/go-cmp v0.5.6/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= +github.com/google/go-cmp v0.5.7/go.mod h1:n+brtR0CgQNWTVd5ZUFpTBC8YFBDLK/h/bpaJ8/DtOE= +github.com/google/go-cmp v0.5.8/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY= +github.com/google/go-cmp v0.5.9 h1:O2Tfq5qg4qc4AmwVlvv0oLiVAGB7enBSJ2x2DqQFi38= +github.com/google/go-cmp v0.5.9/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY= github.com/google/gofuzz v0.0.0-20170612174753-24818f796faf/go.mod h1:HP5RmnzzSNb993RKQDq4+1A4ia9nllfqcQFTQJedwGI= github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg= github.com/google/gofuzz v1.1.1-0.20200604201612-c04b05f3adfa h1:Q75Upo5UN4JbPFURXZ8nLKYUvF85dyFRop/vQ0Rv+64= @@ -405,6 +781,7 @@ github.com/google/gofuzz v1.1.1-0.20200604201612-c04b05f3adfa/go.mod h1:dBl0BpW6 github.com/google/martian v2.1.0+incompatible/go.mod h1:9I4somxYTbIHy5NJKHRl3wXiIaQGbYVAs8BPL6v8lEs= github.com/google/martian/v3 v3.0.0/go.mod h1:y5Zk1BBys9G+gd6Jrk0W3cC1+ELVxBWuIGO+w/tUAp0= github.com/google/martian/v3 v3.1.0/go.mod h1:y5Zk1BBys9G+gd6Jrk0W3cC1+ELVxBWuIGO+w/tUAp0= +github.com/google/martian/v3 v3.2.1/go.mod h1:oBOf6HBosgwRXnUGWUB05QECsc6uvmMiJ3+6W4l/CUk= github.com/google/pprof v0.0.0-20181206194817-3ea8567a2e57/go.mod h1:zfwlbNMJ+OItoe0UupaVj+oy1omPYYDuagoSzA8v9mc= github.com/google/pprof v0.0.0-20190515194954-54271f7e092f/go.mod h1:zfwlbNMJ+OItoe0UupaVj+oy1omPYYDuagoSzA8v9mc= github.com/google/pprof v0.0.0-20191218002539-d4f498aebedc/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM= @@ -414,15 +791,33 @@ github.com/google/pprof v0.0.0-20200430221834-fc25d7d30c6d/go.mod h1:ZgVRPoUq/hf github.com/google/pprof v0.0.0-20200708004538-1a94d8640e99/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM= github.com/google/pprof v0.0.0-20201023163331-3e6fc7fc9c4c/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE= github.com/google/pprof v0.0.0-20201203190320-1bf35d6f28c2/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE= +github.com/google/pprof v0.0.0-20201218002935-b9804c9f04c2/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE= github.com/google/pprof v0.0.0-20210122040257-d980be63207e/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE= github.com/google/pprof v0.0.0-20210226084205-cbba55b83ad5/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE= +github.com/google/pprof v0.0.0-20210601050228-01bbb1931b22/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE= +github.com/google/pprof v0.0.0-20210609004039-a478d1d731e9/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE= +github.com/google/pprof v0.0.0-20210720184732-4bb14d4b1be1/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE= github.com/google/renameio v0.1.0/go.mod h1:KWCgfxg9yswjAJkECMjeO8J8rahYeXnNhOm40UhjYkI= github.com/google/uuid v1.0.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= github.com/google/uuid v1.1.1/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= github.com/google/uuid v1.1.2/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= github.com/google/uuid v1.1.5/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= +github.com/google/uuid v1.3.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= +github.com/googleapis/enterprise-certificate-proxy v0.0.0-20220520183353-fd19c99a87aa/go.mod h1:17drOmN3MwGY7t0e+Ei9b45FFGA3fBs3x36SsCg1hq8= +github.com/googleapis/enterprise-certificate-proxy v0.1.0/go.mod h1:17drOmN3MwGY7t0e+Ei9b45FFGA3fBs3x36SsCg1hq8= +github.com/googleapis/enterprise-certificate-proxy v0.2.0/go.mod h1:8C0jb7/mgJe/9KK8Lm7X9ctZC2t60YyIpYEI16jx0Qg= github.com/googleapis/gax-go/v2 v2.0.4/go.mod h1:0Wqv26UfaUD9n4G6kQubkQ+KchISgw+vpHVxEJEs9eg= github.com/googleapis/gax-go/v2 v2.0.5/go.mod h1:DWXyrwAJ9X0FpwwEdw+IPEYBICEFu5mhpdKc/us6bOk= +github.com/googleapis/gax-go/v2 v2.1.0/go.mod h1:Q3nei7sK6ybPYH7twZdmQpAd1MKb7pfu6SK+H1/DsU0= +github.com/googleapis/gax-go/v2 v2.1.1/go.mod h1:hddJymUZASv3XPyGkUpKj8pPO47Rmb0eJc8R6ouapiM= +github.com/googleapis/gax-go/v2 v2.2.0/go.mod h1:as02EH8zWkzwUoLbBaFeQ+arQaj/OthfcblKl4IGNaM= +github.com/googleapis/gax-go/v2 v2.3.0/go.mod h1:b8LNqSzNabLiUpXKkY7HAR5jr6bIT99EXz9pXxye9YM= +github.com/googleapis/gax-go/v2 v2.4.0/go.mod h1:XOTVJ59hdnfJLIP/dh8n5CGryZR2LxK9wbMD5+iXC6c= +github.com/googleapis/gax-go/v2 v2.5.1/go.mod h1:h6B0KMMFNtI2ddbGJn3T3ZbwkeT6yqEF02fYlzkUCyo= +github.com/googleapis/gax-go/v2 v2.6.0/go.mod h1:1mjbznJAPHFpesgE5ucqfYEscaz5kMdcIDwU/6+DDoY= +github.com/googleapis/gax-go/v2 v2.7.0/go.mod h1:TEop28CZZQ2y+c0VxMUmu1lV+fQx57QpBWsYpwqHJx8= +github.com/googleapis/go-type-adapters v1.0.0/go.mod h1:zHW75FOG2aur7gAO2B+MLby+cLsWGBF62rFAi7WjWO4= +github.com/googleapis/google-cloud-go-testing v0.0.0-20200911160855-bcd43fbb19e8/go.mod h1:dvDLG8qkwmyD9a/MJJN3XJcT3xFxOKAvTZGvuZmac9g= github.com/gopherjs/gopherjs v0.0.0-20181017120253-0766667cb4d1/go.mod h1:wJfORRmW1u3UXTncJ5qlYoELFm8eSnnEO6hX4iZ3EWY= github.com/gordonklaus/ineffassign v0.0.0-20200309095847-7953dde2c7bf/go.mod h1:cuNKsD1zp2v6XfE/orVX2QE1LC+i254ceGcVeDT3pTU= github.com/gorilla/context v1.1.1/go.mod h1:kBGZzfjB9CEq2AlWe17Uuf7NDRt0dE0s8S51q0aT7Yg= @@ -450,6 +845,8 @@ github.com/grpc-ecosystem/grpc-gateway v1.9.0/go.mod h1:vNeuVxBJEsws4ogUvrchl83t github.com/grpc-ecosystem/grpc-gateway v1.9.5/go.mod h1:vNeuVxBJEsws4ogUvrchl83t/GYV9WGTSLVdBhOQFDY= github.com/grpc-ecosystem/grpc-gateway v1.16.0 h1:gmcG1KaJ57LophUzW0Hy8NmPhnMZb4M0+kPpLofRdBo= github.com/grpc-ecosystem/grpc-gateway v1.16.0/go.mod h1:BDjrQk3hbvj6Nolgz8mAMFbcEtjT1g+wF4CSlocrBnw= +github.com/grpc-ecosystem/grpc-gateway/v2 v2.7.0/go.mod h1:hgWBS7lorOAVIJEQMi4ZsPv9hVvWI6+ch50m39Pf2Ks= +github.com/grpc-ecosystem/grpc-gateway/v2 v2.11.3/go.mod h1:o//XUCC/F+yRGJoPO/VU0GSB0f8Nhgmxx0VIRUvaC0w= github.com/gsterjov/go-libsecret v0.0.0-20161001094733-a6f4afe4910c h1:6rhixN/i8ZofjG1Y75iExal34USq5p+wiN1tpie8IrU= github.com/gsterjov/go-libsecret v0.0.0-20161001094733-a6f4afe4910c/go.mod h1:NMPJylDgVpX0MLRlPy15sqSwOFv/U1GZ2m21JhFfek0= github.com/gtank/merlin v0.1.1-0.20191105220539-8318aed1a79f/go.mod h1:T86dnYJhcGOh5BjZFCJWTDeTK7XW8uE+E21Cy/bIQ+s= @@ -459,18 +856,23 @@ github.com/gtank/ristretto255 v0.1.2 h1:JEqUCPA1NvLq5DwYtuzigd7ss8fwbYay9fi4/5uM github.com/gtank/ristretto255 v0.1.2/go.mod h1:Ph5OpO6c7xKUGROZfWVLiJf9icMDwUeIvY4OmlYW69o= github.com/hashicorp/consul/api v1.1.0/go.mod h1:VmuI/Lkw1nC05EYQWNKwWGbkg+FbDBtguAZLlVdkD9Q= github.com/hashicorp/consul/api v1.3.0/go.mod h1:MmDNSzIMUjNpY/mQ398R4bk2FnqQLoPndWW5VkKPlCE= +github.com/hashicorp/consul/api v1.10.1/go.mod h1:XjsvQN+RJGWI2TWy1/kqaE16HrR2J/FWgkYjdZQsX9M= github.com/hashicorp/consul/sdk v0.1.1/go.mod h1:VKf9jXwCTEY1QZP2MOLRhb5i/I/ssyNV1vwHyQBF0x8= github.com/hashicorp/consul/sdk v0.3.0/go.mod h1:VKf9jXwCTEY1QZP2MOLRhb5i/I/ssyNV1vwHyQBF0x8= +github.com/hashicorp/consul/sdk v0.8.0/go.mod h1:GBvyrGALthsZObzUGsfgHZQDXjg4lOjagTIwIR1vPms= github.com/hashicorp/errwrap v1.0.0/go.mod h1:YH+1FKiLXxHSkmPseP+kNlulaMuP3n2brvKWEqk/Jc4= github.com/hashicorp/go-bexpr v0.1.10/go.mod h1:oxlubA2vC/gFVfX1A6JGp7ls7uCDlfJn732ehYYg+g0= github.com/hashicorp/go-cleanhttp v0.5.0/go.mod h1:JpRdi6/HCYpAwUzNwuwqhbovhLtngrth3wmdIIUrZ80= github.com/hashicorp/go-cleanhttp v0.5.1/go.mod h1:JpRdi6/HCYpAwUzNwuwqhbovhLtngrth3wmdIIUrZ80= +github.com/hashicorp/go-hclog v0.12.0/go.mod h1:whpDNt7SSdeAju8AWKIWsul05p54N/39EeqMAyrmvFQ= github.com/hashicorp/go-immutable-radix v1.0.0 h1:AKDB1HM5PWEA7i4nhcpwOrO2byshxBjXVn/J/3+z5/0= github.com/hashicorp/go-immutable-radix v1.0.0/go.mod h1:0y9vanUI8NX6FsYoO3zeMjhV/C5i9g4Q3DwcSNZ4P60= github.com/hashicorp/go-msgpack v0.5.3/go.mod h1:ahLV/dePpqEmjfWmKiqvPkv/twdG7iPBM1vqhUKIvfM= github.com/hashicorp/go-multierror v1.0.0/go.mod h1:dHtQlpGsu+cZNNAkkCN/P3hoUDHhCYQXV3UM06sGGrk= +github.com/hashicorp/go-multierror v1.1.0/go.mod h1:spPvp8C1qA32ftKqdAHm4hHTbPw+vmowP0z+KUhOZdA= github.com/hashicorp/go-retryablehttp v0.5.3/go.mod h1:9B5zBasrRhHXnJnui7y6sL7es7NDiJgTc6Er0maI1Xs= github.com/hashicorp/go-rootcerts v1.0.0/go.mod h1:K6zTfqpRlCUIjkwsN4Z+hiSfzSTQa6eBIzfwKfwNnHU= +github.com/hashicorp/go-rootcerts v1.0.2/go.mod h1:pqUvnprVnM5bf7AOirdbb01K4ccR319Vf4pU3K5EGc8= github.com/hashicorp/go-sockaddr v1.0.0/go.mod h1:7Xibr9yA9JjQq1JpNB2Vw7kxv8xerXegt+ozgdvDeDU= github.com/hashicorp/go-syslog v1.0.0/go.mod h1:qPfqrKkXGihmCqbJM2mZgkZGvKG1dFdvsLplgctolz4= github.com/hashicorp/go-uuid v1.0.0/go.mod h1:6SBZvOh/SIDV7/2o3Jml5SYk/TvGqwFJ/bN7x4byOro= @@ -487,18 +889,24 @@ github.com/hashicorp/hcl v1.0.0 h1:0Anlzjpi4vEasTeNFn2mLJgTSwt0+6sfsiTG8qcWGx4= github.com/hashicorp/hcl v1.0.0/go.mod h1:E5yfLk+7swimpb2L/Alb/PJmXilQ/rhwaUYs4T20WEQ= github.com/hashicorp/logutils v1.0.0/go.mod h1:QIAnNjmIWmVIIkWDTG1z5v++HQmx9WQRO+LraFDTW64= github.com/hashicorp/mdns v1.0.0/go.mod h1:tL+uN++7HEJ6SQLQ2/p+z2pH24WQKWjBPkE0mNTz8vQ= +github.com/hashicorp/mdns v1.0.1/go.mod h1:4gW7WsVCke5TE7EPeYliwHlRUyBtfCwuFwuMg2DmyNY= github.com/hashicorp/memberlist v0.1.3/go.mod h1:ajVTdAv/9Im8oMAAj5G31PhhMCZJV2pPBoIllUwCN7I= +github.com/hashicorp/memberlist v0.2.2/go.mod h1:MS2lj3INKhZjWNqd3N0m3J+Jxf3DAOnAH9VT3Sh9MUE= github.com/hashicorp/serf v0.8.2/go.mod h1:6hOLApaqBFA1NXqRQAsxw9QxuDEvNxSQRwA/JwenrHc= +github.com/hashicorp/serf v0.9.5/go.mod h1:UWDWwZeL5cuWDJdl0C6wrvrUwEqtQ4ZKBKKENpqIUyk= github.com/hdevalence/ed25519consensus v0.0.0-20210204194344-59a8610d2b87 h1:uUjLpLt6bVvZ72SQc/B4dXcPBw4Vgd7soowdRl52qEM= github.com/hdevalence/ed25519consensus v0.0.0-20210204194344-59a8610d2b87/go.mod h1:XGsKKeXxeRr95aEOgipvluMPlgjr7dGlk9ZTWOjcUcg= +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.1.1/go.mod h1:y4ga/t+u+Xwd7CpDgZESaRcWy0I7XMlTMA25ApIH5Jw= +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/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU= github.com/hudl/fargo v1.3.0/go.mod h1:y3CKSmjA+wD2gak7sUSXTAoopbhU08POFhmITJgmKTg= github.com/huin/goupnp v1.0.0/go.mod h1:n9v9KO1tAxYH82qOn+UTIFQDmx5n1Zxd/ClZDMX7Bnc= github.com/huin/goupnp v1.0.2/go.mod h1:0dxJBVBHqTMjIUMkESDTNgOOx/Mw5wYIfyFmdzSamkM= github.com/huin/goutil v0.0.0-20170803182201-1ca381bf3150/go.mod h1:PpLOETDnJ0o3iZrZfqZzyLl6l7F3c6L1oWn7OICBi6o= +github.com/iancoleman/strcase v0.2.0/go.mod h1:iwCmte+B7n89clKwxIoIXy/HfoL7AsD47ZCWhYzw7ho= github.com/ianlancetaylor/demangle v0.0.0-20181102032728-5e5cf60278f6/go.mod h1:aSSvb/t6k1mPoxDqO4vJh6VOCGPwU4O0C2/Eqndh1Sc= github.com/ianlancetaylor/demangle v0.0.0-20200824232613-28f6c0f3b639/go.mod h1:aSSvb/t6k1mPoxDqO4vJh6VOCGPwU4O0C2/Eqndh1Sc= github.com/improbable-eng/grpc-web v0.14.1/go.mod h1:zEjGHa8DAlkoOXmswrNvhUGEYQA9UI7DhrGeHR1DMGU= @@ -584,6 +992,8 @@ github.com/libp2p/go-buffer-pool v0.0.2/go.mod h1:MvaB6xw5vOrDl8rYZGLFdKAuk/hRoR github.com/lightstep/lightstep-tracer-common/golang/gogo v0.0.0-20190605223551-bc2310a04743/go.mod h1:qklhhLq1aX+mtWk9cPHPzaBjWImj5ULL6C7HFJtXQMM= github.com/lightstep/lightstep-tracer-go v0.18.1/go.mod h1:jlF1pusYV4pidLvZ+XD0UBX0ZE6WURAspgAczcDHrL4= github.com/lucasjones/reggen v0.0.0-20180717132126-cdb49ff09d77/go.mod h1:5ELEyG+X8f+meRWHuqUOewBOhvHkl7M76pdGEansxW4= +github.com/lyft/protoc-gen-star v0.6.0/go.mod h1:TGAoBVkt8w7MPG72TrKIu85MIdXwDuzJYeZuUPFPNwA= +github.com/lyft/protoc-gen-star v0.6.1/go.mod h1:TGAoBVkt8w7MPG72TrKIu85MIdXwDuzJYeZuUPFPNwA= github.com/lyft/protoc-gen-validate v0.0.13/go.mod h1:XbGvPuh87YZc5TdIa2/I4pLk0QoUACkjt2znoq26NVQ= github.com/magiconair/properties v1.8.0/go.mod h1:PppfXfuXeibc/6YijjN8zIbojt8czPbwD3XqdrwzmxQ= github.com/magiconair/properties v1.8.1/go.mod h1:PppfXfuXeibc/6YijjN8zIbojt8czPbwD3XqdrwzmxQ= @@ -595,6 +1005,8 @@ github.com/matryer/moq v0.0.0-20190312154309-6cfb0558e1bd/go.mod h1:9ELz6aaclSIG github.com/mattn/go-colorable v0.0.9/go.mod h1:9vuHe8Xs5qXnSaW/c/ABM9alt+Vo+STaOChaDxuIBZU= github.com/mattn/go-colorable v0.1.0/go.mod h1:9vuHe8Xs5qXnSaW/c/ABM9alt+Vo+STaOChaDxuIBZU= github.com/mattn/go-colorable v0.1.2/go.mod h1:U0ppj6V5qS13XJ6of8GYAs25YV2eR4EVcfRqFIhoBtE= +github.com/mattn/go-colorable v0.1.4/go.mod h1:U0ppj6V5qS13XJ6of8GYAs25YV2eR4EVcfRqFIhoBtE= +github.com/mattn/go-colorable v0.1.6/go.mod h1:u6P/XSegPjTcexA+o6vUJrdnUu04hMope9wVRipJSqc= github.com/mattn/go-colorable v0.1.7/go.mod h1:u6P/XSegPjTcexA+o6vUJrdnUu04hMope9wVRipJSqc= github.com/mattn/go-colorable v0.1.8/go.mod h1:u6P/XSegPjTcexA+o6vUJrdnUu04hMope9wVRipJSqc= github.com/mattn/go-ieproxy v0.0.0-20190610004146-91bb50d98149/go.mod h1:31jz6HNzdxOmlERGGEc4v/dMssOfmp2p5bT/okiKFFc= @@ -604,6 +1016,8 @@ github.com/mattn/go-isatty v0.0.4/go.mod h1:M+lRXTBqGeGNdLjl/ufCoiOlB5xdOkqRJdNx github.com/mattn/go-isatty v0.0.5-0.20180830101745-3fb116b82035/go.mod h1:M+lRXTBqGeGNdLjl/ufCoiOlB5xdOkqRJdNxMWT7Zi4= 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.10/go.mod h1:qgIWMr58cqv1PHHyhnkY9lrL7etaEgOFcMEpPG5Rm84= +github.com/mattn/go-isatty v0.0.11/go.mod h1:PhnuNfih5lzO57/f3n+odYbM4JtupLOxQOAqxQCu2WE= github.com/mattn/go-isatty v0.0.12/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Kysco4FUpU= github.com/mattn/go-isatty v0.0.14 h1:yVuAays6BHfxijgZPzw+3Zlu5yQgKGP2/hcQbHb7S9Y= github.com/mattn/go-isatty v0.0.14/go.mod h1:7GGIvUiUoEMVVmxf/4nioHXj79iQHKdU27kJ6hsGG94= @@ -617,11 +1031,13 @@ github.com/mattn/go-tty v0.0.0-20180907095812-13ff1204f104/go.mod h1:XPvLUNfbS4f github.com/matttproud/golang_protobuf_extensions v1.0.1 h1:4hp9jkHxhMHkqkrB3Ix0jegS5sx/RkqARlsWZ6pIwiU= github.com/matttproud/golang_protobuf_extensions v1.0.1/go.mod h1:D8He9yQNgCq6Z5Ld7szi9bcBfOoFv/3dc6xSMkL2PC0= github.com/miekg/dns v1.0.14/go.mod h1:W1PPwlIAgtquWBMBEV9nkV9Cazfe8ScdGz/Lj7v3Nrg= +github.com/miekg/dns v1.1.26/go.mod h1:bPDLeHnStXmXAq1m/Ch/hvfNHr14JKNPMBo3VZKjuso= github.com/mimoo/StrobeGo v0.0.0-20181016162300-f8f6d4d2b643 h1:hLDRPB66XQT/8+wG9WsDpiCvZf1yKO7sz7scAjSlBa0= github.com/mimoo/StrobeGo v0.0.0-20181016162300-f8f6d4d2b643/go.mod h1:43+3pMjjKimDBf5Kr4ZFNGbLql1zKkbImw+fZbw3geM= github.com/minio/highwayhash v1.0.1 h1:dZ6IIu8Z14VlC0VpfKofAhCy74wu/Qb5gcn52yWoz/0= github.com/minio/highwayhash v1.0.1/go.mod h1:BQskDq+xkJ12lmlUUi7U0M5Swg3EWR+dLTk+kldvVxY= github.com/mitchellh/cli v1.0.0/go.mod h1:hNIlj7HEI86fIcpObd7a0FcrxTWetlwJDGcceTlRvqc= +github.com/mitchellh/cli v1.1.0/go.mod h1:xcISNoH86gajksDmfB23e/pu+B+GeFRMYmoHXxx3xhI= github.com/mitchellh/go-homedir v1.0.0/go.mod h1:SfyaCUpYCn1Vlf4IUYiD9fPX4A5wJrkLzIz1N1q0pr0= github.com/mitchellh/go-homedir v1.1.0 h1:lukF9ziXFxDFPkA1vsr5zpc1XuPDn/wFntq5mG+4E0Y= github.com/mitchellh/go-homedir v1.1.0/go.mod h1:SfyaCUpYCn1Vlf4IUYiD9fPX4A5wJrkLzIz1N1q0pr0= @@ -631,8 +1047,9 @@ github.com/mitchellh/iochan v1.0.0/go.mod h1:JwYml1nuB7xOzsp52dPpHFffvOCDupsG0Qu github.com/mitchellh/mapstructure v0.0.0-20160808181253-ca63d7c062ee/go.mod h1:FVVH3fgwuzCH5S8UJGiWEs2h04kUh9fWfEaFds41c1Y= github.com/mitchellh/mapstructure v1.1.2/go.mod h1:FVVH3fgwuzCH5S8UJGiWEs2h04kUh9fWfEaFds41c1Y= github.com/mitchellh/mapstructure v1.3.3/go.mod h1:bFUtVrKA4DC2yAKiSyO/QUcy7e+RRV2QTWOzhPopBRo= -github.com/mitchellh/mapstructure v1.4.1 h1:CpVNEelQCZBooIPDn+AR3NpivK/TIKU8bDxdASFVQag= github.com/mitchellh/mapstructure v1.4.1/go.mod h1:bFUtVrKA4DC2yAKiSyO/QUcy7e+RRV2QTWOzhPopBRo= +github.com/mitchellh/mapstructure v1.4.2 h1:6h7AQ0yhTcIsmFmnAwQls75jp2Gzs4iB8W7pjMO+rqo= +github.com/mitchellh/mapstructure v1.4.2/go.mod h1:bFUtVrKA4DC2yAKiSyO/QUcy7e+RRV2QTWOzhPopBRo= github.com/mitchellh/pointerstructure v1.2.0/go.mod h1:BRAsLI5zgXmw97Lf6s25bs8ohIXc3tViBH44KcwB2g4= 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= @@ -703,8 +1120,9 @@ github.com/paulbellamy/ratecounter v0.2.0/go.mod h1:Hfx1hDpSGoqxkVVpBi/IlYD7kChl github.com/pborman/uuid v0.0.0-20170112150404-1b00554d8222/go.mod h1:VyrYX9gd7irzKovcSS6BIIEwPRkP2Wm2m9ufcdFSJ34= github.com/pborman/uuid v1.2.0/go.mod h1:X/NO0urCmaxf9VXbdlT7C2Yzkj2IKimNn4k+gtPdI/k= github.com/pelletier/go-toml v1.2.0/go.mod h1:5z9KED0ma1S8pY6P1sdut58dfprrGBbd/94hg7ilaic= -github.com/pelletier/go-toml v1.9.3 h1:zeC5b1GviRUyKYd6OJPvBU/mcVDVoL1OhT17FCt5dSQ= github.com/pelletier/go-toml v1.9.3/go.mod h1:u1nR/EPcESfeI/szUZKdtJ0xRNbUoANCkoOuaOx1Y+c= +github.com/pelletier/go-toml v1.9.4 h1:tjENF6MfZAg8e4ZmZTeWaWiT2vXtsoO6+iuOjFhECwM= +github.com/pelletier/go-toml v1.9.4/go.mod h1:u1nR/EPcESfeI/szUZKdtJ0xRNbUoANCkoOuaOx1Y+c= github.com/performancecopilot/speed v3.0.0+incompatible/go.mod h1:/CLtqpZ5gBg1M9iaPbIdPPGyKcA8hKdoy6hAWba7Yac= github.com/peterh/liner v1.0.1-0.20180619022028-8c1271fcf47f/go.mod h1:xIteQHvHuaLYG9IFj6mSxM0fCKrs34IrEQUhOYuGPHc= github.com/peterh/liner v1.1.1-0.20190123174540-a2c9a5303de7/go.mod h1:CRroGNssyjTd/qIG2FyxByd2S8JEAZXBl4qUrZf8GS0= @@ -719,10 +1137,12 @@ github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4= github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= github.com/pkg/profile v1.2.1/go.mod h1:hJw3o1OdXxsrSjjVksARp5W95eeEaEfptyVZyv6JUPA= github.com/pkg/sftp v1.10.1/go.mod h1:lYOWFsE0bwd1+KfKJaKeuokY15vzFx25BLbzYYoAxZI= +github.com/pkg/sftp v1.13.1/go.mod h1:3HaPG6Dq1ILlpPZRO0HVMrsydcdLt6HRDccSgb87qRg= github.com/pkg/term v0.0.0-20180730021639-bffc007b7fd5/go.mod h1:eCbImbZ95eXtAUIbLAuAVnBnwf83mjf6QIVH8SHYwqQ= 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/posener/complete v1.1.1/go.mod h1:em0nMJCgc9GFtwrmVmEMR/ZL6WyhyjMBndrE9hABlRI= +github.com/posener/complete v1.2.3/go.mod h1:WZIdtGGp+qx0sLrYKtIRAruyNpv6hFCicSgv7Sy7s/s= github.com/prometheus/client_golang v0.9.1/go.mod h1:7SWBe2y4D6OKWSNQJUaRYU/AaXPKyh/dDVn+NZz0KFw= github.com/prometheus/client_golang v0.9.3-0.20190127221311-3c4408c8b829/go.mod h1:p2iRAGwDERtqlqzRXnrOVns+ignqQo//hLXqYxZYVNs= github.com/prometheus/client_golang v0.9.3/go.mod h1:/TN21ttK/J9q6uSwhBd54HahCDft0ttaMvbicHlPoso= @@ -790,6 +1210,7 @@ github.com/rs/zerolog v1.23.0/go.mod h1:6c7hFfxPOy7TacJc4Fcdi24/J0NKYGzjG8FWRI91 github.com/russross/blackfriday v1.5.2/go.mod h1:JO/DiYxRf+HjHt06OyowR9PTA263kcR/rfWxYHBV53g= github.com/russross/blackfriday/v2 v2.0.1/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM= github.com/ryanuber/columnize v0.0.0-20160712163229-9b3edd62028f/go.mod h1:sm1tb6uqfes/u+d4ooFouqFdy9/2g9QGwK3SQygK0Ts= +github.com/sagikazarmark/crypt v0.1.0/go.mod h1:B/mN0msZuINBtQ1zZLEQcegFJJf9vnYIR88KRMEuODE= github.com/samuel/go-zookeeper v0.0.0-20190923202752-2cc03de413da/go.mod h1:gi+0XIa01GRL2eRQVjQkKGqKF3SF9vZR/HnPullcV2E= github.com/sasha-s/go-deadlock v0.2.0 h1:lMqc+fUb7RrFS3gQLtoQsJ7/6TV/pAIFvBsqX73DK8Y= github.com/sasha-s/go-deadlock v0.2.0/go.mod h1:StQn567HiB1fF2yJ44N9au7wOhrPS3iZqiDbRupzT10= @@ -816,11 +1237,14 @@ github.com/spaolacci/murmur3 v0.0.0-20180118202830-f09979ecbc72/go.mod h1:JwIasO github.com/spaolacci/murmur3 v1.1.0 h1:7c1g84S4BPRrfL5Xrdp6fOJ206sU9y293DDHaoy0bLI= github.com/spaolacci/murmur3 v1.1.0/go.mod h1:JwIasOWyU6f++ZhiEuf87xNszmSA2myDM2Kzu9HwQUA= github.com/spf13/afero v1.1.2/go.mod h1:j4pytiNVoe2o6bmDsKpLACNPDBIoEAkihy7loJ1B0CQ= -github.com/spf13/afero v1.6.0 h1:xoax2sJ2DT8S8xA2paPFjDCScCNeWsg75VG0DLRreiY= +github.com/spf13/afero v1.3.3/go.mod h1:5KUK8ByomD5Ti5Artl0RtHeI5pTF7MIDuXL3yY520V4= github.com/spf13/afero v1.6.0/go.mod h1:Ai8FlHk4v/PARR026UzYexafAt9roJ7LcLMAmO6Z93I= +github.com/spf13/afero v1.9.2 h1:j49Hj62F0n+DaZ1dDCvhABaPNSGNkt32oRFxI33IEMw= +github.com/spf13/afero v1.9.2/go.mod h1:iUV7ddyEEZPO5gA3zD4fJt6iStLlL+Lg4m2cihcDf8Y= github.com/spf13/cast v1.3.0/go.mod h1:Qx5cxh0v+4UWYiBimWS+eyWzqEqokIECu5etghLkUJE= -github.com/spf13/cast v1.3.1 h1:nFm6S0SMdyzrzcmThSipiEubIDy8WEXKNZ0UOgiRpng= github.com/spf13/cast v1.3.1/go.mod h1:Qx5cxh0v+4UWYiBimWS+eyWzqEqokIECu5etghLkUJE= +github.com/spf13/cast v1.4.1 h1:s0hze+J0196ZfEMTs80N7UlFt0BDuQ7Q+JDnHiMWKdA= +github.com/spf13/cast v1.4.1/go.mod h1:Qx5cxh0v+4UWYiBimWS+eyWzqEqokIECu5etghLkUJE= github.com/spf13/cobra v0.0.3/go.mod h1:1l0Ry5zgKvJasoi3XT1TypsSe7PqH0Sj9dhYf7v3XqQ= github.com/spf13/cobra v0.0.5/go.mod h1:3K3wKZymM7VvHMDS9+Akkh4K60UwM26emMESw8tLCHU= github.com/spf13/cobra v1.1.1/go.mod h1:WnodtKOvamDL/PwE2M4iKs8aMDBZ5Q5klgD3qfVJQMI= @@ -836,8 +1260,9 @@ github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An github.com/spf13/viper v1.3.2/go.mod h1:ZiWeW+zYFKm7srdB9IoDzzZXaJaI5eL9QjNiN/DMA2s= github.com/spf13/viper v1.7.0/go.mod h1:8WkrPz2fc9jxqZNCJI/76HCieCp4Q8HaLFoCha5qpdg= github.com/spf13/viper v1.7.1/go.mod h1:8WkrPz2fc9jxqZNCJI/76HCieCp4Q8HaLFoCha5qpdg= -github.com/spf13/viper v1.8.1 h1:Kq1fyeebqsBfbjZj4EL7gj2IO0mMaiyjYUWcUsl2O44= github.com/spf13/viper v1.8.1/go.mod h1:o0Pch8wJ9BVSWGQMbra6iw0oQ5oktSIBaujf1rJH9Ns= +github.com/spf13/viper v1.9.0 h1:yR6EXjTp0y0cLN8OZg1CRZmOBdI88UcGkhgyJhu6nZk= +github.com/spf13/viper v1.9.0/go.mod h1:+i6ajR7OX2XaiBkrcZJFK21htRk7eDeLg7+O6bhUPP4= github.com/status-im/keycard-go v0.0.0-20190316090335-8537d3370df4/go.mod h1:RZLeN1LMWmRsyYjvAu+I6Dm9QmlDaIIt+Y+4Kd7Tp+Q= github.com/steakknife/bloomfilter v0.0.0-20180922174646-6819c0d2a570/go.mod h1:8OR4w3TdeIHIh1g6EMY5p0gVNOovcWC+1vpc7naMuAw= github.com/steakknife/hamming v0.0.0-20180906055917-c99c65617cd3/go.mod h1:hpGUWaI9xL8pRQCTXQgocU38Qw1g0Us7n5PxxTwTCYU= @@ -846,16 +1271,21 @@ github.com/streadway/amqp v0.0.0-20190827072141-edfb9018d271/go.mod h1:AZpEONHx3 github.com/streadway/handy v0.0.0-20190108123426-d5acb3125c2a/go.mod h1:qNTQ5P5JnDBl6z3cMAg/SywNDC5ABu5ApDIw6lUbRmI= github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= -github.com/stretchr/objx v0.2.0 h1:Hbg2NidpLE8veEBkEZTL3CvlkUIVzuU9jDplZO54c48= github.com/stretchr/objx v0.2.0/go.mod h1:qt09Ya8vawLte6SNmTgCsAVtYtaKzEcn8ATUoHMkEqE= +github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw= +github.com/stretchr/objx v0.5.0 h1:1zr/of2m5FGMsad5YfcqgdqdWrIhu+EBEJRhR1U7z/c= +github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo= github.com/stretchr/testify v1.2.0/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs= 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.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= -github.com/stretchr/testify v1.7.0 h1:nwc3DEeHmmLAfoZucVR881uASk0Mfjw8xYJ99tb5CcY= github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= +github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= +github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU= +github.com/stretchr/testify v1.8.1 h1:w7B6lhMri9wdJUVmEZPGGhZzrYTPvgJArz7wNPgYKsk= +github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4= github.com/subosito/gotenv v1.2.0 h1:Slr1R9HxAlEKefgq5jn9U+DnETlIUa6HfgEzj0g5d7s= github.com/subosito/gotenv v1.2.0/go.mod h1:N0PQaV/YGNqwC0u51sEeR/aUtSLEXKX9iv69rRypqCw= github.com/syndtr/goleveldb v1.0.1-0.20200815110645-5c35d600f0ca/go.mod h1:u2MKkTVTVJWe5D1rCvame8WqhBd88EuIwODJZ1VHCPM= @@ -879,10 +1309,12 @@ github.com/tidwall/sjson v1.1.4/go.mod h1:wXpKXu8CtDjKAZ+3DrKY5ROCorDFahq8l0tey/ github.com/tinylib/msgp v1.0.2/go.mod h1:+d+yLhGm8mzTaHzB+wgMYrodPfmZrzkirds8fDWklFE= github.com/tjfoc/gmsm v1.4.0 h1:8nbaiZG+iVdh+fXVw0DZoZZa7a4TGm3Qab+xdrdzj8s= github.com/tjfoc/gmsm v1.4.0/go.mod h1:j4INPkHWMrhJb38G+J6W4Tw0AbuN8Thu3PbdVYhVcTE= -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/go-sysconf v0.3.7 h1:HT7h4+536gjqeq1ZIJPgOl1rg1XFatQGVZWp7Py53eg= +github.com/tklauser/go-sysconf v0.3.7/go.mod h1:JZIdXh4RmBvZDBZ41ld2bGxRV3n4daiiqA3skYhAoQ4= github.com/tklauser/numcpus v0.2.2/go.mod h1:x3qojaO3uyYt0i56EW/VUYs7uBvdl2fkfZFu0T9wgjM= +github.com/tklauser/numcpus v0.2.3 h1:nQ0QYpiritP6ViFhrKYsiv6VVxOpum2Gks5GhnJbS/8= +github.com/tklauser/numcpus v0.2.3/go.mod h1:vpEPS/JC+oZGGQ/My/vJnNsvMDQL6PwOqt8dsCw5j+E= github.com/tmc/grpc-websocket-proxy v0.0.0-20170815181823-89b8d40f7ca8/go.mod h1:ncp9v5uamzpCO7NfCPTXjqaC+bZgJeR0sMTm6dMHP7U= github.com/tmc/grpc-websocket-proxy v0.0.0-20190109142713-0ad062ec5ee5/go.mod h1:ncp9v5uamzpCO7NfCPTXjqaC+bZgJeR0sMTm6dMHP7U= github.com/tv42/httpunix v0.0.0-20150427012821-b75d8614f926/go.mod h1:9ESjWnEqriFuLhtthL60Sar/7RFoluCcXsuvEwTV5KM= @@ -910,12 +1342,14 @@ github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9de github.com/yuin/goldmark v1.1.32/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= +github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY= github.com/zondax/hid v0.9.0 h1:eiT3P6vNxAEVxXMw66eZUAAnU2zD33JBkfG/EnfAKl8= github.com/zondax/hid v0.9.0/go.mod h1:l5wttcP0jwtdLjqjMMWFVEE7d1zO0jvSPA9OPZxWpEM= go.etcd.io/bbolt v1.3.2/go.mod h1:IbVyRI1SCnLcuJnV2u8VeU0CEYM7e686BmAb1XKL+uU= go.etcd.io/bbolt v1.3.3/go.mod h1:IbVyRI1SCnLcuJnV2u8VeU0CEYM7e686BmAb1XKL+uU= -go.etcd.io/bbolt v1.3.5 h1:XAzx9gjCb0Rxj7EoqcClPD1d5ZBxZJk0jbuoPHenBt0= go.etcd.io/bbolt v1.3.5/go.mod h1:G5EMThwa9y8QZGBClrRx5EY+Yw9kAhnjy3bSjsnlVTQ= +go.etcd.io/bbolt v1.3.6 h1:/ecaJf0sk1l4l6V4awd65v2C3ILy7MSj+s/x1ADCIMU= +go.etcd.io/bbolt v1.3.6/go.mod h1:qXsaaIqmgQH0T+OPdb99Bf+PKfBBQVAdyD6TY9G8XM4= go.etcd.io/etcd v0.0.0-20191023171146-3cf2f69b5738/go.mod h1:dnLIgRNXwCJa5e+c6mIZCrds/GIG4ncV9HhK5PX7jPg= go.etcd.io/etcd/api/v3 v3.5.0/go.mod h1:cbVKeC6lCfl7j/8jBhAK6aIYO9XOjdptoxU/nLQcPvs= go.etcd.io/etcd/client/pkg/v3 v3.5.0/go.mod h1:IJHfcCEKxYu1Os13ZdwCwIUTUVGYTSAM3YSwc9/Ac1g= @@ -929,7 +1363,9 @@ go.opencensus.io v0.22.3/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw= go.opencensus.io v0.22.4/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw= go.opencensus.io v0.22.5/go.mod h1:5pWMHQbX5EPX2/62yrJeAkowc+lfs/XD7Uxpq3pI6kk= go.opencensus.io v0.23.0/go.mod h1:XItmlyltB5F7CS4xOC1DcqMoFqwtC6OG2xF7mCv7P7E= +go.opencensus.io v0.24.0/go.mod h1:vNK8G9p7aAivkbmorf4v+7Hgx+Zs0yY+0fOtgBfjQKo= go.opentelemetry.io/proto/otlp v0.7.0/go.mod h1:PqfVotwruBrMGOCsRd/89rSnXhoiJIqeYNgFYFoEGnI= +go.opentelemetry.io/proto/otlp v0.15.0/go.mod h1:H7XAot3MsfNsj7EXtrA2q5xSNQ10UqI405h3+duxN4U= go.uber.org/atomic v1.3.2/go.mod h1:gD2HeocX3+yG+ygLZcrzQJaqmWj9AIm7n08wl/qW/PE= go.uber.org/atomic v1.4.0/go.mod h1:gD2HeocX3+yG+ygLZcrzQJaqmWj9AIm7n08wl/qW/PE= go.uber.org/atomic v1.5.0/go.mod h1:sABNBOSYdrvTF6hTgEIbc7YasKWGhgEQZyfxyTvoXHQ= @@ -953,6 +1389,7 @@ golang.org/x/crypto v0.0.0-20190605123033-f99c8df09eb5/go.mod h1:yigFU9vqHzYiE8U golang.org/x/crypto v0.0.0-20190701094942-4def268fd1a4/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= golang.org/x/crypto v0.0.0-20190820162420-60c769a6c586/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= golang.org/x/crypto v0.0.0-20190909091759-094676da4a83/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= +golang.org/x/crypto v0.0.0-20190923035154-9ee001bba392/go.mod h1:/lpIB1dKB+9EgE3H3cr1v9wB50oz8l4C4h62xy7jSTY= golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= golang.org/x/crypto v0.0.0-20191206172530-e9b2fee46413/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= golang.org/x/crypto v0.0.0-20200115085410-6d4e4cb37c7d/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= @@ -966,9 +1403,13 @@ golang.org/x/crypto v0.0.0-20201016220609-9e8e0b390897/go.mod h1:LzIPMQfyMNhhGPh golang.org/x/crypto v0.0.0-20201117144127-c1f2f97bffc9/go.mod h1:jdWPYTVW3xRLrWPugEBEK3UY2ZEsg3UU495nc5E+M+I= golang.org/x/crypto v0.0.0-20201221181555-eec23a3978ad/go.mod h1:jdWPYTVW3xRLrWPugEBEK3UY2ZEsg3UU495nc5E+M+I= golang.org/x/crypto v0.0.0-20210322153248-0c34fe9e7dc2/go.mod h1:T9bdIzuCu7OtxOm1hfPfRQxPLYneinmdGuTeoZ9dtd4= +golang.org/x/crypto v0.0.0-20210421170649-83a5a9bb288b/go.mod h1:T9bdIzuCu7OtxOm1hfPfRQxPLYneinmdGuTeoZ9dtd4= golang.org/x/crypto v0.0.0-20210513164829-c07d793c2f9a/go.mod h1:P+XmwS30IXTQdn5tA2iutPOUgjI07+tq3H3K9MVA1s8= -golang.org/x/crypto v0.0.0-20211115234514-b4de73f9ece8 h1:5QRxNnVsaJP6NAse0UdkRgL3zHMvCRRkrDVLNdNpdy4= -golang.org/x/crypto v0.0.0-20211115234514-b4de73f9ece8/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc= +golang.org/x/crypto v0.0.0-20210817164053-32db794688a5/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc= +golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc= +golang.org/x/crypto v0.0.0-20211108221036-ceb1ce70b4fa/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-20180321215751-8460e604b9de/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= golang.org/x/exp v0.0.0-20180807140117-3d87b88a115f/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= @@ -1012,6 +1453,9 @@ golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= golang.org/x/mod v0.4.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= golang.org/x/mod v0.4.1/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= +golang.org/x/mod v0.5.0/go.mod h1:5OXOZSfqPIIbmVBIIKWRFfZjPR0E5r58TLhUjH0a2Ro= +golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4= +golang.org/x/mod v0.7.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs= golang.org/x/net v0.0.0-20180719180050-a680a1efc54d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= 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= @@ -1034,6 +1478,7 @@ golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLL golang.org/x/net v0.0.0-20190628185345-da137c7871d7/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.0.0-20190724013045-ca1201d0de80/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.0.0-20190813141303-74dc4d7220e7/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20190923162816-aa69164e4478/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-20200114155413-6afb5195e5aa/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.0.0-20200202094626-16171245cfb2/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= @@ -1057,15 +1502,34 @@ golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwY golang.org/x/net v0.0.0-20201031054903-ff519b6c9102/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= golang.org/x/net v0.0.0-20201110031124-69a78807bb2b/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= golang.org/x/net v0.0.0-20201209123823-ac852fbbde11/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= +golang.org/x/net v0.0.0-20201224014010-6772e930b67b/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= golang.org/x/net v0.0.0-20210119194325-5f4716e94777/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= golang.org/x/net v0.0.0-20210220033124-5f55cee0dc0d/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= golang.org/x/net v0.0.0-20210316092652-d523dce5a7f4/go.mod h1:RBQZq4jEuRlivfhVLdyRGr576XBO4/greRjx4P4O3yc= golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM= golang.org/x/net v0.0.0-20210428140749-89ef3d95e781/go.mod h1:OJAsFXCWl8Ukc7SiCT/9KSuxbyM7479/AVlXFRxuMCk= +golang.org/x/net v0.0.0-20210503060351-7fd8e65b6420/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= golang.org/x/net v0.0.0-20210525063256-abc453219eb5/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= -golang.org/x/net v0.0.0-20210805182204-aaa1db679c0d h1:20cMwl2fHAzkJMEA+8J4JgqBQcQGzbisXo31MIeenXI= golang.org/x/net v0.0.0-20210805182204-aaa1db679c0d/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= +golang.org/x/net v0.0.0-20210813160813-60bc85c4be6d/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= +golang.org/x/net v0.0.0-20220127200216-cd36cc0744dd/go.mod h1:CfG3xpIq0wQ8r1q4Su4UZFWDARRcnwPjda9FqA0JpMk= +golang.org/x/net v0.0.0-20220225172249-27dd8689420f/go.mod h1:CfG3xpIq0wQ8r1q4Su4UZFWDARRcnwPjda9FqA0JpMk= +golang.org/x/net v0.0.0-20220325170049-de3da57026de/go.mod h1:CfG3xpIq0wQ8r1q4Su4UZFWDARRcnwPjda9FqA0JpMk= +golang.org/x/net v0.0.0-20220412020605-290c469a71a5/go.mod h1:CfG3xpIq0wQ8r1q4Su4UZFWDARRcnwPjda9FqA0JpMk= +golang.org/x/net v0.0.0-20220425223048-2871e0cb64e4/go.mod h1:CfG3xpIq0wQ8r1q4Su4UZFWDARRcnwPjda9FqA0JpMk= +golang.org/x/net v0.0.0-20220607020251-c690dde0001d/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c= +golang.org/x/net v0.0.0-20220617184016-355a448f1bc9/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c= +golang.org/x/net v0.0.0-20220624214902-1bab6f366d9e/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c= +golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c= +golang.org/x/net v0.0.0-20220909164309-bea034e7d591/go.mod h1:YDH+HFinaLZZlnHAfSS6ZXJJ9M9t4Dl22yv3iI2vPwk= +golang.org/x/net v0.0.0-20221012135044-0b7e1fb9d458/go.mod h1:YDH+HFinaLZZlnHAfSS6ZXJJ9M9t4Dl22yv3iI2vPwk= +golang.org/x/net v0.0.0-20221014081412-f15817d10f9b/go.mod h1:YDH+HFinaLZZlnHAfSS6ZXJJ9M9t4Dl22yv3iI2vPwk= +golang.org/x/net v0.1.0/go.mod h1:Cx3nUiGt4eDBEyega/BKRp+/AlGL8hYe7U9odMt2Cco= +golang.org/x/net v0.2.0/go.mod h1:KqCZLdyyvdV855qA2rE3GC2aiw5xGR5TEjj8smXukLY= +golang.org/x/net v0.5.0/go.mod h1:DivGGAXEgPSlEBzxGzZI+ZLohi+xUj054jfeKui00ws= +golang.org/x/net v0.6.0 h1:L4ZwwTvKW9gr0ZMS1yrHD9GZhIuVjOBBnaKH+SPQK0Q= +golang.org/x/net v0.6.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs= golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U= golang.org/x/oauth2 v0.0.0-20190226205417-e64efc72b421/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= golang.org/x/oauth2 v0.0.0-20190604053449-0f29369cfe45/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= @@ -1079,6 +1543,20 @@ golang.org/x/oauth2 v0.0.0-20210220000619-9bb904979d93/go.mod h1:KelEdhl1UZF7XfJ golang.org/x/oauth2 v0.0.0-20210313182246-cd4f82c27b84/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= golang.org/x/oauth2 v0.0.0-20210402161424-2e8d93401602/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= golang.org/x/oauth2 v0.0.0-20210514164344-f6687ab2804c/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= +golang.org/x/oauth2 v0.0.0-20210628180205-a41e5a781914/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= +golang.org/x/oauth2 v0.0.0-20210805134026-6f1e6394065a/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= +golang.org/x/oauth2 v0.0.0-20210819190943-2bc19b11175f/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= +golang.org/x/oauth2 v0.0.0-20211104180415-d3ed0bb246c8/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= +golang.org/x/oauth2 v0.0.0-20220223155221-ee480838109b/go.mod h1:DAh4E804XQdzx2j+YRIaUnCqCV2RuMz24cGBJ5QYIrc= +golang.org/x/oauth2 v0.0.0-20220309155454-6242fa91716a/go.mod h1:DAh4E804XQdzx2j+YRIaUnCqCV2RuMz24cGBJ5QYIrc= +golang.org/x/oauth2 v0.0.0-20220411215720-9780585627b5/go.mod h1:DAh4E804XQdzx2j+YRIaUnCqCV2RuMz24cGBJ5QYIrc= +golang.org/x/oauth2 v0.0.0-20220608161450-d0670ef3b1eb/go.mod h1:jaDAt6Dkxork7LmZnYtzbRWj0W47D86a3TGe0YHBvmE= +golang.org/x/oauth2 v0.0.0-20220622183110-fd043fe589d2/go.mod h1:jaDAt6Dkxork7LmZnYtzbRWj0W47D86a3TGe0YHBvmE= +golang.org/x/oauth2 v0.0.0-20220822191816-0ebed06d0094/go.mod h1:h4gKUeWbJ4rQPri7E0u6Gs4e9Ri2zaLxzw5DI5XGrYg= +golang.org/x/oauth2 v0.0.0-20220909003341-f21342109be1/go.mod h1:h4gKUeWbJ4rQPri7E0u6Gs4e9Ri2zaLxzw5DI5XGrYg= +golang.org/x/oauth2 v0.0.0-20221006150949-b44042a4b9c1/go.mod h1:h4gKUeWbJ4rQPri7E0u6Gs4e9Ri2zaLxzw5DI5XGrYg= +golang.org/x/oauth2 v0.0.0-20221014153046-6fdb5e3db783/go.mod h1:h4gKUeWbJ4rQPri7E0u6Gs4e9Ri2zaLxzw5DI5XGrYg= +golang.org/x/oauth2 v0.4.0/go.mod h1:RznEsdpjGAINPTOF0UH/t+xJ75L18YO3Ho6Pyn+uRec= 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= @@ -1090,6 +1568,10 @@ golang.org/x/sync v0.0.0-20200625203802-6e8e738ad208/go.mod h1:RxMgew5VJxzue5/jJ golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20201207232520-09787c993a3a/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.0.0-20220601150217-0de741cfad7f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20220929204114-8fcdb60fdcc0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sys v0.0.0-20180823144017-11551d06cbcc/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20180905080454-ebe1bf3edb33/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= @@ -1115,8 +1597,11 @@ golang.org/x/sys v0.0.0-20190726091711-fc99dfbffb4e/go.mod h1:h1NjWce9XRLGQEsW7w golang.org/x/sys v0.0.0-20190813064441-fde4db37ae7a/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20190826190057-c7b8b68b1456/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20190904154756-749cb33beabd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20190922100055-0a153f010e69/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20190924154521-2837fb4f24fe/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20191001151750-bb3f8db39f24/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20191005200804-aed5e4c7ecf9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20191008105621-543471e840be/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20191026070338-33540a1f6037/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20191120155948-bd437916bb0e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20191204072324-ce4227a45e2e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= @@ -1127,6 +1612,7 @@ golang.org/x/sys v0.0.0-20200107162124-548cf772de50/go.mod h1:h1NjWce9XRLGQEsW7w golang.org/x/sys v0.0.0-20200113162924-86b910548bc1/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200116001909-b77594299b42/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200122134326-e047566fdf82/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200124204421-9fbb57f87de9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200202164722-d101bd2416d5/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200212091648-12a6c2dcc1e4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200223170610-d5e6a3e2c0ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= @@ -1147,6 +1633,7 @@ golang.org/x/sys v0.0.0-20200824131525-c12d262b63d8/go.mod h1:h1NjWce9XRLGQEsW7w golang.org/x/sys v0.0.0-20200826173525-f9321e4c35a6/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200905004654-be1d3432aa8f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200909081042-eff7692f9009/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200923182605-d9f96fdee20d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20201015000850-e3ed0017c211/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= @@ -1156,6 +1643,7 @@ golang.org/x/sys v0.0.0-20210112080510-489259a85091/go.mod h1:h1NjWce9XRLGQEsW7w golang.org/x/sys v0.0.0-20210119212857-b64e53b001e4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210124154548-22da62e12c0c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210220050731-9a76102bfb43/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210225134936-a50acf3fe073/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210305230114-8fe3ee5dd75b/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210315160823-c6e025ad8005/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210316164454-77fc1eacc6aa/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= @@ -1165,15 +1653,47 @@ golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/go.mod h1:h1NjWce9XRLGQEsW7w golang.org/x/sys v0.0.0-20210403161142-5e06dd20ab57/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210420205809-ac73e9fd8988/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210423185535-09eb48e85fd7/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-20210514084401-e8d321eab015/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20210603081109-ebe580a85c40/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20210603125802-9665404d3644/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-20210616094352-59db8d763f22/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-20210816183151-1e6c022a8912 h1:uCLL3g5wH2xjxVREVuAbP9JM5PPKjRbXKRa6IBjkzmU= +golang.org/x/sys v0.0.0-20210806184541-e5e7981a1069/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20210816183151-1e6c022a8912/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20210823070655-63515b42dcdf/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20210908233432-aa78b53d3365/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20211124211545-fe61309f8881/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20211210111614-af8b64212486/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20211216021012-1d35b9e2eb4e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220128215802-99c3d69c2c27/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220209214540-3681064d5158/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220227234510-4e6760a101f9/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220328115105-d36c6a25d886/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220412211240-33da011f77ad/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220502124256-b6088ccd6cba/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220503163025-988cb79eb6c6/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220610221304-9f5ed59c137d/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220615213510-4f61da869c0c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220624220833-87e55d714810/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220728004956-3c1f35247d10/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.1.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.2.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.4.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.5.0 h1:MUK/U/4lj1t1oPg0HfuXDN/Z1wv31ZJ/YcPiGccS4DU= +golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/term v0.0.0-20201117132131-f5c789dd3221/go.mod h1:Nr5EML6q2oocZ2LXRh80K7BxOlk5/8JxuGnuhpl+muw= -golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1 h1:v+OssWQX+hTHEmOBgwxdZxK4zHq3yOs8F9J7mk0PY8E= golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= +golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8= +golang.org/x/term v0.1.0/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8= +golang.org/x/term v0.2.0/go.mod h1:TVmDHMZPmdnySmBfhjOoOdhjzdE1h4u1VwSiw2l1Nuc= +golang.org/x/term v0.4.0/go.mod h1:9P2UbLfCdcvo3p/nzKvsmas4TnlujnuoV9hGgYzW1lQ= +golang.org/x/term v0.5.0 h1:n2a8QNdAb0sZNpU9R1ALUXBbY+w51fCQDN+7EdxNBsY= +golang.org/x/term v0.5.0/go.mod h1:jMB1sMXY+tzblOD4FWmEbocvup2/aLOaQEp7JmGp78k= golang.org/x/text v0.0.0-20170915032832-14c0d48ead0c/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.1-0.20180807135948-17ff2d5776d2/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= @@ -1181,14 +1701,21 @@ 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.4/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= golang.org/x/text v0.3.5/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= -golang.org/x/text v0.3.6 h1:aRYxNxv6iGQlyVaZmk6ZgYEDa+Jg18DxebPSrd6bg1M= 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.3.8/go.mod h1:E6s5w1FMmriuDzIBO73fBruAKo1PCIq6d2Q6DHfQ8WQ= +golang.org/x/text v0.4.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8= +golang.org/x/text v0.6.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8= +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-20180412165947-fbb02b2291d2/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= golang.org/x/time v0.0.0-20181108054448-85acf8d2951c/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= golang.org/x/time v0.0.0-20190308202827-9d24e82272b4/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= golang.org/x/time v0.0.0-20191024005414-555d28b269f0/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= golang.org/x/time v0.0.0-20201208040808-7e3f01d25324/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= golang.org/x/time v0.0.0-20210220033141-f8bda1e9f3ba/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= +golang.org/x/time v0.0.0-20220922220347-f3bd1da661af/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= +golang.org/x/time v0.1.0/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= golang.org/x/tools v0.0.0-20180525024113-a5b4c53f6e8b/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= golang.org/x/tools v0.0.0-20180828015842-6cd1fcedba52/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= @@ -1207,6 +1734,7 @@ golang.org/x/tools v0.0.0-20190606124116-d0a3d012864b/go.mod h1:/rFqwRUd4F7ZHNgw golang.org/x/tools v0.0.0-20190621195816-6e04913cbbac/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc= golang.org/x/tools v0.0.0-20190628153133-6cdbf07be9d0/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc= golang.org/x/tools v0.0.0-20190816200558-6889da9d5479/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.0.0-20190907020128-2ca718005c18/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= golang.org/x/tools v0.0.0-20190911174233-4f2ddba30aff/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= golang.org/x/tools v0.0.0-20191012152004-8de300cfc20a/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= golang.org/x/tools v0.0.0-20191029041327-9cc4af7d6b2c/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= @@ -1249,14 +1777,23 @@ golang.org/x/tools v0.0.0-20201201161351-ac6f37ff4c2a/go.mod h1:emZCQorbCU4vsT4f golang.org/x/tools v0.0.0-20201208233053-a543418bbed2/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= golang.org/x/tools v0.0.0-20201224043029-2b0845dc783e/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= golang.org/x/tools v0.0.0-20210105154028-b0ab187a4818/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= +golang.org/x/tools v0.0.0-20210108195828-e2f9c7f1fc8e/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= golang.org/x/tools v0.1.0/go.mod h1:xkSsbof2nBLbhDlRMhhhyNLN/zl3eTqcnHD5viDpcZ0= golang.org/x/tools v0.1.1/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk= golang.org/x/tools v0.1.2/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk= +golang.org/x/tools v0.1.3/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk= +golang.org/x/tools v0.1.4/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk= +golang.org/x/tools v0.1.5/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk= +golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc= +golang.org/x/tools v0.3.0/go.mod h1:/rWhSS2+zyEVwoJf8YAX6L2f0ntZ7Kn/mGgAWcipA5k= 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-20220411194840-2f41105eb62f/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +golang.org/x/xerrors v0.0.0-20220517211312-f3a8303e98df/go.mod h1:K8+ghG5WaK9qNqU5K3HdILfMLy1f3aNYFI/wnl100a8= +golang.org/x/xerrors v0.0.0-20220609144429-65e65417b02f/go.mod h1:K8+ghG5WaK9qNqU5K3HdILfMLy1f3aNYFI/wnl100a8= +golang.org/x/xerrors v0.0.0-20220907171357-04be3eba64a2/go.mod h1:K8+ghG5WaK9qNqU5K3HdILfMLy1f3aNYFI/wnl100a8= gonum.org/v1/gonum v0.0.0-20180816165407-929014505bf4/go.mod h1:Y+Yx5eoAFn32cQvJDxZx5Dpnq+c3wtXuadVZAcxbbBo= gonum.org/v1/gonum v0.0.0-20181121035319-3f7ecaa7e8ca/go.mod h1:Y+Yx5eoAFn32cQvJDxZx5Dpnq+c3wtXuadVZAcxbbBo= gonum.org/v1/gonum v0.6.0/go.mod h1:9mxDZsDKxgMAuccQkewq682L+0eCu4dCN2yonUJTCLU= @@ -1286,6 +1823,36 @@ google.golang.org/api v0.40.0/go.mod h1:fYKFpnQN0DsDSKRVRcQSDQNtqWPfM9i+zNPxepjR google.golang.org/api v0.41.0/go.mod h1:RkxM5lITDfTzmyKFPt+wGrCJbVfniCr2ool8kTBzRTU= google.golang.org/api v0.43.0/go.mod h1:nQsDGjRXMo4lvh5hP0TKqF244gqhGcr/YSIykhUk/94= google.golang.org/api v0.44.0/go.mod h1:EBOGZqzyhtvMDoxwS97ctnh0zUmYY6CxqXsc1AvkYD8= +google.golang.org/api v0.47.0/go.mod h1:Wbvgpq1HddcWVtzsVLyfLp8lDg6AA241LmgIL59tHXo= +google.golang.org/api v0.48.0/go.mod h1:71Pr1vy+TAZRPkPs/xlCf5SsU8WjuAWv1Pfjbtukyy4= +google.golang.org/api v0.50.0/go.mod h1:4bNT5pAuq5ji4SRZm+5QIkjny9JAyVD/3gaSihNefaw= +google.golang.org/api v0.51.0/go.mod h1:t4HdrdoNgyN5cbEfm7Lum0lcLDLiise1F8qDKX00sOU= +google.golang.org/api v0.54.0/go.mod h1:7C4bFFOvVDGXjfDTAsgGwDgAxRDeQ4X8NvUedIt6z3k= +google.golang.org/api v0.55.0/go.mod h1:38yMfeP1kfjsl8isn0tliTjIb1rJXcQi4UXlbqivdVE= +google.golang.org/api v0.56.0/go.mod h1:38yMfeP1kfjsl8isn0tliTjIb1rJXcQi4UXlbqivdVE= +google.golang.org/api v0.57.0/go.mod h1:dVPlbZyBo2/OjBpmvNdpn2GRm6rPy75jyU7bmhdrMgI= +google.golang.org/api v0.61.0/go.mod h1:xQRti5UdCmoCEqFxcz93fTl338AVqDgyaDRuOZ3hg9I= +google.golang.org/api v0.63.0/go.mod h1:gs4ij2ffTRXwuzzgJl/56BdwJaA194ijkfn++9tDuPo= +google.golang.org/api v0.67.0/go.mod h1:ShHKP8E60yPsKNw/w8w+VYaj9H6buA5UqDp8dhbQZ6g= +google.golang.org/api v0.70.0/go.mod h1:Bs4ZM2HGifEvXwd50TtW70ovgJffJYw2oRCOFU/SkfA= +google.golang.org/api v0.71.0/go.mod h1:4PyU6e6JogV1f9eA4voyrTY2batOLdgZ5qZ5HOCc4j8= +google.golang.org/api v0.74.0/go.mod h1:ZpfMZOVRMywNyvJFeqL9HRWBgAuRfSjJFpe9QtRRyDs= +google.golang.org/api v0.75.0/go.mod h1:pU9QmyHLnzlpar1Mjt4IbapUCy8J+6HD6GeELN69ljA= +google.golang.org/api v0.77.0/go.mod h1:pU9QmyHLnzlpar1Mjt4IbapUCy8J+6HD6GeELN69ljA= +google.golang.org/api v0.78.0/go.mod h1:1Sg78yoMLOhlQTeF+ARBoytAcH1NNyyl390YMy6rKmw= +google.golang.org/api v0.80.0/go.mod h1:xY3nI94gbvBrE0J6NHXhxOmW97HG7Khjkku6AFB3Hyg= +google.golang.org/api v0.84.0/go.mod h1:NTsGnUFJMYROtiquksZHBWtHfeMC7iYthki7Eq3pa8o= +google.golang.org/api v0.85.0/go.mod h1:AqZf8Ep9uZ2pyTvgL+x0D3Zt0eoT9b5E8fmzfu6FO2g= +google.golang.org/api v0.90.0/go.mod h1:+Sem1dnrKlrXMR/X0bPnMWyluQe4RsNoYfmNLhOIkzw= +google.golang.org/api v0.93.0/go.mod h1:+Sem1dnrKlrXMR/X0bPnMWyluQe4RsNoYfmNLhOIkzw= +google.golang.org/api v0.95.0/go.mod h1:eADj+UBuxkh5zlrSntJghuNeg8HwQ1w5lTKkuqaETEI= +google.golang.org/api v0.96.0/go.mod h1:w7wJQLTM+wvQpNf5JyEcBoxK0RH7EDrh/L4qfsuJ13s= +google.golang.org/api v0.97.0/go.mod h1:w7wJQLTM+wvQpNf5JyEcBoxK0RH7EDrh/L4qfsuJ13s= +google.golang.org/api v0.98.0/go.mod h1:w7wJQLTM+wvQpNf5JyEcBoxK0RH7EDrh/L4qfsuJ13s= +google.golang.org/api v0.99.0/go.mod h1:1YOf74vkVndF7pG6hIHuINsM7eWwpVTAfNMNiL91A08= +google.golang.org/api v0.100.0/go.mod h1:ZE3Z2+ZOr87Rx7dqFsdRQkRBk36kDtp/h+QpHbB7a70= +google.golang.org/api v0.102.0/go.mod h1:3VFl6/fzoA+qNuS1N1/VfXY4LjoXN/wzeIp7TweWwGo= +google.golang.org/api v0.103.0/go.mod h1:hGtW6nK1AC+d9si/UBhw8Xli+QMOf6xyNAyJw4qU9w0= google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM= google.golang.org/appengine v1.2.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4= google.golang.org/appengine v1.4.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4= @@ -1337,15 +1904,85 @@ google.golang.org/genproto v0.0.0-20201119123407-9b1e624d6bc4/go.mod h1:FWY/as6D google.golang.org/genproto v0.0.0-20201201144952-b05cb90ed32e/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= google.golang.org/genproto v0.0.0-20201210142538-e3217bee35cc/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= google.golang.org/genproto v0.0.0-20201214200347-8c77b98c765d/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= +google.golang.org/genproto v0.0.0-20210108203827-ffc7fda8c3d7/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= google.golang.org/genproto v0.0.0-20210126160654-44e461bb6506/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= google.golang.org/genproto v0.0.0-20210222152913-aa3ee6e6a81c/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= +google.golang.org/genproto v0.0.0-20210226172003-ab064af71705/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= google.golang.org/genproto v0.0.0-20210303154014-9728d6b83eeb/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= google.golang.org/genproto v0.0.0-20210310155132-4ce2db91004e/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= google.golang.org/genproto v0.0.0-20210319143718-93e7006c17a6/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= +google.golang.org/genproto v0.0.0-20210329143202-679c6ae281ee/go.mod h1:9lPAdzaEmUacj36I+k7YKbEc5CXzPIeORRgDAUOu28A= google.golang.org/genproto v0.0.0-20210402141018-6c239bbf2bb1/go.mod h1:9lPAdzaEmUacj36I+k7YKbEc5CXzPIeORRgDAUOu28A= +google.golang.org/genproto v0.0.0-20210513213006-bf773b8c8384/go.mod h1:P3QM42oQyzQSnHPnZ/vqoCdDmzH28fzWByN9asMeM8A= google.golang.org/genproto v0.0.0-20210602131652-f16073e35f0c/go.mod h1:UODoCrxHCcBojKKwX1terBiRUaqAsFqJiF615XL43r0= -google.golang.org/genproto v0.0.0-20211116182654-e63d96a377c4 h1:nPiLDJ9/wsay2NDshdJ1B24frx+butTxmaVaCxDBChY= -google.golang.org/genproto v0.0.0-20211116182654-e63d96a377c4/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc= +google.golang.org/genproto v0.0.0-20210604141403-392c879c8b08/go.mod h1:UODoCrxHCcBojKKwX1terBiRUaqAsFqJiF615XL43r0= +google.golang.org/genproto v0.0.0-20210608205507-b6d2f5bf0d7d/go.mod h1:UODoCrxHCcBojKKwX1terBiRUaqAsFqJiF615XL43r0= +google.golang.org/genproto v0.0.0-20210624195500-8bfb893ecb84/go.mod h1:SzzZ/N+nwJDaO1kznhnlzqS8ocJICar6hYhVyhi++24= +google.golang.org/genproto v0.0.0-20210713002101-d411969a0d9a/go.mod h1:AxrInvYm1dci+enl5hChSFPOmmUF1+uAa/UsgNRWd7k= +google.golang.org/genproto v0.0.0-20210716133855-ce7ef5c701ea/go.mod h1:AxrInvYm1dci+enl5hChSFPOmmUF1+uAa/UsgNRWd7k= +google.golang.org/genproto v0.0.0-20210728212813-7823e685a01f/go.mod h1:ob2IJxKrgPT52GcgX759i1sleT07tiKowYBGbczaW48= +google.golang.org/genproto v0.0.0-20210805201207-89edb61ffb67/go.mod h1:ob2IJxKrgPT52GcgX759i1sleT07tiKowYBGbczaW48= +google.golang.org/genproto v0.0.0-20210813162853-db860fec028c/go.mod h1:cFeNkxwySK631ADgubI+/XFU/xp8FD5KIVV4rj8UC5w= +google.golang.org/genproto v0.0.0-20210821163610-241b8fcbd6c8/go.mod h1:eFjDcFEctNawg4eG61bRv87N7iHBWyVhJu7u1kqDUXY= +google.golang.org/genproto v0.0.0-20210828152312-66f60bf46e71/go.mod h1:eFjDcFEctNawg4eG61bRv87N7iHBWyVhJu7u1kqDUXY= +google.golang.org/genproto v0.0.0-20210831024726-fe130286e0e2/go.mod h1:eFjDcFEctNawg4eG61bRv87N7iHBWyVhJu7u1kqDUXY= +google.golang.org/genproto v0.0.0-20210903162649-d08c68adba83/go.mod h1:eFjDcFEctNawg4eG61bRv87N7iHBWyVhJu7u1kqDUXY= +google.golang.org/genproto v0.0.0-20210909211513-a8c4777a87af/go.mod h1:eFjDcFEctNawg4eG61bRv87N7iHBWyVhJu7u1kqDUXY= +google.golang.org/genproto v0.0.0-20210924002016-3dee208752a0/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc= +google.golang.org/genproto v0.0.0-20211118181313-81c1377c94b1/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc= +google.golang.org/genproto v0.0.0-20211206160659-862468c7d6e0/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc= +google.golang.org/genproto v0.0.0-20211208223120-3a66f561d7aa/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc= +google.golang.org/genproto v0.0.0-20211221195035-429b39de9b1c/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc= +google.golang.org/genproto v0.0.0-20220126215142-9970aeb2e350/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc= +google.golang.org/genproto v0.0.0-20220207164111-0872dc986b00/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc= +google.golang.org/genproto v0.0.0-20220218161850-94dd64e39d7c/go.mod h1:kGP+zUP2Ddo0ayMi4YuN7C3WZyJvGLZRh8Z5wnAqvEI= +google.golang.org/genproto v0.0.0-20220222213610-43724f9ea8cf/go.mod h1:kGP+zUP2Ddo0ayMi4YuN7C3WZyJvGLZRh8Z5wnAqvEI= +google.golang.org/genproto v0.0.0-20220304144024-325a89244dc8/go.mod h1:kGP+zUP2Ddo0ayMi4YuN7C3WZyJvGLZRh8Z5wnAqvEI= +google.golang.org/genproto v0.0.0-20220310185008-1973136f34c6/go.mod h1:kGP+zUP2Ddo0ayMi4YuN7C3WZyJvGLZRh8Z5wnAqvEI= +google.golang.org/genproto v0.0.0-20220324131243-acbaeb5b85eb/go.mod h1:hAL49I2IFola2sVEjAn7MEwsja0xp51I0tlGAf9hz4E= +google.golang.org/genproto v0.0.0-20220329172620-7be39ac1afc7/go.mod h1:8w6bsBMX6yCPbAVTeqQHvzxW0EIFigd5lZyahWgyfDo= +google.golang.org/genproto v0.0.0-20220407144326-9054f6ed7bac/go.mod h1:8w6bsBMX6yCPbAVTeqQHvzxW0EIFigd5lZyahWgyfDo= +google.golang.org/genproto v0.0.0-20220413183235-5e96e2839df9/go.mod h1:8w6bsBMX6yCPbAVTeqQHvzxW0EIFigd5lZyahWgyfDo= +google.golang.org/genproto v0.0.0-20220414192740-2d67ff6cf2b4/go.mod h1:8w6bsBMX6yCPbAVTeqQHvzxW0EIFigd5lZyahWgyfDo= +google.golang.org/genproto v0.0.0-20220421151946-72621c1f0bd3/go.mod h1:8w6bsBMX6yCPbAVTeqQHvzxW0EIFigd5lZyahWgyfDo= +google.golang.org/genproto v0.0.0-20220429170224-98d788798c3e/go.mod h1:8w6bsBMX6yCPbAVTeqQHvzxW0EIFigd5lZyahWgyfDo= +google.golang.org/genproto v0.0.0-20220502173005-c8bf987b8c21/go.mod h1:RAyBrSAP7Fh3Nc84ghnVLDPuV51xc9agzmm4Ph6i0Q4= +google.golang.org/genproto v0.0.0-20220505152158-f39f71e6c8f3/go.mod h1:RAyBrSAP7Fh3Nc84ghnVLDPuV51xc9agzmm4Ph6i0Q4= +google.golang.org/genproto v0.0.0-20220518221133-4f43b3371335/go.mod h1:RAyBrSAP7Fh3Nc84ghnVLDPuV51xc9agzmm4Ph6i0Q4= +google.golang.org/genproto v0.0.0-20220523171625-347a074981d8/go.mod h1:RAyBrSAP7Fh3Nc84ghnVLDPuV51xc9agzmm4Ph6i0Q4= +google.golang.org/genproto v0.0.0-20220608133413-ed9918b62aac/go.mod h1:KEWEmljWE5zPzLBa/oHl6DaEt9LmfH6WtH1OHIvleBA= +google.golang.org/genproto v0.0.0-20220616135557-88e70c0c3a90/go.mod h1:KEWEmljWE5zPzLBa/oHl6DaEt9LmfH6WtH1OHIvleBA= +google.golang.org/genproto v0.0.0-20220617124728-180714bec0ad/go.mod h1:KEWEmljWE5zPzLBa/oHl6DaEt9LmfH6WtH1OHIvleBA= +google.golang.org/genproto v0.0.0-20220624142145-8cd45d7dbd1f/go.mod h1:KEWEmljWE5zPzLBa/oHl6DaEt9LmfH6WtH1OHIvleBA= +google.golang.org/genproto v0.0.0-20220628213854-d9e0b6570c03/go.mod h1:KEWEmljWE5zPzLBa/oHl6DaEt9LmfH6WtH1OHIvleBA= +google.golang.org/genproto v0.0.0-20220722212130-b98a9ff5e252/go.mod h1:GkXuJDJ6aQ7lnJcRF+SJVgFdQhypqgl3LB1C9vabdRE= +google.golang.org/genproto v0.0.0-20220801145646-83ce21fca29f/go.mod h1:iHe1svFLAZg9VWz891+QbRMwUv9O/1Ww+/mngYeThbc= +google.golang.org/genproto v0.0.0-20220815135757-37a418bb8959/go.mod h1:dbqgFATTzChvnt+ujMdZwITVAJHFtfyN1qUhDqEiIlk= +google.golang.org/genproto v0.0.0-20220817144833-d7fd3f11b9b1/go.mod h1:dbqgFATTzChvnt+ujMdZwITVAJHFtfyN1qUhDqEiIlk= +google.golang.org/genproto v0.0.0-20220822174746-9e6da59bd2fc/go.mod h1:dbqgFATTzChvnt+ujMdZwITVAJHFtfyN1qUhDqEiIlk= +google.golang.org/genproto v0.0.0-20220829144015-23454907ede3/go.mod h1:dbqgFATTzChvnt+ujMdZwITVAJHFtfyN1qUhDqEiIlk= +google.golang.org/genproto v0.0.0-20220829175752-36a9c930ecbf/go.mod h1:dbqgFATTzChvnt+ujMdZwITVAJHFtfyN1qUhDqEiIlk= +google.golang.org/genproto v0.0.0-20220913154956-18f8339a66a5/go.mod h1:0Nb8Qy+Sk5eDzHnzlStwW3itdNaWoZA5XeSG+R3JHSo= +google.golang.org/genproto v0.0.0-20220914142337-ca0e39ece12f/go.mod h1:0Nb8Qy+Sk5eDzHnzlStwW3itdNaWoZA5XeSG+R3JHSo= +google.golang.org/genproto v0.0.0-20220915135415-7fd63a7952de/go.mod h1:0Nb8Qy+Sk5eDzHnzlStwW3itdNaWoZA5XeSG+R3JHSo= +google.golang.org/genproto v0.0.0-20220916172020-2692e8806bfa/go.mod h1:0Nb8Qy+Sk5eDzHnzlStwW3itdNaWoZA5XeSG+R3JHSo= +google.golang.org/genproto v0.0.0-20220919141832-68c03719ef51/go.mod h1:0Nb8Qy+Sk5eDzHnzlStwW3itdNaWoZA5XeSG+R3JHSo= +google.golang.org/genproto v0.0.0-20220920201722-2b89144ce006/go.mod h1:ht8XFiar2npT/g4vkk7O0WYS1sHOHbdujxbEp7CJWbw= +google.golang.org/genproto v0.0.0-20220926165614-551eb538f295/go.mod h1:woMGP53BroOrRY3xTxlbr8Y3eB/nzAvvFM83q7kG2OI= +google.golang.org/genproto v0.0.0-20220926220553-6981cbe3cfce/go.mod h1:woMGP53BroOrRY3xTxlbr8Y3eB/nzAvvFM83q7kG2OI= +google.golang.org/genproto v0.0.0-20221010155953-15ba04fc1c0e/go.mod h1:3526vdqwhZAwq4wsRUaVG555sVgsNmIjRtO7t/JH29U= +google.golang.org/genproto v0.0.0-20221014173430-6e2ab493f96b/go.mod h1:1vXfmgAz9N9Jx0QA82PqRVauvCz1SGSz739p0f183jM= +google.golang.org/genproto v0.0.0-20221014213838-99cd37c6964a/go.mod h1:1vXfmgAz9N9Jx0QA82PqRVauvCz1SGSz739p0f183jM= +google.golang.org/genproto v0.0.0-20221024153911-1573dae28c9c/go.mod h1:9qHF0xnpdSfF6knlcsnpzUu5y+rpwgbvsyGAZPBMg4s= +google.golang.org/genproto v0.0.0-20221024183307-1bc688fe9f3e/go.mod h1:9qHF0xnpdSfF6knlcsnpzUu5y+rpwgbvsyGAZPBMg4s= +google.golang.org/genproto v0.0.0-20221027153422-115e99e71e1c/go.mod h1:CGI5F/G+E5bKwmfYo09AXuVN4dD894kIKUFmVbP2/Fo= +google.golang.org/genproto v0.0.0-20221114212237-e4508ebdbee1/go.mod h1:rZS5c/ZVYMaOGBfO68GWtjOw/eLaZM1X6iVtgjZ+EWg= +google.golang.org/genproto v0.0.0-20221117204609-8f9c96812029/go.mod h1:rZS5c/ZVYMaOGBfO68GWtjOw/eLaZM1X6iVtgjZ+EWg= +google.golang.org/genproto v0.0.0-20221118155620-16455021b5e6/go.mod h1:rZS5c/ZVYMaOGBfO68GWtjOw/eLaZM1X6iVtgjZ+EWg= +google.golang.org/genproto v0.0.0-20221201164419-0e50fba7f41c/go.mod h1:rZS5c/ZVYMaOGBfO68GWtjOw/eLaZM1X6iVtgjZ+EWg= +google.golang.org/genproto v0.0.0-20221202195650-67e5cbc046fd/go.mod h1:cTsE614GARnxrLsqKREzmNYJACSWWpAWdNMwnD7c2BE= +google.golang.org/genproto v0.0.0-20230110181048-76db0878b65f h1:BWUVssLB0HVOSY78gIdvk1dTVYtT1y8SBWtPYuTJ/6w= +google.golang.org/genproto v0.0.0-20230110181048-76db0878b65f/go.mod h1:RGgjbofJ8xD9Sq1VVhDM1Vok1vRONV+rg+CjzG4SZKM= google.golang.org/grpc v1.17.0/go.mod h1:6QZJwpn2B+Zp71q/5VxRsJ6NXXVCE5NRUHRo+f3cWCs= google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c= google.golang.org/grpc v1.19.1/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c= @@ -1372,10 +2009,27 @@ google.golang.org/grpc v1.34.0/go.mod h1:WotjhfgOW/POjDeRt8vscBtXq+2VjORFy659qA5 google.golang.org/grpc v1.35.0/go.mod h1:qjiiYl8FncCW8feJPdyg3v6XW24KsRHe+dy9BAGRRjU= google.golang.org/grpc v1.36.0/go.mod h1:qjiiYl8FncCW8feJPdyg3v6XW24KsRHe+dy9BAGRRjU= google.golang.org/grpc v1.36.1/go.mod h1:qjiiYl8FncCW8feJPdyg3v6XW24KsRHe+dy9BAGRRjU= +google.golang.org/grpc v1.37.0/go.mod h1:NREThFqKR1f3iQ6oBuvc5LadQuXVGo9rkm5ZGrQdJfM= +google.golang.org/grpc v1.37.1/go.mod h1:NREThFqKR1f3iQ6oBuvc5LadQuXVGo9rkm5ZGrQdJfM= google.golang.org/grpc v1.38.0/go.mod h1:NREThFqKR1f3iQ6oBuvc5LadQuXVGo9rkm5ZGrQdJfM= +google.golang.org/grpc v1.39.0/go.mod h1:PImNr+rS9TWYb2O4/emRugxiyHZ5JyHW5F+RPnDzfrE= +google.golang.org/grpc v1.39.1/go.mod h1:PImNr+rS9TWYb2O4/emRugxiyHZ5JyHW5F+RPnDzfrE= google.golang.org/grpc v1.40.0/go.mod h1:ogyxbiOoUXAkP+4+xa6PZSE9DZgIHtSpzjDTB9KAK34= -google.golang.org/grpc v1.41.0 h1:f+PlOh7QV4iIJkPrx5NQ7qaNGFQ3OTse67yaDHfju4E= -google.golang.org/grpc v1.41.0/go.mod h1:U3l9uK9J0sini8mHphKoXyaqDA/8VyGnDee1zzIUK6k= +google.golang.org/grpc v1.40.1/go.mod h1:ogyxbiOoUXAkP+4+xa6PZSE9DZgIHtSpzjDTB9KAK34= +google.golang.org/grpc v1.42.0/go.mod h1:k+4IHHFw41K8+bbowsex27ge2rCb65oeWqe4jJ590SU= +google.golang.org/grpc v1.44.0/go.mod h1:k+4IHHFw41K8+bbowsex27ge2rCb65oeWqe4jJ590SU= +google.golang.org/grpc v1.45.0/go.mod h1:lN7owxKUQEqMfSyQikvvk5tf/6zMPsrK+ONuO11+0rQ= +google.golang.org/grpc v1.46.0/go.mod h1:vN9eftEi1UMyUsIF80+uQXhHjbXYbm0uXoFCACuMGWk= +google.golang.org/grpc v1.46.2/go.mod h1:vN9eftEi1UMyUsIF80+uQXhHjbXYbm0uXoFCACuMGWk= +google.golang.org/grpc v1.47.0/go.mod h1:vN9eftEi1UMyUsIF80+uQXhHjbXYbm0uXoFCACuMGWk= +google.golang.org/grpc v1.48.0/go.mod h1:vN9eftEi1UMyUsIF80+uQXhHjbXYbm0uXoFCACuMGWk= +google.golang.org/grpc v1.49.0/go.mod h1:ZgQEeidpAuNRZ8iRrlBKXZQP1ghovWIVhdJRyCDK+GI= +google.golang.org/grpc v1.50.0/go.mod h1:ZgQEeidpAuNRZ8iRrlBKXZQP1ghovWIVhdJRyCDK+GI= +google.golang.org/grpc v1.50.1/go.mod h1:ZgQEeidpAuNRZ8iRrlBKXZQP1ghovWIVhdJRyCDK+GI= +google.golang.org/grpc v1.51.0/go.mod h1:wgNDFcnuBGmxLKI/qn4T+m5BtEBYXJPvibbUPsAIPww= +google.golang.org/grpc v1.53.0 h1:LAv2ds7cmFV/XTS3XG1NneeENYrXGmorPxsBbptIjNc= +google.golang.org/grpc v1.53.0/go.mod h1:OnIrk0ipVdj4N5d9IUoFUx72/VlD7+jUsHwZgwSMQpw= +google.golang.org/grpc/cmd/protoc-gen-go-grpc v1.1.0/go.mod h1:6Kw0yEErY5E/yWrBtf03jp27GLLJujG4z/JK95pnjjw= 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= @@ -1389,8 +2043,10 @@ google.golang.org/protobuf v1.25.0/go.mod h1:9JNX74DMeImyA3h4bdi1ymwjUzf21/xIlba google.golang.org/protobuf v1.25.1-0.20200805231151-a709e31e5d12/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.27.1 h1:SnqbnDw1V7RiZcXPx5MEeqPv2s79L9i7BJUlG/+RurQ= google.golang.org/protobuf v1.27.1/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc= +google.golang.org/protobuf v1.28.0/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I= +google.golang.org/protobuf v1.28.1 h1:d0NfwRgPtno5B1Wa6L2DAG+KivqkdutMf1UhdNx175w= +google.golang.org/protobuf v1.28.1/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I= gopkg.in/alecthomas/kingpin.v2 v2.2.6/go.mod h1:FMv+mEhP44yOT+4EoQTLFTRgOQ1FBLkstjWtayDeSgw= 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= @@ -1403,8 +2059,10 @@ gopkg.in/errgo.v2 v2.1.0/go.mod h1:hNsd1EY+bozCKY1Ytp96fpM3vjJbqLJn88ws8XvfDNI= gopkg.in/fsnotify.v1 v1.4.7/go.mod h1:Tz8NjZHkW78fSQdbUxIjBTcgA1z1m8ZHf0WmKUhAMys= gopkg.in/gcfg.v1 v1.2.3/go.mod h1:yesOnuUOFQAhST5vPY4nbZsb/huCgGGXlipJsBn0b3o= gopkg.in/ini.v1 v1.51.0/go.mod h1:pNLf8WUiyNEtQjuu5G5vTm06TEv9tsIgeAvK8hOrP4k= -gopkg.in/ini.v1 v1.62.0 h1:duBzk771uxoUuOlyRLkHsygud9+5lrlGjdFBb4mSKDU= gopkg.in/ini.v1 v1.62.0/go.mod h1:pNLf8WUiyNEtQjuu5G5vTm06TEv9tsIgeAvK8hOrP4k= +gopkg.in/ini.v1 v1.63.2 h1:tGK/CyBg7SMzb60vP1M03vNZ3VDu3wGQJwn7Sxi9r3c= +gopkg.in/ini.v1 v1.63.2/go.mod h1:pNLf8WUiyNEtQjuu5G5vTm06TEv9tsIgeAvK8hOrP4k= +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/olebedev/go-duktape.v3 v3.0.0-20200619000410-60c24ae608a6/go.mod h1:uAJfkITjFhyEEuUfm7bsmCZRbW5WRq8s9EY8HZ6hCns= gopkg.in/resty.v1 v1.12.0/go.mod h1:mDo4pnntr5jdWRML875a/NmxYqAlA73dVijT2AXvQQo= @@ -1423,8 +2081,9 @@ 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.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ= gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= -gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b h1:h8qDotaEPuJATrMmW04NCwg7v22aHH28wwpauUhK9Oo= gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= +gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= +gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= gotest.tools v2.2.0+incompatible/go.mod h1:DsYFclhRJ6vuDpmuTbkuFWG+y2sxOXAzmJt81HFBacw= honnef.co/go/tools v0.0.0-20180728063816-88497007e858/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= diff --git a/types/factory.go b/types/factory.go index 69fa1b6..7ca7375 100644 --- a/types/factory.go +++ b/types/factory.go @@ -3,6 +3,7 @@ package types import ( "errors" "fmt" + "github.com/ethereum/go-ethereum/crypto" cryptoamino "github.com/irisnet/core-sdk-go/common/crypto/codec" ethsecp256k1 "github.com/irisnet/core-sdk-go/common/crypto/keys/eth_secp256k1" @@ -263,7 +264,11 @@ func (f *Factory) BuildTxWithoutKeyDao(pubkey []byte, algo string, msgs []Msg) ( return []byte{}, err } - return crypto.Keccak256Hash(signBytes).Bytes(), nil + if algo != "secp256k1" { + return crypto.Keccak256Hash(signBytes).Bytes(), nil + } + + return signBytes, nil } func (f *Factory) SetUnsignedTxSignature(pubkey []byte, algo string, msgs []Msg, signedData []byte) ([]byte, error) { @@ -423,7 +428,7 @@ func FromTmPubKey(Algo string, pubKey tmcrypto.PubKey) commoncryptotypes.PubKey pubkey = &sm2.PubKey{Key: pubkeyBytes} case "secp256k1": pubkey = &secp256k1.PubKey{Key: pubkeyBytes} - case "eth_secp256k1": + case ethsecp256k1.KeyType: pubkey = ðsecp256k1.PubKey{Key: pubkeyBytes} } return pubkey From 1fc63ebe852076a53daef9d0c23f8bf0a499c8ff Mon Sep 17 00:00:00 2001 From: sxj Date: Tue, 23 May 2023 17:26:33 +0800 Subject: [PATCH 16/17] fix buildtxwithoutkeydao --- types/factory.go | 5 ----- 1 file changed, 5 deletions(-) diff --git a/types/factory.go b/types/factory.go index 7ca7375..9b38330 100644 --- a/types/factory.go +++ b/types/factory.go @@ -4,7 +4,6 @@ import ( "errors" "fmt" - "github.com/ethereum/go-ethereum/crypto" cryptoamino "github.com/irisnet/core-sdk-go/common/crypto/codec" ethsecp256k1 "github.com/irisnet/core-sdk-go/common/crypto/keys/eth_secp256k1" "github.com/irisnet/core-sdk-go/common/crypto/keys/secp256k1" @@ -264,10 +263,6 @@ func (f *Factory) BuildTxWithoutKeyDao(pubkey []byte, algo string, msgs []Msg) ( return []byte{}, err } - if algo != "secp256k1" { - return crypto.Keccak256Hash(signBytes).Bytes(), nil - } - return signBytes, nil } From 0b33ecd6dbef8633aca23b944727712e1cb6058f Mon Sep 17 00:00:00 2001 From: sxj Date: Tue, 6 Jun 2023 15:08:29 +0800 Subject: [PATCH 17/17] fix BuildTx and SetTxSignature, add EstimateTxSize --- client/base_client.go | 25 +++++++++++++++++-------- types/client.go | 5 +++-- types/factory.go | 23 +++++++++++++---------- 3 files changed, 33 insertions(+), 20 deletions(-) diff --git a/client/base_client.go b/client/base_client.go index 92a0137..23bb8fd 100644 --- a/client/base_client.go +++ b/client/base_client.go @@ -284,28 +284,37 @@ func (base *baseClient) SendBatch(msgs sdktypes.Msgs, baseTx sdktypes.BaseTx) (r return rs, nil } -func (base *baseClient) BuildTx(addr string, pubkey []byte, algo string, sequence, accountNumber uint64, msg []sdktypes.Msg, baseTx sdktypes.BaseTx) ([]byte, sdktypes.Error) { +func (base *baseClient) BuildTx(addr string, pubkey []byte, algo string, sequence, accountNumber uint64, msg []sdktypes.Msg, baseTx sdktypes.BaseTx) ([]byte, *sdktypes.Factory, sdktypes.TxBuilder, sdktypes.Error) { builder, err := base.prepareWithAccount(addr, accountNumber, sequence, baseTx) if err != nil { - return nil, sdktypes.Wrap(err) + return nil, nil, nil, sdktypes.Wrap(err) } - unsignedTxBytes, err := builder.BuildTxWithoutKeyDao(pubkey, algo, msg) + unsignedTxBytes, txBuilder, err := builder.BuildTxWithoutKeyDao(pubkey, algo, msg) if err != nil { - return nil, sdktypes.Wrap(err) + return nil, nil, nil, sdktypes.Wrap(err) } base.Logger().Debug("sign transaction success") - return unsignedTxBytes, nil + return unsignedTxBytes, builder, txBuilder, nil } -func (base *baseClient) SetTxSignature(addr string, pubkey []byte, algo string, sequence, accountNumber uint64, msg []sdktypes.Msg, baseTx sdktypes.BaseTx, signedData []byte) ([]byte, sdktypes.Error) { - builder, err := base.prepareWithAccount(addr, accountNumber, sequence, baseTx) +func (base *baseClient) SetTxSignature(builder *sdktypes.Factory, txBuilder sdktypes.TxBuilder, pubkey []byte, algo string, signedData []byte, msgs []sdktypes.Msg) ([]byte, sdktypes.Error) { + txByte, err := builder.SetUnsignedTxSignature(txBuilder, pubkey, algo, signedData, msgs) if err != nil { return nil, sdktypes.Wrap(err) } - txByte, err := builder.SetUnsignedTxSignature(pubkey, algo, msg, signedData) + base.Logger().Debug("sign transaction success") + return txByte, nil +} + +func (base *baseClient) EstimateTxSize(addr string, pubkey []byte, algo string, sequence, accountNumber uint64, msgs []sdktypes.Msg, baseTx sdktypes.BaseTx, signedData []byte) ([]byte, sdktypes.Error) { + factory, err := base.prepareWithAccount(addr, accountNumber, sequence, baseTx) + if err != nil { + return nil, sdktypes.Wrap(err) + } + txByte, err := factory.SetUnsignedTxSignature(nil, pubkey, algo, signedData, msgs) if err != nil { return nil, sdktypes.Wrap(err) } diff --git a/types/client.go b/types/client.go index fdb97d2..bd6afe2 100644 --- a/types/client.go +++ b/types/client.go @@ -15,8 +15,9 @@ type TxManager interface { BuildTxHash(msg []Msg, baseTx BaseTx) (string, Error) BuildAndSendWithAccount(addr string, accountNumber, sequence uint64, msg []Msg, baseTx BaseTx) (ResultTx, Error) BuildAndSignWithAccount(addr string, accountNumber, sequence uint64, msg []Msg, baseTx BaseTx) ([]byte, Error) - BuildTx(addr string, pubkey []byte, algo string, sequence, accountNumber uint64, msg []Msg, baseTx BaseTx) ([]byte, Error) - SetTxSignature(addr string, pubkey []byte, algo string, sequence, accountNumber uint64, msg []Msg, baseTx BaseTx, signedData []byte) ([]byte, Error) + BuildTx(addr string, pubkey []byte, algo string, sequence, accountNumber uint64, msg []Msg, baseTx BaseTx) ([]byte, *Factory, TxBuilder, Error) + SetTxSignature(builder *Factory, txBuilder TxBuilder, pubkey []byte, algo string, signedData []byte, msgs []Msg) ([]byte, Error) + EstimateTxSize(addr string, pubkey []byte, algo string, sequence, accountNumber uint64, msgs []Msg, baseTx BaseTx, signedData []byte) ([]byte, Error) } type Queries interface { diff --git a/types/factory.go b/types/factory.go index 9b38330..a64f357 100644 --- a/types/factory.go +++ b/types/factory.go @@ -220,10 +220,10 @@ func (f *Factory) BuildAndSign(name string, msgs []Msg, json bool) ([]byte, erro return txBytes, nil } -func (f *Factory) BuildTxWithoutKeyDao(pubkey []byte, algo string, msgs []Msg) ([]byte, error) { +func (f *Factory) BuildTxWithoutKeyDao(pubkey []byte, algo string, msgs []Msg) ([]byte, TxBuilder, error) { tx, err := f.BuildUnsignedTx(msgs) if err != nil { - return []byte{}, err + return []byte{}, nil, err } signMode := f.signMode @@ -239,7 +239,7 @@ func (f *Factory) BuildTxWithoutKeyDao(pubkey []byte, algo string, msgs []Msg) ( pubKey, err := cryptoamino.PubKeyFromBytes(pubkey) if err != nil { - return []byte{}, err + return []byte{}, nil, err } publicKey := FromTmPubKey(algo, pubKey) @@ -254,22 +254,25 @@ func (f *Factory) BuildTxWithoutKeyDao(pubkey []byte, algo string, msgs []Msg) ( Sequence: f.Sequence(), } if err := tx.SetSignatures(sig); err != nil { - return []byte{}, err + return []byte{}, nil, err } // Generate the bytes to be signed. signBytes, err := f.signModeHandler.GetSignBytes(signMode, signerData, tx.GetTx()) if err != nil { - return []byte{}, err + return []byte{}, nil, err } - return signBytes, nil + return signBytes, tx, nil } -func (f *Factory) SetUnsignedTxSignature(pubkey []byte, algo string, msgs []Msg, signedData []byte) ([]byte, error) { - tx, err := f.BuildUnsignedTx(msgs) - if err != nil { - return []byte{}, err +func (f *Factory) SetUnsignedTxSignature(tx TxBuilder, pubkey []byte, algo string, signedData []byte, msgs []Msg) ([]byte, error) { + if tx == nil { + builder, err := f.BuildUnsignedTx(msgs) + if err != nil { + return []byte{}, err + } + tx = builder } signMode := f.signMode