diff --git a/CHANGELOG.md b/CHANGELOG.md index 831f42435..34df15759 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -94,6 +94,7 @@ needed to include double quotes around the hexadecimal string. - [#2183](https://github.com/NibiruChain/nibiru/pull/2183) - fix(evm): bank keeper extension gas meter type - [#2184](https://github.com/NibiruChain/nibiru/pull/2184) - test(evm): e2e tests configuration enhancements - [#2187](https://github.com/NibiruChain/nibiru/pull/2187) - fix(evm): fix eip55 address encoding +- [#2188](https://github.com/NibiruChain/nibiru/pull/2188) - refactor(evm): update logs emission - [#2192](https://github.com/NibiruChain/nibiru/pull/2192) - fix(oracle): correctly handle misscount #### Nibiru EVM | Before Audit 2 - 2024-12-06 diff --git a/eth/rpc/backend/tx_logs_test.go b/eth/rpc/backend/tx_logs_test.go index 6bd1132cf..3c5a81e4f 100644 --- a/eth/rpc/backend/tx_logs_test.go +++ b/eth/rpc/backend/tx_logs_test.go @@ -11,7 +11,6 @@ import ( "github.com/ethereum/go-ethereum/crypto" "github.com/NibiruChain/nibiru/v2/eth" - "github.com/NibiruChain/nibiru/v2/eth/rpc/backend" "github.com/NibiruChain/nibiru/v2/x/common/testutil" "github.com/NibiruChain/nibiru/v2/x/evm" "github.com/NibiruChain/nibiru/v2/x/evm/embeds" @@ -241,8 +240,10 @@ func (s *BackendSuite) assertTxLogsAndTxIndex( foundEthTx := false for _, event := range events { if event.Type == evm.TypeUrlEventTxLog { - logs, err := backend.ParseTxLogsFromEvent(event) + eventTxLog, err := evm.EventTxLogFromABCIEvent(event) s.Require().NoError(err) + + logs := evm.LogsToEthereum(eventTxLog.Logs) if len(expectedTxLogs) > 0 { s.Require().GreaterOrEqual(len(logs), len(expectedTxLogs)) s.assertTxLogsMatch(expectedTxLogs, logs, txInfo) diff --git a/eth/rpc/backend/utils.go b/eth/rpc/backend/utils.go index 3ea0f710a..f4e49046d 100644 --- a/eth/rpc/backend/utils.go +++ b/eth/rpc/backend/utils.go @@ -2,7 +2,6 @@ package backend import ( - "encoding/json" "fmt" "math/big" "sort" @@ -11,7 +10,6 @@ import ( "cosmossdk.io/errors" sdk "github.com/cosmos/cosmos-sdk/types" authtypes "github.com/cosmos/cosmos-sdk/x/auth/types" - "github.com/cosmos/gogoproto/proto" "google.golang.org/grpc/codes" "google.golang.org/grpc/status" @@ -210,28 +208,10 @@ func (b *Backend) retrieveEVMTxFeesFromBlock( return nil } -// AllTxLogsFromEvents parses all ethereum logs from cosmos events -func AllTxLogsFromEvents(events []abci.Event) ([][]*gethcore.Log, error) { - allLogs := make([][]*gethcore.Log, 0, 4) - for _, event := range events { - if event.Type != proto.MessageName(new(evm.EventTxLog)) { - continue - } - - logs, err := ParseTxLogsFromEvent(event) - if err != nil { - return nil, err - } - - allLogs = append(allLogs, logs) - } - return allLogs, nil -} - // TxLogsFromEvents parses ethereum logs from cosmos events for specific msg index func TxLogsFromEvents(events []abci.Event, msgIndex int) ([]*gethcore.Log, error) { for _, event := range events { - if event.Type != proto.MessageName(new(evm.EventTxLog)) { + if event.Type != evm.TypeUrlEventTxLog { continue } @@ -241,26 +221,13 @@ func TxLogsFromEvents(events []abci.Event, msgIndex int) ([]*gethcore.Log, error continue } - return ParseTxLogsFromEvent(event) - } - return nil, fmt.Errorf("eth tx logs not found for message index %d", msgIndex) -} - -// ParseTxLogsFromEvent parse tx logs from one event -func ParseTxLogsFromEvent(event abci.Event) ([]*gethcore.Log, error) { - eventTxLog, err := evm.EventTxLogFromABCIEvent(event) - if err != nil { - return nil, errors.Wrapf(err, "failed to parse event tx log") - } - var evmLogs []*evm.Log - for _, logString := range eventTxLog.TxLogs { - var evmLog evm.Log - if err = json.Unmarshal([]byte(logString), &evmLog); err != nil { - return nil, errors.Wrapf(err, "failed to unmarshal event tx log") + eventTxLog, err := evm.EventTxLogFromABCIEvent(event) + if err != nil { + return nil, errors.Wrapf(err, "failed to parse event tx log") } - evmLogs = append(evmLogs, &evmLog) + return evm.LogsToEthereum(eventTxLog.Logs), nil } - return evm.LogsToEthereum(evmLogs), nil + return nil, fmt.Errorf("eth tx logs not found for message index %d", msgIndex) } // ShouldIgnoreGasUsed returns true if the gasUsed in result should be ignored @@ -272,16 +239,27 @@ func ShouldIgnoreGasUsed(res *abci.ResponseDeliverTx) bool { // GetLogsFromBlockResults returns the list of event logs from the tendermint block result response func GetLogsFromBlockResults( blockRes *tmrpctypes.ResultBlockResults, -) ([][]*gethcore.Log, error) { - blockLogs := [][]*gethcore.Log{} +) (blockLogs [][]*gethcore.Log, err error) { + blockLogs = [][]*gethcore.Log{} for _, txResult := range blockRes.TxsResults { - logs, err := AllTxLogsFromEvents(txResult.Events) - if err != nil { - return nil, err + txLogs := []*gethcore.Log{} + + for _, event := range txResult.Events { + if event.Type != evm.TypeUrlEventTxLog { + continue + } + + eventTxLogs, err := evm.EventTxLogFromABCIEvent(event) + if err != nil { + return nil, err + } + + txLogs = append(txLogs, evm.LogsToEthereum(eventTxLogs.Logs)...) } - blockLogs = append(blockLogs, logs...) + blockLogs = append(blockLogs, txLogs) } + return blockLogs, nil } diff --git a/eth/rpc/events_parser.go b/eth/rpc/events_parser.go index 8fd5c6311..ea15f025f 100644 --- a/eth/rpc/events_parser.go +++ b/eth/rpc/events_parser.go @@ -9,7 +9,6 @@ import ( abci "github.com/cometbft/cometbft/abci/types" tmrpctypes "github.com/cometbft/cometbft/rpc/core/types" sdk "github.com/cosmos/cosmos-sdk/types" - "github.com/cosmos/gogoproto/proto" gethcommon "github.com/ethereum/go-ethereum/common" "github.com/NibiruChain/nibiru/v2/eth" @@ -39,9 +38,6 @@ type ParsedTxs struct { // ParseTxResult parses eth tx info from the ABCI events of Eth tx msgs func ParseTxResult(result *abci.ResponseDeliverTx, tx sdk.Tx) (*ParsedTxs, error) { - eventTypePendingEthereumTx := evm.PendingEthereumTxEvent - eventTypeEthereumTx := proto.MessageName((*evm.EventEthereumTx)(nil)) - // Parsed txs is the structure being populated from the events // So far (until we allow ethereum_txs as cosmos tx messages) it'll have single tx parsedTxs := &ParsedTxs{ @@ -53,7 +49,7 @@ func ParseTxResult(result *abci.ResponseDeliverTx, tx sdk.Tx) (*ParsedTxs, error msgIndex := -1 for _, event := range result.Events { // Pending tx event could be single if tx didn't succeed - if event.Type == eventTypePendingEthereumTx { + if event.Type == evm.PendingEthereumTxEvent { msgIndex++ ethHash, txIndex, err := evm.GetEthHashAndIndexFromPendingEthereumTxEvent(event) if err != nil { @@ -66,7 +62,7 @@ func ParseTxResult(result *abci.ResponseDeliverTx, tx sdk.Tx) (*ParsedTxs, error } parsedTxs.Txs = append(parsedTxs.Txs, pendingTx) parsedTxs.TxHashes[ethHash] = msgIndex - } else if event.Type == eventTypeEthereumTx { // Full event replaces the pending tx + } else if event.Type == evm.TypeUrlEventEthereumTx { // Full event replaces the pending tx eventEthereumTx, err := evm.EventEthereumTxFromABCIEvent(event) if err != nil { return nil, err @@ -84,7 +80,7 @@ func ParseTxResult(result *abci.ResponseDeliverTx, tx sdk.Tx) (*ParsedTxs, error EthTxIndex: int32(ethTxIndexFromEvent), EthHash: gethcommon.HexToHash(eventEthereumTx.EthHash), GasUsed: gasUsed, - Failed: len(eventEthereumTx.EthTxFailed) > 0, + Failed: len(eventEthereumTx.VmError) > 0, } // find the pending tx to replace by tx hash pendingMsgIndex, found := parsedTxs.TxHashes[committedTx.EthHash] diff --git a/eth/rpc/events_parser_test.go b/eth/rpc/events_parser_test.go index e4a0c6b73..91a891394 100644 --- a/eth/rpc/events_parser_test.go +++ b/eth/rpc/events_parser_test.go @@ -182,16 +182,16 @@ func pendingEthereumTxEvent(txHash string, txIndex int) abci.Event { } func ethereumTxEvent(txHash string, txIndex int, gasUsed int, failed bool) abci.Event { - failure := "" + var vmError string if failed { - failure = "failed" + vmError = "failed" } event, err := sdk.TypedEventToEvent( &evm.EventEthereumTx{ - EthHash: txHash, - Index: strconv.Itoa(txIndex), - GasUsed: strconv.Itoa(gasUsed), - EthTxFailed: failure, + EthHash: txHash, + Index: strconv.Itoa(txIndex), + GasUsed: strconv.Itoa(gasUsed), + VmError: vmError, }, ) if err != nil { diff --git a/proto/eth/evm/v1/events.proto b/proto/eth/evm/v1/events.proto index 826c8bf6d..a99b98ddd 100644 --- a/proto/eth/evm/v1/events.proto +++ b/proto/eth/evm/v1/events.proto @@ -4,6 +4,7 @@ package eth.evm.v1; import "cosmos/base/v1beta1/coin.proto"; import "gogoproto/gogo.proto"; +import "eth/evm/v1/evm.proto"; option go_package = "github.com/NibiruChain/nibiru/v2/x/evm"; @@ -21,14 +22,14 @@ message EventEthereumTx { string hash = 5; // recipient of the transaction string recipient = 6; - // eth_tx_failed contains a VM error should it occur - string eth_tx_failed = 7; + // vm_error contains a VM error should it occur + string vm_error = 7; } // EventTxLog defines the event for an Ethereum transaction log message EventTxLog { // tx_logs is an array of transaction logs - repeated string tx_logs = 1; + repeated Log logs = 1 [ (gogoproto.nullable) = false ]; } // EventBlockBloom defines an Ethereum block bloom filter event diff --git a/proto/eth/evm/v1/evm.proto b/proto/eth/evm/v1/evm.proto index 46893edcc..db785891a 100644 --- a/proto/eth/evm/v1/evm.proto +++ b/proto/eth/evm/v1/evm.proto @@ -68,16 +68,6 @@ message State { 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 { - // hash of the transaction - string hash = 1; - // logs is an array of Logs for the given transaction hash - 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. @@ -109,31 +99,6 @@ message Log { 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; @@ -144,9 +109,10 @@ message AccessTuple { repeated string storage_keys = 2 [ (gogoproto.jsontag) = "storageKeys" ]; } -// TracerConfig stores additional tracer args. For geth it's only one attr: onlyTopCall +// TracerConfig stores additional tracer args. For geth it's only one attr: +// onlyTopCall message TracerConfig { - bool only_top_call = 1 [ (gogoproto.jsontag) = "onlyTopCall" ]; + bool only_top_call = 1 [ (gogoproto.jsontag) = "onlyTopCall" ]; } // TraceConfig holds extra parameters to trace functions. diff --git a/proto/eth/evm/v1/tx.proto b/proto/eth/evm/v1/tx.proto index af185d368..a1896fe86 100644 --- a/proto/eth/evm/v1/tx.proto +++ b/proto/eth/evm/v1/tx.proto @@ -24,13 +24,15 @@ service Msg { // CreateFunToken: Create a "FunToken" mapping. Either the ERC20 contract // address can be given to create the mapping to a Bank Coin, or the - // denomination for a Bank Coin can be given to create the mapping to an ERC20. + // denomination for a Bank Coin can be given to create the mapping to an + // ERC20. rpc CreateFunToken(MsgCreateFunToken) returns (MsgCreateFunTokenResponse); // ConvertCoinToEvm: Sends a coin with a valid "FunToken" mapping to the // given recipient address ("to_eth_addr") in the corresponding ERC20 // representation. - rpc ConvertCoinToEvm(MsgConvertCoinToEvm) returns (MsgConvertCoinToEvmResponse); + rpc ConvertCoinToEvm(MsgConvertCoinToEvm) + returns (MsgConvertCoinToEvmResponse); } // MsgEthereumTx encapsulates an Ethereum transaction as an SDK message. @@ -41,11 +43,11 @@ message MsgEthereumTx { google.protobuf.Any data = 1; // size is the encoded storage size of the transaction (DEPRECATED) - double size = 2 [(gogoproto.jsontag) = "-"]; + double size = 2 [ (gogoproto.jsontag) = "-" ]; // hash of the transaction in hex format - string hash = 3 [(gogoproto.moretags) = "rlp:\"-\""]; - // from is the ethereum signer address in hex format. This address value is checked - // against the address derived from the signature (V, R, S) using the + string hash = 3 [ (gogoproto.moretags) = "rlp:\"-\"" ]; + // from is the 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; } @@ -64,31 +66,34 @@ message LegacyTx { // 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) = "cosmossdk.io/math.Int"]; + string gas_price = 2 [ (gogoproto.customtype) = "cosmossdk.io/math.Int" ]; // gas defines the gas limit defined for the transaction. - uint64 gas = 3 [(gogoproto.customname) = "GasLimit"]; + uint64 gas = 3 [ (gogoproto.customname) = "GasLimit" ]; // to is the hex formatted address of the recipient string to = 4; // value defines the unsigned integer value of the transaction amount. - string value = 5 [(gogoproto.customtype) = "cosmossdk.io/math.Int", (gogoproto.customname) = "Amount"]; + string value = 5 [ + (gogoproto.customtype) = "cosmossdk.io/math.Int", + (gogoproto.customname) = "Amount" + ]; // data is the data payload bytes of the transaction. bytes data = 6; - // v defines the recovery id as the "v" signature value from the elliptic curve - // digital signatute algorithm (ECDSA). It indicates which of two possible - // solutions should be used to reconstruct the public key from the signature. - // In Ethereum, "v" takes the value 27 or 28 for transactions that are not - // relay-protected. + // v defines the recovery id as the "v" signature value from the elliptic + // curve digital signatute algorithm (ECDSA). It indicates which of two + // possible solutions should be used to reconstruct the public key from the + // signature. In Ethereum, "v" takes the value 27 or 28 for transactions that + // are not relay-protected. bytes v = 7; - // r defines the x-coordinate of a point on the elliptic curve in the elliptic curve - // digital signatute algorithm (ECDSA). It's crucial in ensuring uniqueness of - // the signature. + // r defines the x-coordinate of a point on the elliptic curve in the elliptic + // curve digital signatute algorithm (ECDSA). It's crucial in ensuring + // uniqueness of the signature. bytes r = 8; - // s define the signature value derived from the private key, message hash, and - // the value of "r". It ensures that the signature is tied to both the message - // and the private key of the sender. + // s define the signature value derived from the private key, message hash, + // and the value of "r". It ensures that the signature is tied to both the + // message and the private key of the sender. bytes s = 9; } @@ -108,18 +113,24 @@ message AccessListTx { // 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) = "cosmossdk.io/math.Int"]; + string gas_price = 3 [ (gogoproto.customtype) = "cosmossdk.io/math.Int" ]; // gas defines the gas limit defined for the transaction. - uint64 gas = 4 [(gogoproto.customname) = "GasLimit"]; + uint64 gas = 4 [ (gogoproto.customname) = "GasLimit" ]; // to is the recipient address in hex format string to = 5; // value defines the unsigned integer value of the transaction amount. - string value = 6 [(gogoproto.customtype) = "cosmossdk.io/math.Int", (gogoproto.customname) = "Amount"]; + string value = 6 [ + (gogoproto.customtype) = "cosmossdk.io/math.Int", + (gogoproto.customname) = "Amount" + ]; // data is the data payload bytes of the transaction. bytes data = 7; // accesses is an array of access tuples - repeated AccessTuple accesses = 8 - [(gogoproto.castrepeated) = "AccessList", (gogoproto.jsontag) = "accessList", (gogoproto.nullable) = false]; + repeated AccessTuple accesses = 8 [ + (gogoproto.castrepeated) = "AccessList", + (gogoproto.jsontag) = "accessList", + (gogoproto.nullable) = false + ]; // v defines the recovery id and "v" signature value from the elliptic curve // digital signatute algorithm (ECDSA). It indicates which of two possible @@ -128,14 +139,14 @@ message AccessListTx { // relay-protected. bytes v = 9; - // r defines the x-coordinate of a point on the elliptic curve in the elliptic curve - // digital signatute algorithm (ECDSA). It's crucial in ensuring uniqueness of - // the signature. + // r defines the x-coordinate of a point on the elliptic curve in the elliptic + // curve digital signatute algorithm (ECDSA). It's crucial in ensuring + // uniqueness of the signature. bytes r = 10; - // s define the signature value derived from the private key, message hash, and - // the value of "r". It ensures that the signature is tied to both the message - // and the private key of the sender. + // s define the signature value derived from the private key, message hash, + // and the value of "r". It ensures that the signature is tied to both the + // message and the private key of the sender. bytes s = 11; } @@ -155,20 +166,26 @@ message DynamicFeeTx { // 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) = "cosmossdk.io/math.Int"]; + string gas_tip_cap = 3 [ (gogoproto.customtype) = "cosmossdk.io/math.Int" ]; // gas_fee_cap defines the max value for the gas fee - string gas_fee_cap = 4 [(gogoproto.customtype) = "cosmossdk.io/math.Int"]; + string gas_fee_cap = 4 [ (gogoproto.customtype) = "cosmossdk.io/math.Int" ]; // gas defines the gas limit defined for the transaction. - uint64 gas = 5 [(gogoproto.customname) = "GasLimit"]; + uint64 gas = 5 [ (gogoproto.customname) = "GasLimit" ]; // to is the hex formatted address of the recipient string to = 6; // value defines the the transaction amount. - string value = 7 [(gogoproto.customtype) = "cosmossdk.io/math.Int", (gogoproto.customname) = "Amount"]; + string value = 7 [ + (gogoproto.customtype) = "cosmossdk.io/math.Int", + (gogoproto.customname) = "Amount" + ]; // data is the data payload bytes of the transaction. bytes data = 8; // accesses is an array of access tuples - repeated AccessTuple accesses = 9 - [(gogoproto.castrepeated) = "AccessList", (gogoproto.jsontag) = "accessList", (gogoproto.nullable) = false]; + repeated AccessTuple accesses = 9 [ + (gogoproto.castrepeated) = "AccessList", + (gogoproto.jsontag) = "accessList", + (gogoproto.nullable) = false + ]; // v defines the recovery id and "v" signature value from the elliptic curve // digital signatute algorithm (ECDSA). It indicates which of two possible // solutions should be used to reconstruct the public key from the signature. @@ -176,14 +193,14 @@ message DynamicFeeTx { // relay-protected. bytes v = 10; - // r defines the x-coordinate of a point on the elliptic curve in the elliptic curve - // digital signatute algorithm (ECDSA). It's crucial in ensuring uniqueness of - // the signature. + // r defines the x-coordinate of a point on the elliptic curve in the elliptic + // curve digital signatute algorithm (ECDSA). It's crucial in ensuring + // uniqueness of the signature. bytes r = 11; - // s define the signature value derived from the private key, message hash, and - // the value of "r". It ensures that the signature is tied to both the message - // and the private key of the sender. + // s define the signature value derived from the private key, message hash, + // and the value of "r". It ensures that the signature is tied to both the + // message and the private key of the sender. bytes s = 12; } @@ -202,9 +219,9 @@ message MsgEthereumTxResponse { string hash = 1; // logs contains the transaction hash and the proto-compatible ethereum // logs. - repeated Log logs = 2; - // ret is the returned data from evm function (result or data supplied with revert - // opcode) + repeated Log logs = 2 [ (gogoproto.nullable) = false ]; + // ret is the 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; @@ -217,11 +234,11 @@ message MsgUpdateParams { option (cosmos.msg.v1.signer) = "authority"; // authority is the address of the governance account. - string authority = 1 [(cosmos_proto.scalar) = "cosmos.AddressString"]; + string authority = 1 [ (cosmos_proto.scalar) = "cosmos.AddressString" ]; // params defines the x/evm parameters to update. // NOTE: All parameters must be supplied. - eth.evm.v1.Params params = 2 [(gogoproto.nullable) = false]; + eth.evm.v1.Params params = 2 [ (gogoproto.nullable) = false ]; } // MsgUpdateParamsResponse defines the response structure for executing a @@ -235,7 +252,7 @@ message MsgCreateFunToken { // Hexadecimal address of the ERC20 token to which the `FunToken` maps string from_erc20 = 1 [ (gogoproto.customtype) = "github.com/NibiruChain/nibiru/v2/eth.EIP55Addr", - (gogoproto.nullable) = true + (gogoproto.nullable) = true ]; // Coin denomination in the Bank Module. @@ -247,7 +264,7 @@ message MsgCreateFunToken { message MsgCreateFunTokenResponse { // Fungible token mapping corresponding to ERC20 tokens. - eth.evm.v1.FunToken funtoken_mapping = 1 [(gogoproto.nullable) = false]; + eth.evm.v1.FunToken funtoken_mapping = 1 [ (gogoproto.nullable) = false ]; } // MsgConvertCoinToEvm: Arguments to send a Bank Coin to ERC-20 representation @@ -255,7 +272,7 @@ message MsgConvertCoinToEvm { // Hexadecimal address of the ERC20 token to which the `FunToken` maps string to_eth_addr = 1 [ (gogoproto.customtype) = "github.com/NibiruChain/nibiru/v2/eth.EIP55Addr", - (gogoproto.nullable) = false + (gogoproto.nullable) = false ]; // Sender: Address for the signer of the transaction. diff --git a/x/evm/events.go b/x/evm/events.go index e6d0b217d..c31cae28e 100644 --- a/x/evm/events.go +++ b/x/evm/events.go @@ -34,46 +34,43 @@ const ( ) func EventTxLogFromABCIEvent(event abci.Event) (*EventTxLog, error) { - typeUrl := TypeUrlEventTxLog typedProtoEvent, err := sdk.ParseTypedEvent(event) if err != nil { return nil, errors.Wrapf( - err, "failed to parse event of type %s", typeUrl) + err, "failed to parse event of type %s", TypeUrlEventTxLog) } typedEvent, ok := (typedProtoEvent).(*EventTxLog) if !ok { return nil, errors.Wrapf( - err, "failed to parse event of type %s", typeUrl) + err, "failed to parse event of type %s", TypeUrlEventTxLog) } return typedEvent, nil } func EventBlockBloomFromABCIEvent(event abci.Event) (*EventBlockBloom, error) { - typeUrl := TypeUrlEventBlockBloom typedProtoEvent, err := sdk.ParseTypedEvent(event) if err != nil { return nil, errors.Wrapf( - err, "failed to parse event of type %s", typeUrl) + err, "failed to parse event of type %s", TypeUrlEventBlockBloom) } typedEvent, ok := (typedProtoEvent).(*EventBlockBloom) if !ok { return nil, errors.Wrapf( - err, "failed to parse event of type %s", typeUrl) + err, "failed to parse event of type %s", TypeUrlEventBlockBloom) } return typedEvent, nil } func EventEthereumTxFromABCIEvent(event abci.Event) (*EventEthereumTx, error) { - typeUrl := TypeUrlEventEthereumTx typedProtoEvent, err := sdk.ParseTypedEvent(event) if err != nil { return nil, errors.Wrapf( - err, "failed to parse event of type %s", typeUrl) + err, "failed to parse event of type %s", TypeUrlEventEthereumTx) } typedEvent, ok := (typedProtoEvent).(*EventEthereumTx) if !ok { return nil, errors.Wrapf( - err, "failed to parse event of type %s", typeUrl) + err, "failed to parse event of type %s", TypeUrlEventEthereumTx) } return typedEvent, nil } diff --git a/x/evm/events.pb.go b/x/evm/events.pb.go index 918018491..e0efcbf02 100644 --- a/x/evm/events.pb.go +++ b/x/evm/events.pb.go @@ -38,8 +38,8 @@ type EventEthereumTx struct { Hash string `protobuf:"bytes,5,opt,name=hash,proto3" json:"hash,omitempty"` // recipient of the transaction Recipient string `protobuf:"bytes,6,opt,name=recipient,proto3" json:"recipient,omitempty"` - // eth_tx_failed contains a VM error should it occur - EthTxFailed string `protobuf:"bytes,7,opt,name=eth_tx_failed,json=ethTxFailed,proto3" json:"eth_tx_failed,omitempty"` + // vm_error contains a VM error should it occur + VmError string `protobuf:"bytes,7,opt,name=vm_error,json=vmError,proto3" json:"vm_error,omitempty"` } func (m *EventEthereumTx) Reset() { *m = EventEthereumTx{} } @@ -117,9 +117,9 @@ func (m *EventEthereumTx) GetRecipient() string { return "" } -func (m *EventEthereumTx) GetEthTxFailed() string { +func (m *EventEthereumTx) GetVmError() string { if m != nil { - return m.EthTxFailed + return m.VmError } return "" } @@ -127,7 +127,7 @@ func (m *EventEthereumTx) GetEthTxFailed() string { // EventTxLog defines the event for an Ethereum transaction log type EventTxLog struct { // tx_logs is an array of transaction logs - TxLogs []string `protobuf:"bytes,1,rep,name=tx_logs,json=txLogs,proto3" json:"tx_logs,omitempty"` + Logs []Log `protobuf:"bytes,1,rep,name=logs,proto3" json:"logs"` } func (m *EventTxLog) Reset() { *m = EventTxLog{} } @@ -163,9 +163,9 @@ func (m *EventTxLog) XXX_DiscardUnknown() { var xxx_messageInfo_EventTxLog proto.InternalMessageInfo -func (m *EventTxLog) GetTxLogs() []string { +func (m *EventTxLog) GetLogs() []Log { if m != nil { - return m.TxLogs + return m.Logs } return nil } @@ -535,46 +535,47 @@ func init() { func init() { proto.RegisterFile("eth/evm/v1/events.proto", fileDescriptor_f8bc26b53c788f17) } var fileDescriptor_f8bc26b53c788f17 = []byte{ - // 618 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x54, 0x4b, 0x6e, 0xd4, 0x40, - 0x10, 0x1d, 0xe7, 0x37, 0x99, 0x0e, 0xe1, 0xd3, 0x1a, 0x12, 0x27, 0x02, 0x27, 0x32, 0xe2, 0xb7, - 0xb1, 0x99, 0xc0, 0x8a, 0x15, 0xcc, 0x64, 0x22, 0x16, 0x80, 0x50, 0x34, 0x6c, 0x90, 0x90, 0xd5, - 0xb6, 0x2b, 0xb6, 0x15, 0xbb, 0x2b, 0xea, 0x6e, 0x5b, 0xce, 0x2d, 0x38, 0x0a, 0xc7, 0x88, 0xc4, - 0x26, 0x3b, 0x58, 0x45, 0x28, 0xb9, 0x01, 0x27, 0x40, 0xdd, 0x76, 0x32, 0x09, 0x28, 0x1b, 0xd8, - 0x55, 0xbd, 0xfa, 0x74, 0xbd, 0xaa, 0x67, 0x93, 0x55, 0x50, 0xa9, 0x0f, 0x55, 0xe1, 0x57, 0x03, - 0x1f, 0x2a, 0xe0, 0x4a, 0x7a, 0x07, 0x02, 0x15, 0x52, 0x02, 0x2a, 0xf5, 0xa0, 0x2a, 0xbc, 0x6a, - 0xb0, 0xee, 0x44, 0x28, 0x0b, 0x94, 0x7e, 0xc8, 0x24, 0xf8, 0xd5, 0x20, 0x04, 0xc5, 0x06, 0x7e, - 0x84, 0x19, 0x6f, 0x72, 0xd7, 0xfb, 0x09, 0x26, 0x68, 0x4c, 0x5f, 0x5b, 0x0d, 0xea, 0x7e, 0xb3, - 0xc8, 0xad, 0xb1, 0x6e, 0x39, 0x56, 0x29, 0x08, 0x28, 0x8b, 0x49, 0x4d, 0x57, 0xc8, 0x02, 0x2b, - 0xb0, 0xe4, 0xca, 0xb6, 0x36, 0xad, 0x27, 0xbd, 0xdd, 0xd6, 0xa3, 0x6b, 0x64, 0x11, 0x54, 0x1a, - 0xa4, 0x4c, 0xa6, 0xf6, 0x8c, 0x89, 0x74, 0x41, 0xa5, 0x6f, 0x98, 0x4c, 0x69, 0x9f, 0xcc, 0x67, - 0x3c, 0x86, 0xda, 0x9e, 0x35, 0x78, 0xe3, 0xe8, 0x82, 0x84, 0xc9, 0xa0, 0x94, 0x10, 0xdb, 0x73, - 0x4d, 0x41, 0xc2, 0xe4, 0x47, 0x09, 0x31, 0xa5, 0x64, 0xce, 0xf4, 0x99, 0x37, 0xb0, 0xb1, 0xe9, - 0x3d, 0xd2, 0x13, 0x10, 0x65, 0x07, 0x19, 0x70, 0x65, 0x2f, 0x98, 0xc0, 0x14, 0xa0, 0x2e, 0x59, - 0xd6, 0xaf, 0xab, 0x3a, 0xd8, 0x63, 0x59, 0x0e, 0xb1, 0xdd, 0x35, 0x19, 0x4b, 0xa0, 0xd2, 0x49, - 0xbd, 0x63, 0x20, 0xf7, 0x21, 0x21, 0x86, 0xcc, 0xa4, 0x7e, 0x8b, 0x09, 0x5d, 0x25, 0x5d, 0x55, - 0x07, 0x39, 0x26, 0xd2, 0xb6, 0x36, 0x67, 0x35, 0x11, 0xa5, 0x71, 0xe9, 0x3e, 0x6e, 0x39, 0x0f, - 0x73, 0x8c, 0xf6, 0x87, 0x39, 0x62, 0xa1, 0x09, 0x84, 0xda, 0x68, 0x29, 0x37, 0x8e, 0xfb, 0xd5, - 0x22, 0x7d, 0x93, 0xb9, 0x53, 0xf2, 0x09, 0xee, 0x03, 0x1f, 0x09, 0x60, 0x0a, 0x62, 0x7a, 0x9f, - 0x90, 0x90, 0xf1, 0xfd, 0x20, 0x06, 0x7e, 0x51, 0xd3, 0xd3, 0xc8, 0xb6, 0x06, 0xe8, 0x0b, 0xb2, - 0x02, 0x22, 0xda, 0x7a, 0x16, 0x44, 0xc8, 0x95, 0x60, 0x91, 0x0a, 0x58, 0x1c, 0x0b, 0x90, 0xb2, - 0xdd, 0x5b, 0xdf, 0x44, 0x47, 0x6d, 0xf0, 0x75, 0x13, 0xa3, 0x36, 0xe9, 0x46, 0xba, 0x3f, 0x8a, - 0x76, 0x8d, 0xe7, 0x2e, 0x7d, 0x4a, 0xee, 0x64, 0x32, 0x28, 0x58, 0x0c, 0xc1, 0x9e, 0xc0, 0x22, - 0xd0, 0x67, 0x35, 0x1b, 0x5d, 0xdc, 0xbd, 0x99, 0xc9, 0x77, 0x2c, 0x86, 0x1d, 0x81, 0xc5, 0x08, - 0x33, 0xee, 0x7e, 0xb7, 0xc8, 0x5d, 0x33, 0xf2, 0x08, 0x79, 0x05, 0x42, 0x69, 0x70, 0x82, 0xe3, - 0xaa, 0xd0, 0x67, 0x95, 0xc0, 0x63, 0x10, 0xe7, 0x67, 0x6d, 0xbc, 0x7f, 0x1c, 0xd6, 0x21, 0x4b, - 0x0a, 0x03, 0x7d, 0x11, 0x9d, 0xdd, 0x0e, 0xdc, 0x53, 0x38, 0x56, 0xa9, 0x4e, 0xa1, 0x1f, 0x88, - 0xd9, 0xc7, 0x74, 0xd4, 0xa5, 0xad, 0x35, 0xaf, 0x91, 0xa8, 0xa7, 0x25, 0xea, 0xb5, 0x12, 0xf5, - 0xf4, 0x80, 0x43, 0xfb, 0xe8, 0x64, 0xa3, 0xf3, 0xeb, 0x64, 0xe3, 0xf6, 0x21, 0x2b, 0xf2, 0x97, - 0xee, 0x45, 0xa5, 0xbb, 0xbb, 0xa8, 0x6d, 0xc3, 0xec, 0x33, 0x59, 0x6e, 0x8e, 0x2b, 0x18, 0x97, - 0x7b, 0x20, 0xae, 0x25, 0x74, 0x45, 0x47, 0x33, 0x7f, 0xea, 0x68, 0xaa, 0xee, 0xd9, 0xcb, 0xea, - 0x76, 0x27, 0xd3, 0xbd, 0x19, 0xa2, 0xdb, 0x70, 0x90, 0xe3, 0x21, 0xc4, 0xd7, 0x3e, 0xf3, 0x80, - 0x2c, 0x5f, 0xd9, 0x58, 0xfb, 0xd4, 0x8d, 0xe8, 0xd2, 0xa6, 0xfe, 0xea, 0x3a, 0xae, 0x21, 0x2a, - 0xd5, 0x7f, 0x76, 0x1d, 0xbe, 0x3a, 0x3a, 0x75, 0xac, 0xe3, 0x53, 0xc7, 0xfa, 0x79, 0xea, 0x58, - 0x5f, 0xce, 0x9c, 0xce, 0xf1, 0x99, 0xd3, 0xf9, 0x71, 0xe6, 0x74, 0x3e, 0x3d, 0x4a, 0x32, 0x95, - 0x96, 0xa1, 0x17, 0x61, 0xe1, 0xbf, 0xcf, 0xc2, 0x4c, 0x94, 0xa3, 0x94, 0x65, 0xdc, 0xe7, 0xc6, - 0xf6, 0xab, 0x2d, 0xbf, 0xd6, 0x7f, 0x92, 0x70, 0xc1, 0x7c, 0xfe, 0xcf, 0x7f, 0x07, 0x00, 0x00, - 0xff, 0xff, 0x1c, 0xa0, 0xad, 0x46, 0x5b, 0x04, 0x00, 0x00, + // 628 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x54, 0xcf, 0x6e, 0xd3, 0x4e, + 0x10, 0x8e, 0xdb, 0xf4, 0x4f, 0xb6, 0xbf, 0xfe, 0x0a, 0x56, 0x28, 0x6e, 0x05, 0x6e, 0x65, 0x24, + 0x68, 0x2f, 0x36, 0x09, 0x48, 0x48, 0x9c, 0x20, 0x69, 0x2a, 0x0e, 0x05, 0xa1, 0x28, 0x5c, 0x90, + 0x90, 0xb5, 0xb6, 0xa7, 0xb6, 0xd5, 0xec, 0x4e, 0xb5, 0xbb, 0xb6, 0xd2, 0xb7, 0xe0, 0x51, 0x78, + 0x06, 0x4e, 0x3d, 0xf6, 0x06, 0xa7, 0x0a, 0xb5, 0x6f, 0xc0, 0x13, 0xa0, 0x5d, 0xbb, 0x4d, 0x03, + 0xea, 0x05, 0x6e, 0x33, 0xdf, 0xfc, 0xd9, 0x99, 0x6f, 0x3e, 0x2d, 0xb9, 0x0f, 0x2a, 0x0b, 0xa0, + 0x64, 0x41, 0xd9, 0x09, 0xa0, 0x04, 0xae, 0xa4, 0x7f, 0x2c, 0x50, 0xa1, 0x4d, 0x40, 0x65, 0x3e, + 0x94, 0xcc, 0x2f, 0x3b, 0x9b, 0x6e, 0x8c, 0x92, 0xa1, 0x0c, 0x22, 0x2a, 0x21, 0x28, 0x3b, 0x11, + 0x28, 0xda, 0x09, 0x62, 0xcc, 0x79, 0x95, 0xbb, 0xd9, 0x4e, 0x31, 0x45, 0x63, 0x06, 0xda, 0xba, + 0x42, 0x67, 0x5a, 0xb3, 0x0a, 0xf5, 0xbe, 0x5a, 0x64, 0x6d, 0xa0, 0x1f, 0x1a, 0xa8, 0x0c, 0x04, + 0x14, 0x6c, 0x34, 0xb1, 0xd7, 0xc9, 0x22, 0x65, 0x58, 0x70, 0xe5, 0x58, 0xdb, 0xd6, 0x4e, 0x6b, + 0x58, 0x7b, 0xf6, 0x06, 0x59, 0x06, 0x95, 0x85, 0x19, 0x95, 0x99, 0x33, 0x67, 0x22, 0x4b, 0xa0, + 0xb2, 0x37, 0x54, 0x66, 0x76, 0x9b, 0x2c, 0xe4, 0x3c, 0x81, 0x89, 0x33, 0x6f, 0xf0, 0xca, 0xd1, + 0x05, 0x29, 0x95, 0x61, 0x21, 0x21, 0x71, 0x9a, 0x55, 0x41, 0x4a, 0xe5, 0x07, 0x09, 0x89, 0x6d, + 0x93, 0xa6, 0xe9, 0xb3, 0x60, 0x60, 0x63, 0xdb, 0x0f, 0x48, 0x4b, 0x40, 0x9c, 0x1f, 0xe7, 0xc0, + 0x95, 0xb3, 0x68, 0x02, 0x53, 0x40, 0x37, 0x2b, 0x59, 0x08, 0x42, 0xa0, 0x70, 0x96, 0xaa, 0x66, + 0x25, 0x1b, 0x68, 0xd7, 0x7b, 0x41, 0x88, 0xd9, 0x61, 0x34, 0x39, 0xc0, 0xd4, 0xde, 0x25, 0xcd, + 0x31, 0xa6, 0xd2, 0xb1, 0xb6, 0xe7, 0x77, 0x56, 0xba, 0x6b, 0xfe, 0x94, 0x39, 0xff, 0x00, 0xd3, + 0x5e, 0xf3, 0xf4, 0x7c, 0xab, 0x31, 0x34, 0x29, 0xde, 0x93, 0x7a, 0xf9, 0xde, 0x18, 0xe3, 0xa3, + 0xde, 0x18, 0x91, 0xe9, 0x4d, 0x22, 0x6d, 0xd4, 0xbb, 0x57, 0x8e, 0xf7, 0xc5, 0x22, 0x6d, 0x93, + 0xb9, 0x5f, 0xf0, 0x11, 0x1e, 0x01, 0xef, 0x0b, 0xa0, 0x0a, 0x12, 0xfb, 0x21, 0x21, 0x11, 0xe5, + 0x47, 0x61, 0x02, 0xfc, 0xba, 0xa6, 0xa5, 0x91, 0x3d, 0x0d, 0xd8, 0xcf, 0xc9, 0x3a, 0x88, 0xb8, + 0xfb, 0x34, 0x8c, 0x91, 0x2b, 0x41, 0x63, 0x15, 0xd2, 0x24, 0x11, 0x20, 0x65, 0x4d, 0x60, 0xdb, + 0x44, 0xfb, 0x75, 0xf0, 0x75, 0x15, 0xb3, 0x1d, 0xb2, 0x14, 0xeb, 0xfe, 0x28, 0x6a, 0x3e, 0xaf, + 0x5c, 0x7b, 0x97, 0xdc, 0xcd, 0x65, 0xc8, 0x68, 0x02, 0xe1, 0xa1, 0x40, 0x16, 0xea, 0xab, 0x1b, + 0x6a, 0x97, 0x87, 0xff, 0xe7, 0xf2, 0x2d, 0x4d, 0x60, 0x5f, 0x20, 0xeb, 0x63, 0xce, 0xbd, 0x6f, + 0x16, 0xb9, 0x67, 0x46, 0xee, 0x23, 0x2f, 0x41, 0x28, 0x0d, 0x8e, 0x70, 0x50, 0x32, 0x7d, 0x5f, + 0x09, 0x3c, 0x01, 0x71, 0x75, 0xdf, 0xca, 0xfb, 0xcb, 0x61, 0x5d, 0xb2, 0xa2, 0x30, 0xd4, 0xc2, + 0xd0, 0xd9, 0xf5, 0xc0, 0x2d, 0x85, 0x03, 0x95, 0xe9, 0x14, 0xfb, 0x3d, 0x31, 0x7c, 0x4c, 0x47, + 0x5d, 0xe9, 0x6e, 0xf8, 0x95, 0x82, 0x7d, 0xad, 0x60, 0xbf, 0x56, 0xb0, 0xaf, 0x07, 0xec, 0x39, + 0xfa, 0x3a, 0x3f, 0xcf, 0xb7, 0xee, 0x9c, 0x50, 0x36, 0x7e, 0xe9, 0x5d, 0x57, 0x7a, 0xc3, 0x65, + 0x6d, 0x9b, 0xcd, 0x3e, 0x91, 0xd5, 0xea, 0xdc, 0x82, 0x72, 0x79, 0x08, 0xe2, 0xd6, 0x85, 0x66, + 0x04, 0x35, 0xf7, 0xbb, 0xa0, 0xa6, 0x32, 0x9f, 0xbf, 0x29, 0x73, 0x6f, 0x34, 0xe5, 0xcd, 0x2c, + 0xba, 0x07, 0xc7, 0x63, 0x3c, 0x81, 0xe4, 0xd6, 0x67, 0x1e, 0x91, 0xd5, 0x19, 0xc6, 0xea, 0xa7, + 0xfe, 0x8b, 0x6f, 0x30, 0xf5, 0x47, 0xd7, 0xc1, 0x04, 0xe2, 0x42, 0xfd, 0x63, 0xd7, 0xde, 0xab, + 0xd3, 0x0b, 0xd7, 0x3a, 0xbb, 0x70, 0xad, 0x1f, 0x17, 0xae, 0xf5, 0xf9, 0xd2, 0x6d, 0x9c, 0x5d, + 0xba, 0x8d, 0xef, 0x97, 0x6e, 0xe3, 0xe3, 0xe3, 0x34, 0x57, 0x59, 0x11, 0xf9, 0x31, 0xb2, 0xe0, + 0x5d, 0x1e, 0xe5, 0xa2, 0xe8, 0x67, 0x34, 0xe7, 0x01, 0x37, 0x76, 0x50, 0x76, 0x83, 0x89, 0xfe, + 0x06, 0xa2, 0x45, 0xf3, 0x0f, 0x3c, 0xfb, 0x15, 0x00, 0x00, 0xff, 0xff, 0x52, 0xaf, 0x8b, 0xfe, + 0x7a, 0x04, 0x00, 0x00, } func (m *EventEthereumTx) Marshal() (dAtA []byte, err error) { @@ -597,10 +598,10 @@ func (m *EventEthereumTx) MarshalToSizedBuffer(dAtA []byte) (int, error) { _ = i var l int _ = l - if len(m.EthTxFailed) > 0 { - i -= len(m.EthTxFailed) - copy(dAtA[i:], m.EthTxFailed) - i = encodeVarintEvents(dAtA, i, uint64(len(m.EthTxFailed))) + if len(m.VmError) > 0 { + i -= len(m.VmError) + copy(dAtA[i:], m.VmError) + i = encodeVarintEvents(dAtA, i, uint64(len(m.VmError))) i-- dAtA[i] = 0x3a } @@ -669,11 +670,16 @@ func (m *EventTxLog) MarshalToSizedBuffer(dAtA []byte) (int, error) { _ = i var l int _ = l - if len(m.TxLogs) > 0 { - for iNdEx := len(m.TxLogs) - 1; iNdEx >= 0; iNdEx-- { - i -= len(m.TxLogs[iNdEx]) - copy(dAtA[i:], m.TxLogs[iNdEx]) - i = encodeVarintEvents(dAtA, i, uint64(len(m.TxLogs[iNdEx]))) + 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 = encodeVarintEvents(dAtA, i, uint64(size)) + } i-- dAtA[i] = 0xa } @@ -978,7 +984,7 @@ func (m *EventEthereumTx) Size() (n int) { if l > 0 { n += 1 + l + sovEvents(uint64(l)) } - l = len(m.EthTxFailed) + l = len(m.VmError) if l > 0 { n += 1 + l + sovEvents(uint64(l)) } @@ -991,9 +997,9 @@ func (m *EventTxLog) Size() (n int) { } var l int _ = l - if len(m.TxLogs) > 0 { - for _, s := range m.TxLogs { - l = len(s) + if len(m.Logs) > 0 { + for _, e := range m.Logs { + l = e.Size() n += 1 + l + sovEvents(uint64(l)) } } @@ -1344,7 +1350,7 @@ func (m *EventEthereumTx) Unmarshal(dAtA []byte) error { iNdEx = postIndex case 7: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field EthTxFailed", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field VmError", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -1372,7 +1378,7 @@ func (m *EventEthereumTx) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.EthTxFailed = string(dAtA[iNdEx:postIndex]) + m.VmError = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex @@ -1426,9 +1432,9 @@ func (m *EventTxLog) Unmarshal(dAtA []byte) error { switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field TxLogs", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Logs", wireType) } - var stringLen uint64 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowEvents @@ -1438,23 +1444,25 @@ func (m *EventTxLog) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - stringLen |= uint64(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - intStringLen := int(stringLen) - if intStringLen < 0 { + if msglen < 0 { return ErrInvalidLengthEvents } - postIndex := iNdEx + intStringLen + postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthEvents } if postIndex > l { return io.ErrUnexpectedEOF } - m.TxLogs = append(m.TxLogs, string(dAtA[iNdEx:postIndex])) + 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 diff --git a/x/evm/evm.pb.go b/x/evm/evm.pb.go index 59bdc4cbe..fac1e30bb 100644 --- a/x/evm/evm.pb.go +++ b/x/evm/evm.pb.go @@ -200,63 +200,6 @@ func (m *State) GetValue() string { 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 of the transaction - Hash string `protobuf:"bytes,1,opt,name=hash,proto3" json:"hash,omitempty"` - // logs is an array of Logs for the given transaction hash - 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_98abbdadb327b7d0, []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. @@ -290,7 +233,7 @@ 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_98abbdadb327b7d0, []int{4} + return fileDescriptor_98abbdadb327b7d0, []int{3} } func (m *Log) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -382,58 +325,6 @@ func (m *Log) GetRemoved() bool { 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_98abbdadb327b7d0, []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 { // address is a hex formatted ethereum address @@ -446,7 +337,7 @@ 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_98abbdadb327b7d0, []int{6} + return fileDescriptor_98abbdadb327b7d0, []int{4} } func (m *AccessTuple) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -475,7 +366,8 @@ func (m *AccessTuple) XXX_DiscardUnknown() { var xxx_messageInfo_AccessTuple proto.InternalMessageInfo -// TracerConfig stores additional tracer args. For geth it's only one attr: onlyTopCall +// TracerConfig stores additional tracer args. For geth it's only one attr: +// onlyTopCall type TracerConfig struct { OnlyTopCall bool `protobuf:"varint,1,opt,name=only_top_call,json=onlyTopCall,proto3" json:"onlyTopCall"` } @@ -484,7 +376,7 @@ func (m *TracerConfig) Reset() { *m = TracerConfig{} } func (m *TracerConfig) String() string { return proto.CompactTextString(m) } func (*TracerConfig) ProtoMessage() {} func (*TracerConfig) Descriptor() ([]byte, []int) { - return fileDescriptor_98abbdadb327b7d0, []int{7} + return fileDescriptor_98abbdadb327b7d0, []int{5} } func (m *TracerConfig) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -549,7 +441,7 @@ 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_98abbdadb327b7d0, []int{8} + return fileDescriptor_98abbdadb327b7d0, []int{6} } func (m *TraceConfig) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -652,9 +544,7 @@ func init() { proto.RegisterType((*FunToken)(nil), "eth.evm.v1.FunToken") proto.RegisterType((*Params)(nil), "eth.evm.v1.Params") proto.RegisterType((*State)(nil), "eth.evm.v1.State") - proto.RegisterType((*TransactionLogs)(nil), "eth.evm.v1.TransactionLogs") proto.RegisterType((*Log)(nil), "eth.evm.v1.Log") - proto.RegisterType((*TxResult)(nil), "eth.evm.v1.TxResult") proto.RegisterType((*AccessTuple)(nil), "eth.evm.v1.AccessTuple") proto.RegisterType((*TracerConfig)(nil), "eth.evm.v1.TracerConfig") proto.RegisterType((*TraceConfig)(nil), "eth.evm.v1.TraceConfig") @@ -663,77 +553,67 @@ func init() { func init() { proto.RegisterFile("eth/evm/v1/evm.proto", fileDescriptor_98abbdadb327b7d0) } var fileDescriptor_98abbdadb327b7d0 = []byte{ - // 1113 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x84, 0x55, 0x31, 0x6f, 0xdb, 0x46, - 0x14, 0xb6, 0x2c, 0x4a, 0xa2, 0x4e, 0x72, 0xc4, 0x5c, 0xdc, 0x94, 0x4d, 0x10, 0xd3, 0x60, 0x81, - 0xc2, 0x05, 0x02, 0xa9, 0x71, 0x90, 0x0e, 0xe9, 0x52, 0xcb, 0xb1, 0x51, 0xab, 0x76, 0x1a, 0x5c, - 0x9c, 0x0e, 0x5d, 0x88, 0x13, 0xf9, 0x4c, 0x11, 0x22, 0x79, 0xc2, 0xdd, 0x51, 0x90, 0x7e, 0x40, - 0x81, 0x8e, 0xfd, 0x09, 0xd9, 0xfb, 0x47, 0x82, 0x4e, 0x19, 0x8b, 0x0e, 0x44, 0xe1, 0x2c, 0x85, - 0x46, 0x4f, 0x45, 0xa7, 0xe2, 0x8e, 0x94, 0x25, 0xbb, 0x40, 0x3b, 0xe9, 0x7d, 0xdf, 0xbb, 0xf7, - 0xde, 0xf1, 0x7b, 0x1f, 0x45, 0xb4, 0x0d, 0x72, 0xd4, 0x83, 0x69, 0xd2, 0x9b, 0x3e, 0x51, 0x3f, - 0xdd, 0x09, 0x67, 0x92, 0x61, 0x04, 0x72, 0xd4, 0x55, 0x70, 0xfa, 0xe4, 0xc1, 0x76, 0xc8, 0x42, - 0xa6, 0xe9, 0x9e, 0x8a, 0x8a, 0x13, 0xee, 0x2f, 0x15, 0x64, 0x1e, 0x67, 0xe9, 0x39, 0x1b, 0x43, - 0x8a, 0xdf, 0x20, 0x04, 0xdc, 0xdf, 0xff, 0xc2, 0xa3, 0x41, 0xc0, 0xed, 0xca, 0x6e, 0x65, 0xaf, - 0xd9, 0xff, 0xf2, 0x5d, 0xee, 0x6c, 0xfc, 0x9e, 0x3b, 0xdd, 0x30, 0x92, 0xa3, 0x6c, 0xd8, 0xf5, - 0x59, 0xd2, 0x7b, 0x19, 0x0d, 0x23, 0x9e, 0x1d, 0x8e, 0x68, 0x94, 0xf6, 0x52, 0x1d, 0xf7, 0xa6, - 0xfb, 0x3d, 0x35, 0xeb, 0xe8, 0xe4, 0xd5, 0xb3, 0x67, 0x07, 0x41, 0xc0, 0x49, 0x53, 0x77, 0x52, - 0x21, 0x7e, 0x84, 0xd0, 0x90, 0xa6, 0x63, 0x2f, 0x80, 0x94, 0x25, 0xf6, 0xa6, 0x6a, 0x4b, 0x9a, - 0x8a, 0x79, 0xa1, 0x08, 0xfc, 0x39, 0xba, 0x1b, 0x09, 0x2f, 0xa1, 0x01, 0x78, 0x17, 0x9c, 0x25, - 0x9e, 0xcf, 0xa2, 0xd4, 0xae, 0xee, 0x56, 0xf6, 0x4c, 0x72, 0x27, 0x12, 0x67, 0x34, 0x80, 0x63, - 0xce, 0x92, 0x43, 0x16, 0xa5, 0xee, 0x5f, 0x15, 0x54, 0x7f, 0x45, 0x39, 0x4d, 0x04, 0x3e, 0x40, - 0x08, 0x66, 0x92, 0x53, 0x0f, 0xa2, 0x89, 0xb0, 0x8d, 0xdd, 0xea, 0x5e, 0xb5, 0xef, 0x5e, 0xe6, - 0x4e, 0xf3, 0x48, 0xb1, 0x47, 0x27, 0xaf, 0xc4, 0x55, 0xee, 0xdc, 0x9d, 0xd3, 0x24, 0x7e, 0xee, - 0xae, 0x0e, 0xba, 0xa4, 0xa9, 0xc1, 0x51, 0x34, 0x11, 0x78, 0x1f, 0xb5, 0x61, 0x9a, 0x78, 0xfe, - 0x88, 0xa6, 0x29, 0xc4, 0xc2, 0x36, 0x77, 0xab, 0x7b, 0xcd, 0x7e, 0xe7, 0x32, 0x77, 0x5a, 0x47, - 0xdf, 0x9f, 0x1d, 0x96, 0x34, 0x69, 0xc1, 0x34, 0x59, 0x02, 0x7c, 0x86, 0xee, 0xf9, 0x1c, 0xa8, - 0x04, 0xef, 0x22, 0x4b, 0xa5, 0x52, 0xcd, 0xbb, 0x00, 0xb0, 0x9b, 0x5a, 0xab, 0x47, 0xa5, 0x56, - 0x1f, 0xf9, 0x4c, 0x24, 0x4c, 0x88, 0x60, 0xdc, 0x8d, 0x58, 0x2f, 0xa1, 0x72, 0xd4, 0x3d, 0x49, - 0x25, 0xb9, 0x5b, 0x54, 0x1e, 0x97, 0x85, 0xc7, 0x00, 0xcf, 0x8d, 0x3f, 0xdf, 0x3a, 0x95, 0x81, - 0x61, 0x56, 0xac, 0xcd, 0x81, 0x61, 0x6e, 0x5a, 0xd5, 0x81, 0x61, 0x56, 0x2d, 0x63, 0x60, 0x98, - 0x35, 0xab, 0x3e, 0x30, 0xcc, 0xba, 0xd5, 0x18, 0x18, 0x66, 0xc3, 0x32, 0xdd, 0x1e, 0xaa, 0xbd, - 0x96, 0x54, 0x02, 0xb6, 0x50, 0x75, 0x0c, 0xf3, 0x62, 0x3b, 0x44, 0x85, 0x78, 0x1b, 0xd5, 0xa6, - 0x34, 0xce, 0xa0, 0x94, 0xb6, 0x00, 0xee, 0x00, 0x75, 0xce, 0x39, 0x4d, 0x05, 0xf5, 0x65, 0xc4, - 0xd2, 0x53, 0x16, 0x0a, 0x8c, 0x91, 0x31, 0xa2, 0x62, 0x54, 0xd6, 0xea, 0x18, 0x7f, 0x8a, 0x8c, - 0x98, 0x85, 0xc2, 0xde, 0xdc, 0xad, 0xee, 0xb5, 0xf6, 0x3b, 0xdd, 0x95, 0x63, 0xba, 0xa7, 0x2c, - 0x24, 0x3a, 0xe9, 0xfe, 0xba, 0x89, 0xaa, 0xa7, 0x2c, 0xc4, 0x36, 0x6a, 0x28, 0x6b, 0x80, 0x10, - 0x65, 0x8f, 0x25, 0xc4, 0xf7, 0x51, 0x5d, 0xb2, 0x49, 0xe4, 0x17, 0x8d, 0x9a, 0xa4, 0x44, 0x6a, - 0x64, 0x40, 0x25, 0xd5, 0xfb, 0x6c, 0x13, 0x1d, 0x2b, 0xdd, 0x87, 0x31, 0xf3, 0xc7, 0x5e, 0x9a, - 0x25, 0x43, 0xe0, 0xb6, 0xb1, 0x5b, 0xd9, 0x33, 0xfa, 0x9d, 0x45, 0xee, 0xb4, 0x34, 0xff, 0x52, - 0xd3, 0x64, 0x1d, 0xe0, 0xc7, 0xa8, 0x21, 0x67, 0x9e, 0xbe, 0x7d, 0x4d, 0x6b, 0x7d, 0x6f, 0x91, - 0x3b, 0x1d, 0xb9, 0x7a, 0xc0, 0x6f, 0xa8, 0x18, 0x91, 0xba, 0x9c, 0xa9, 0x5f, 0xdc, 0x43, 0xa6, - 0x9c, 0x79, 0x51, 0x1a, 0xc0, 0xcc, 0xae, 0xeb, 0xee, 0xdb, 0x8b, 0xdc, 0xb1, 0xd6, 0x8e, 0x9f, - 0xa8, 0x1c, 0x69, 0xc8, 0x99, 0x0e, 0xf0, 0x63, 0x84, 0x8a, 0x2b, 0xe9, 0x09, 0x0d, 0x3d, 0x61, - 0x6b, 0x91, 0x3b, 0x4d, 0xcd, 0xea, 0xde, 0xab, 0x10, 0xbb, 0xa8, 0x56, 0xf4, 0x36, 0x75, 0xef, - 0xf6, 0x22, 0x77, 0xcc, 0x98, 0x85, 0x45, 0xcf, 0x22, 0xa5, 0xa4, 0xe2, 0x90, 0xb0, 0x29, 0x04, - 0xda, 0x1c, 0x26, 0x59, 0x42, 0xf7, 0xc7, 0x4d, 0x64, 0x9e, 0xcf, 0x08, 0x88, 0x2c, 0x96, 0xf8, - 0x18, 0x59, 0x3e, 0x4b, 0x25, 0xa7, 0xbe, 0xf4, 0x6e, 0x48, 0xdb, 0x7f, 0x78, 0x95, 0x3b, 0x1f, - 0x17, 0xfe, 0xbd, 0x7d, 0xc2, 0x25, 0x9d, 0x25, 0x75, 0x50, 0xea, 0xbf, 0x8d, 0x6a, 0xc3, 0x98, - 0x95, 0xaf, 0x57, 0x9b, 0x14, 0x00, 0x9f, 0x6a, 0xd5, 0xf4, 0x7e, 0xd5, 0x02, 0x5a, 0xfb, 0x0f, - 0xd7, 0xf7, 0x7b, 0xcb, 0x1e, 0xfd, 0xfb, 0xca, 0xbe, 0x57, 0xb9, 0x73, 0xa7, 0x98, 0x5a, 0x56, - 0xba, 0x4a, 0x55, 0x6d, 0x1f, 0x0b, 0x55, 0x39, 0x48, 0xbd, 0xae, 0x36, 0x51, 0x21, 0x7e, 0x80, - 0x4c, 0x0e, 0x53, 0xe0, 0x12, 0x02, 0xbd, 0x16, 0x93, 0x5c, 0x63, 0xfc, 0x09, 0x32, 0x43, 0x2a, - 0xbc, 0x4c, 0x40, 0x50, 0xec, 0x80, 0x34, 0x42, 0x2a, 0xde, 0x08, 0x08, 0x9e, 0x1b, 0x3f, 0xbd, - 0x75, 0x36, 0x5c, 0x8a, 0x5a, 0x07, 0xbe, 0x0f, 0x42, 0x9c, 0x67, 0x93, 0x18, 0xfe, 0xc3, 0x5b, - 0xfb, 0xa8, 0x2d, 0x24, 0xe3, 0x34, 0x04, 0x6f, 0x0c, 0xf3, 0xd2, 0x61, 0x85, 0x5f, 0x4a, 0xfe, - 0x5b, 0x98, 0x0b, 0xb2, 0x0e, 0xca, 0x11, 0x87, 0xa8, 0x7d, 0xce, 0xa9, 0x0f, 0xfc, 0x90, 0xa5, - 0x17, 0x51, 0x88, 0x9f, 0xa2, 0x2d, 0x96, 0xc6, 0x73, 0x4f, 0xb2, 0x89, 0xe7, 0xd3, 0x38, 0xd6, - 0x93, 0xcc, 0xa2, 0x95, 0x4a, 0x9c, 0xb3, 0xc9, 0x21, 0x8d, 0x63, 0xb2, 0x0e, 0xdc, 0xbf, 0xab, - 0xa8, 0xa5, 0xbb, 0x94, 0x4d, 0x94, 0xd5, 0x75, 0xd3, 0xf2, 0x9e, 0x25, 0x52, 0x0f, 0x20, 0xa3, - 0x04, 0x58, 0x26, 0xcb, 0x17, 0x71, 0x09, 0x55, 0x05, 0x07, 0x98, 0x81, 0xaf, 0xb7, 0x60, 0x90, - 0x12, 0xe1, 0x67, 0x68, 0x2b, 0x88, 0x04, 0x1d, 0xc6, 0xe0, 0x09, 0x49, 0xfd, 0x71, 0xa1, 0x61, - 0xdf, 0x5a, 0xe4, 0x4e, 0xbb, 0x4c, 0xbc, 0x56, 0x3c, 0xb9, 0x81, 0xf0, 0x57, 0xa8, 0xb3, 0x2a, - 0xd3, 0x8f, 0xac, 0x05, 0x36, 0xfb, 0x78, 0x91, 0x3b, 0x77, 0xae, 0x8f, 0xea, 0x0c, 0xb9, 0x85, - 0x95, 0x51, 0x02, 0x18, 0x66, 0xa1, 0xf6, 0xae, 0x49, 0x0a, 0xa0, 0xd8, 0x38, 0x4a, 0x22, 0xa9, - 0xbd, 0x5a, 0x23, 0x05, 0x50, 0xf7, 0x83, 0x54, 0xcf, 0x49, 0x20, 0x61, 0x7c, 0x6e, 0xb7, 0x56, - 0xf7, 0x2b, 0x12, 0x67, 0x9a, 0x27, 0x37, 0x10, 0xee, 0x23, 0x5c, 0x96, 0x71, 0x90, 0x19, 0x4f, - 0x3d, 0xfd, 0x0f, 0xd0, 0xd6, 0xb5, 0xfa, 0x3d, 0x2c, 0xb2, 0x44, 0x27, 0x5f, 0x50, 0x49, 0xc9, - 0xbf, 0x18, 0xfc, 0x1d, 0xda, 0x2a, 0x64, 0xf5, 0x7c, 0xad, 0xba, 0xbd, 0xa5, 0xfd, 0x6b, 0xdf, - 0xf2, 0xef, 0xf5, 0x6a, 0x8b, 0x4b, 0xc9, 0x35, 0x86, 0xdc, 0x40, 0x03, 0xc3, 0x34, 0xac, 0x5a, - 0xf1, 0x5f, 0x3a, 0x30, 0x4c, 0x64, 0xb5, 0xae, 0x95, 0x29, 0x1f, 0x8e, 0xdc, 0x5b, 0xe2, 0xb5, - 0x5b, 0xf7, 0xbf, 0x7e, 0x77, 0xb9, 0x53, 0x79, 0x7f, 0xb9, 0x53, 0xf9, 0xe3, 0x72, 0xa7, 0xf2, - 0xf3, 0x87, 0x9d, 0x8d, 0xf7, 0x1f, 0x76, 0x36, 0x7e, 0xfb, 0xb0, 0xb3, 0xf1, 0xc3, 0x67, 0xff, - 0xfb, 0x41, 0x9c, 0xa9, 0x2f, 0xf1, 0xb0, 0xae, 0x3f, 0xb4, 0x4f, 0xff, 0x09, 0x00, 0x00, 0xff, - 0xff, 0xab, 0xac, 0xcf, 0xa2, 0xa2, 0x07, 0x00, 0x00, + // 954 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x84, 0x55, 0x41, 0x6f, 0xe3, 0x44, + 0x14, 0xae, 0x1b, 0x27, 0x71, 0x26, 0xe9, 0xd6, 0x9d, 0x16, 0x64, 0x21, 0x6d, 0x1c, 0xf9, 0x80, + 0x82, 0xb4, 0x4a, 0xd8, 0xae, 0xca, 0xa1, 0x5c, 0x68, 0xb2, 0xad, 0x68, 0xa0, 0x4b, 0x35, 0x5b, + 0x38, 0x70, 0xb1, 0x26, 0xf6, 0x6b, 0x62, 0xc5, 0xf6, 0x44, 0x33, 0xe3, 0x28, 0xf9, 0x07, 0x1c, + 0xf9, 0x09, 0x7b, 0xe7, 0x8f, 0xac, 0x38, 0xed, 0x11, 0x71, 0xb0, 0x50, 0x7b, 0x41, 0x39, 0x72, + 0x42, 0x9c, 0xd0, 0x8c, 0xdd, 0x4d, 0x0a, 0x12, 0x9c, 0xfc, 0xbe, 0xef, 0xcd, 0x7b, 0xf3, 0xe6, + 0xfb, 0xc6, 0x36, 0x3a, 0x02, 0x39, 0xed, 0xc3, 0x22, 0xe9, 0x2f, 0x9e, 0xab, 0x47, 0x6f, 0xce, + 0x99, 0x64, 0x18, 0x81, 0x9c, 0xf6, 0x14, 0x5c, 0x3c, 0xff, 0xe8, 0x68, 0xc2, 0x26, 0x4c, 0xd3, + 0x7d, 0x15, 0x15, 0x2b, 0xbc, 0x9f, 0x0c, 0x64, 0x5d, 0x64, 0xe9, 0x0d, 0x9b, 0x41, 0x8a, 0xbf, + 0x45, 0x08, 0x78, 0x70, 0xfc, 0xa9, 0x4f, 0xc3, 0x90, 0x3b, 0x46, 0xc7, 0xe8, 0x36, 0x06, 0x9f, + 0xbd, 0xcd, 0xdd, 0x9d, 0x5f, 0x73, 0xb7, 0x37, 0x89, 0xe4, 0x34, 0x1b, 0xf7, 0x02, 0x96, 0xf4, + 0x5f, 0x45, 0xe3, 0x88, 0x67, 0xc3, 0x29, 0x8d, 0xd2, 0x7e, 0xaa, 0xe3, 0xfe, 0xe2, 0xb8, 0xaf, + 0xf6, 0x3a, 0xbf, 0xbc, 0x3e, 0x39, 0x39, 0x0b, 0x43, 0x4e, 0x1a, 0xba, 0x93, 0x0a, 0xf1, 0x53, + 0x84, 0xc6, 0x34, 0x9d, 0xf9, 0x21, 0xa4, 0x2c, 0x71, 0x76, 0x55, 0x5b, 0xd2, 0x50, 0xcc, 0x4b, + 0x45, 0xe0, 0x4f, 0xd0, 0x41, 0x24, 0xfc, 0x84, 0x86, 0xe0, 0xdf, 0x72, 0x96, 0xf8, 0x01, 0x8b, + 0x52, 0xa7, 0xd2, 0x31, 0xba, 0x16, 0x79, 0x12, 0x89, 0x2b, 0x1a, 0xc2, 0x05, 0x67, 0xc9, 0x90, + 0x45, 0xa9, 0xf7, 0xa7, 0x81, 0x6a, 0xd7, 0x94, 0xd3, 0x44, 0xe0, 0x33, 0x84, 0x60, 0x29, 0x39, + 0xf5, 0x21, 0x9a, 0x0b, 0xc7, 0xec, 0x54, 0xba, 0x95, 0x81, 0x77, 0x97, 0xbb, 0x8d, 0x73, 0xc5, + 0x9e, 0x5f, 0x5e, 0x8b, 0x3f, 0x72, 0xf7, 0x60, 0x45, 0x93, 0xf8, 0xd4, 0xdb, 0x2c, 0xf4, 0x48, + 0x43, 0x83, 0xf3, 0x68, 0x2e, 0xf0, 0x31, 0x6a, 0xc1, 0x22, 0xf1, 0x83, 0x29, 0x4d, 0x53, 0x88, + 0x85, 0x63, 0x75, 0x2a, 0xdd, 0xc6, 0x60, 0xff, 0x2e, 0x77, 0x9b, 0xe7, 0xdf, 0x5d, 0x0d, 0x4b, + 0x9a, 0x34, 0x61, 0x91, 0x3c, 0x00, 0x7c, 0x85, 0x0e, 0x03, 0x0e, 0x54, 0x82, 0x7f, 0x9b, 0xa5, + 0x52, 0xa9, 0xe6, 0xdf, 0x02, 0x38, 0x0d, 0xad, 0xd5, 0xd3, 0x52, 0xab, 0x0f, 0x02, 0x26, 0x12, + 0x26, 0x44, 0x38, 0xeb, 0x45, 0xac, 0x9f, 0x50, 0x39, 0xed, 0x5d, 0xa6, 0x92, 0x1c, 0x14, 0x95, + 0x17, 0x65, 0xe1, 0x05, 0xc0, 0xa9, 0xf9, 0xfb, 0x1b, 0xd7, 0x18, 0x99, 0x96, 0x61, 0xef, 0x8e, + 0x4c, 0x6b, 0xd7, 0xae, 0x8c, 0x4c, 0xab, 0x62, 0x9b, 0x23, 0xd3, 0xaa, 0xda, 0xb5, 0x91, 0x69, + 0xd5, 0xec, 0xfa, 0xc8, 0xb4, 0xea, 0xb6, 0xe5, 0xf5, 0x51, 0xf5, 0xb5, 0xa4, 0x12, 0xb0, 0x8d, + 0x2a, 0x33, 0x58, 0x15, 0xee, 0x10, 0x15, 0xe2, 0x23, 0x54, 0x5d, 0xd0, 0x38, 0x83, 0x52, 0xda, + 0x02, 0x78, 0x3f, 0xef, 0xa2, 0xca, 0xd7, 0x6c, 0x82, 0x1d, 0x54, 0x57, 0x76, 0x82, 0x10, 0x65, + 0xcd, 0x03, 0xc4, 0x1f, 0xa2, 0x9a, 0x64, 0xf3, 0x28, 0x10, 0xce, 0xae, 0x3a, 0x39, 0x29, 0x11, + 0xc6, 0xc8, 0x0c, 0xa9, 0xa4, 0xda, 0x83, 0x16, 0xd1, 0xb1, 0xd2, 0x6a, 0x1c, 0xb3, 0x60, 0xe6, + 0xa7, 0x59, 0x32, 0x06, 0xee, 0x98, 0x1d, 0xa3, 0x6b, 0x0e, 0xf6, 0xd7, 0xb9, 0xdb, 0xd4, 0xfc, + 0x2b, 0x4d, 0x93, 0x6d, 0x80, 0x9f, 0xa1, 0xba, 0x5c, 0xfa, 0x53, 0x2a, 0xa6, 0x4e, 0x55, 0xeb, + 0x73, 0xb8, 0xce, 0xdd, 0x7d, 0xc9, 0x69, 0x2a, 0x68, 0x20, 0x23, 0x96, 0x7e, 0x49, 0xc5, 0x94, + 0xd4, 0xe4, 0x52, 0x3d, 0x71, 0x1f, 0x59, 0x72, 0xe9, 0x47, 0x69, 0x08, 0x4b, 0xa7, 0xa6, 0xbb, + 0x1f, 0xad, 0x73, 0xd7, 0xde, 0x5a, 0x7e, 0xa9, 0x72, 0xa4, 0x2e, 0x97, 0x3a, 0xc0, 0xcf, 0x10, + 0x2a, 0x46, 0xd2, 0x3b, 0xd4, 0xf5, 0x0e, 0x7b, 0xeb, 0xdc, 0x6d, 0x68, 0x56, 0xf7, 0xde, 0x84, + 0xd8, 0x43, 0xd5, 0xa2, 0xb7, 0xa5, 0x7b, 0xb7, 0xd6, 0xb9, 0x6b, 0xc5, 0x6c, 0x52, 0xf4, 0x2c, + 0x52, 0x4a, 0x2a, 0x0e, 0x09, 0x5b, 0x40, 0xa8, 0x0d, 0xb5, 0xc8, 0x03, 0xf4, 0x28, 0x6a, 0x9e, + 0x05, 0x01, 0x08, 0x71, 0x93, 0xcd, 0x63, 0xf8, 0x0f, 0x4d, 0x8f, 0x51, 0x4b, 0x48, 0xc6, 0xe9, + 0x04, 0xfc, 0x19, 0xac, 0x4a, 0x65, 0x0b, 0x9d, 0x4a, 0xfe, 0x2b, 0x58, 0x09, 0xb2, 0x0d, 0x4e, + 0xcd, 0x1f, 0xde, 0xb8, 0x3b, 0xde, 0x10, 0xb5, 0x6e, 0x38, 0x0d, 0x80, 0x0f, 0x59, 0x7a, 0x1b, + 0x4d, 0xf0, 0x0b, 0xb4, 0xc7, 0xd2, 0x78, 0xe5, 0x4b, 0x36, 0xf7, 0x03, 0x1a, 0xc7, 0x7a, 0x27, + 0xab, 0x68, 0xa5, 0x12, 0x37, 0x6c, 0x3e, 0xa4, 0x71, 0x4c, 0xb6, 0x81, 0xf7, 0x57, 0x05, 0x35, + 0x75, 0x97, 0xb2, 0x89, 0xb2, 0x58, 0x37, 0x2d, 0xe7, 0x2c, 0x91, 0x3a, 0x80, 0x8c, 0x12, 0x60, + 0x99, 0x2c, 0x2f, 0xcd, 0x03, 0x54, 0x15, 0x1c, 0x60, 0x09, 0x81, 0xb6, 0xdf, 0x24, 0x25, 0xc2, + 0x27, 0x68, 0x2f, 0x8c, 0x04, 0x1d, 0xc7, 0xe0, 0x0b, 0x49, 0x83, 0x99, 0xb6, 0xd4, 0x1a, 0xd8, + 0xeb, 0xdc, 0x6d, 0x95, 0x89, 0xd7, 0x8a, 0x27, 0x8f, 0x10, 0xfe, 0x1c, 0xed, 0x6f, 0xca, 0xf4, + 0x91, 0xb5, 0xb9, 0xd6, 0x00, 0xaf, 0x73, 0xf7, 0xc9, 0xfb, 0xa5, 0x3a, 0x43, 0xfe, 0x81, 0xd5, + 0xc5, 0x0e, 0x61, 0x9c, 0x4d, 0xb4, 0x67, 0x16, 0x29, 0x80, 0x62, 0xe3, 0x28, 0x89, 0xa4, 0xf6, + 0xa8, 0x4a, 0x0a, 0xa0, 0xe6, 0x83, 0x54, 0xef, 0x93, 0x40, 0xc2, 0xf8, 0xca, 0x69, 0x6e, 0xe6, + 0x2b, 0x12, 0x57, 0x9a, 0x27, 0x8f, 0x10, 0x1e, 0x20, 0x5c, 0x96, 0x71, 0x90, 0x19, 0x4f, 0x7d, + 0x7d, 0xf3, 0x5b, 0xba, 0x56, 0xdf, 0xbf, 0x22, 0x4b, 0x74, 0xf2, 0x25, 0x95, 0x94, 0xfc, 0x8b, + 0xc1, 0xdf, 0xa0, 0xbd, 0x42, 0x56, 0x3f, 0xd0, 0xaa, 0x3b, 0x7b, 0x1d, 0xa3, 0xdb, 0x3c, 0x76, + 0x7a, 0x9b, 0xaf, 0x6f, 0x6f, 0xdb, 0xda, 0x62, 0x28, 0xb9, 0xc5, 0x90, 0x47, 0x68, 0x64, 0x5a, + 0xa6, 0x5d, 0x2d, 0xde, 0xfb, 0x91, 0x69, 0x21, 0xbb, 0xf9, 0x5e, 0x99, 0xf2, 0x70, 0xe4, 0xf0, + 0x01, 0x6f, 0x4d, 0x3d, 0xf8, 0xe2, 0xed, 0x5d, 0xdb, 0x78, 0x77, 0xd7, 0x36, 0x7e, 0xbb, 0x6b, + 0x1b, 0x3f, 0xde, 0xb7, 0x77, 0xde, 0xdd, 0xb7, 0x77, 0x7e, 0xb9, 0x6f, 0xef, 0x7c, 0xff, 0xf1, + 0xff, 0x7e, 0xbc, 0x97, 0xea, 0xaf, 0x31, 0xae, 0xe9, 0x9f, 0xc2, 0x8b, 0xbf, 0x03, 0x00, 0x00, + 0xff, 0xff, 0x33, 0x26, 0x36, 0x60, 0x4e, 0x06, 0x00, 0x00, } func (this *Params) Equal(that interface{}) bool { @@ -924,50 +804,6 @@ func (m *State) MarshalToSizedBuffer(dAtA []byte) (int, error) { 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) @@ -1053,75 +889,6 @@ func (m *Log) MarshalToSizedBuffer(dAtA []byte) (int, error) { 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) @@ -1373,25 +1140,6 @@ func (m *State) Size() (n int) { 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 @@ -1435,35 +1183,6 @@ func (m *Log) Size() (n int) { 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 @@ -1985,122 +1704,6 @@ func (m *State) Unmarshal(dAtA []byte) error { } 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 @@ -2390,228 +1993,6 @@ func (m *Log) Unmarshal(dAtA []byte) error { } 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 diff --git a/x/evm/keeper/call_contract.go b/x/evm/keeper/call_contract.go index 032d30bd7..08928be64 100644 --- a/x/evm/keeper/call_contract.go +++ b/x/evm/keeper/call_contract.go @@ -87,7 +87,7 @@ func (k Keeper) CallContractWithInput( if commit { k.updateBlockBloom(ctx, evmResp, uint64(txConfig.LogIndex)) - err = k.EmitLogEvents(ctx, evmResp) + err = ctx.EventManager().EmitTypedEvent(&evm.EventTxLog{Logs: evmResp.Logs}) if err != nil { return nil, errors.Wrap(err, "error emitting tx logs") } diff --git a/x/evm/keeper/msg_server.go b/x/evm/keeper/msg_server.go index e5421725c..ac69d3b36 100644 --- a/x/evm/keeper/msg_server.go +++ b/x/evm/keeper/msg_server.go @@ -4,7 +4,6 @@ package keeper import ( "context" "encoding/binary" - "encoding/json" "fmt" "math/big" "strconv" @@ -95,13 +94,13 @@ func (k *Keeper) EthereumTx( if err != nil { return nil, errors.Wrap(err, "error emitting ethereum tx events") } - err = k.EmitLogEvents(ctx, evmResp) + + err = ctx.EventManager().EmitTypedEvent(&evm.EventTxLog{Logs: evmResp.Logs}) if err != nil { - return nil, errors.Wrap(err, "error emitting tx logs") + return nil, errors.Wrap(err, "error emitting tx log event") } - blockTxIdx := uint64(txConfig.TxIndex) + 1 - k.EvmState.BlockTxIndex.Set(ctx, blockTxIdx) + k.EvmState.BlockTxIndex.Set(ctx, uint64(txConfig.TxIndex)+1) return evmResp, nil } @@ -685,7 +684,7 @@ func (k *Keeper) EmitEthereumTxEvents( eventEthereumTx.Recipient = recipient.Hex() } if evmResp.Failed() { - eventEthereumTx.EthTxFailed = evmResp.VmError + eventEthereumTx.VmError = evmResp.VmError } err := ctx.EventManager().EmitTypedEvent(eventEthereumTx) if err != nil { @@ -727,35 +726,15 @@ func (k *Keeper) EmitEthereumTxEvents( return nil } -// EmitLogEvents emits all types of EVM events applicable to a particular execution case -func (k *Keeper) EmitLogEvents( - ctx sdk.Context, - evmResp *evm.MsgEthereumTxResponse, -) error { - // Typed event: eth.evm.v1.EventTxLog - txLogs := make([]string, len(evmResp.Logs)) - for i, log := range evmResp.Logs { - value, err := json.Marshal(log) - if err != nil { - return errors.Wrap(err, "failed to encode log") - } - txLogs[i] = string(value) - } - _ = ctx.EventManager().EmitTypedEvent(&evm.EventTxLog{TxLogs: txLogs}) - - return nil -} - // updateBlockBloom updates transient block bloom filter func (k *Keeper) updateBlockBloom( ctx sdk.Context, evmResp *evm.MsgEthereumTxResponse, logIndex uint64, ) { - logs := evm.LogsToEthereum(evmResp.Logs) - if len(logs) > 0 { + if len(evmResp.Logs) > 0 { + logs := evm.LogsToEthereum(evmResp.Logs) k.EvmState.BlockBloom.Set(ctx, k.EvmState.CalcBloomFromLogs(ctx, logs).Bytes()) - blockLogSize := logIndex + uint64(len(logs)) - k.EvmState.BlockLogSize.Set(ctx, blockLogSize) + k.EvmState.BlockLogSize.Set(ctx, logIndex+uint64(len(logs))) } } diff --git a/x/evm/logs.go b/x/evm/logs.go index 3b662964f..d83742216 100644 --- a/x/evm/logs.go +++ b/x/evm/logs.go @@ -11,39 +11,6 @@ import ( "github.com/NibiruChain/nibiru/v2/eth" ) -// NewTransactionLogsFromEth creates a new NewTransactionLogs instance using []*ethtypes.Log. -func NewTransactionLogsFromEth(hash gethcommon.Hash, ethlogs []*gethcore.Log) TransactionLogs { - return TransactionLogs{ - Hash: hash.String(), - Logs: NewLogsFromEth(ethlogs), - } -} - -// Validate performs a basic validation of a GenesisAccount fields. -func (tx TransactionLogs) Validate() error { - if eth.IsEmptyHash(tx.Hash) { - return fmt.Errorf("hash cannot be the empty %s", tx.Hash) - } - - for i, log := range tx.Logs { - if log == nil { - return fmt.Errorf("log %d cannot be nil", i) - } - if err := log.Validate(); err != nil { - return fmt.Errorf("invalid log %d: %w", i, err) - } - if log.TxHash != tx.Hash { - return fmt.Errorf("log tx hash mismatch (%s ≠ %s)", log.TxHash, tx.Hash) - } - } - return nil -} - -// EthLogs returns the Ethereum type Logs from the Transaction Logs. -func (tx TransactionLogs) EthLogs() []*gethcore.Log { - return LogsToEthereum(tx.Logs) -} - // Validate performs a basic validation of an ethereum Log fields. func (log *Log) Validate() error { if err := eth.ValidateAddress(log.Address); err != nil { @@ -81,8 +48,8 @@ func (log *Log) ToEthereum() *gethcore.Log { } } -func NewLogsFromEth(ethlogs []*gethcore.Log) []*Log { - var logs []*Log //nolint: prealloc +func NewLogsFromEth(ethlogs []*gethcore.Log) []Log { + var logs []Log //nolint: prealloc for _, ethlog := range ethlogs { logs = append(logs, NewLogFromEth(ethlog)) } @@ -91,7 +58,7 @@ func NewLogsFromEth(ethlogs []*gethcore.Log) []*Log { } // LogsToEthereum casts the Proto Logs to a slice of Ethereum Logs. -func LogsToEthereum(logs []*Log) []*gethcore.Log { +func LogsToEthereum(logs []Log) []*gethcore.Log { var ethLogs []*gethcore.Log //nolint: prealloc for i := range logs { ethLogs = append(ethLogs, logs[i].ToEthereum()) @@ -100,13 +67,13 @@ func LogsToEthereum(logs []*Log) []*gethcore.Log { } // NewLogFromEth creates a new Log instance from an Ethereum type Log. -func NewLogFromEth(log *gethcore.Log) *Log { +func NewLogFromEth(log *gethcore.Log) Log { topics := make([]string, len(log.Topics)) for i, topic := range log.Topics { topics[i] = topic.String() } - return &Log{ + return Log{ Address: log.Address.String(), Topics: topics, Data: log.Data, diff --git a/x/evm/logs_test.go b/x/evm/logs_test.go index 66dc1105c..97c3e67f1 100644 --- a/x/evm/logs_test.go +++ b/x/evm/logs_test.go @@ -11,90 +11,6 @@ import ( "github.com/ethereum/go-ethereum/common" ) -func TestTransactionLogsValidate(t *testing.T) { - addr := evmtest.NewEthPrivAcc().EthAddr.String() - - testCases := []struct { - name string - txLogs evm.TransactionLogs - expPass bool - }{ - { - "valid log", - evm.TransactionLogs{ - Hash: common.BytesToHash([]byte("tx_hash")).String(), - Logs: []*evm.Log{ - { - Address: addr, - Topics: []string{common.BytesToHash([]byte("topic")).String()}, - Data: []byte("data"), - BlockNumber: 1, - TxHash: common.BytesToHash([]byte("tx_hash")).String(), - TxIndex: 1, - BlockHash: common.BytesToHash([]byte("block_hash")).String(), - Index: 1, - Removed: false, - }, - }, - }, - true, - }, - { - "empty hash", - evm.TransactionLogs{ - Hash: common.Hash{}.String(), - }, - false, - }, - { - "nil log", - evm.TransactionLogs{ - Hash: common.BytesToHash([]byte("tx_hash")).String(), - Logs: []*evm.Log{nil}, - }, - false, - }, - { - "invalid log", - evm.TransactionLogs{ - Hash: common.BytesToHash([]byte("tx_hash")).String(), - Logs: []*evm.Log{{}}, - }, - false, - }, - { - "hash mismatch log", - evm.TransactionLogs{ - Hash: common.BytesToHash([]byte("tx_hash")).String(), - Logs: []*evm.Log{ - { - Address: addr, - Topics: []string{common.BytesToHash([]byte("topic")).String()}, - Data: []byte("data"), - BlockNumber: 1, - TxHash: common.BytesToHash([]byte("other_hash")).String(), - TxIndex: 1, - BlockHash: common.BytesToHash([]byte("block_hash")).String(), - Index: 1, - Removed: false, - }, - }, - }, - false, - }, - } - - for _, tc := range testCases { - tc := tc - err := tc.txLogs.Validate() - if tc.expPass { - require.NoError(t, err, tc.name) - } else { - require.Error(t, err, tc.name) - } - } -} - func TestValidateLog(t *testing.T) { addr := evmtest.NewEthPrivAcc().EthAddr.String() @@ -167,38 +83,3 @@ func TestValidateLog(t *testing.T) { } } } - -func TestConversionFunctions(t *testing.T) { - addr := evmtest.NewEthPrivAcc().EthAddr.String() - - txLogs := evm.TransactionLogs{ - Hash: common.BytesToHash([]byte("tx_hash")).String(), - Logs: []*evm.Log{ - { - Address: addr, - Topics: []string{common.BytesToHash([]byte("topic")).String()}, - Data: []byte("data"), - BlockNumber: 1, - TxHash: common.BytesToHash([]byte("tx_hash")).String(), - TxIndex: 1, - BlockHash: common.BytesToHash([]byte("block_hash")).String(), - Index: 1, - Removed: false, - }, - }, - } - - // convert valid log to eth logs and back (and validate) - conversionLogs := evm.NewTransactionLogsFromEth(common.BytesToHash([]byte("tx_hash")), txLogs.EthLogs()) - conversionErr := conversionLogs.Validate() - - // create new transaction logs as copy of old valid one (and validate) - copyLogs := evm.TransactionLogs{ - Hash: common.BytesToHash([]byte("tx_hash")).Hex(), - Logs: txLogs.Logs, - } - copyErr := copyLogs.Validate() - - require.Nil(t, conversionErr) - require.Nil(t, copyErr) -} diff --git a/x/evm/msg.go b/x/evm/msg.go index ec7520bb1..c0839bd80 100644 --- a/x/evm/msg.go +++ b/x/evm/msg.go @@ -421,23 +421,6 @@ func UnwrapEthereumMsg(tx *sdk.Tx, ethHash common.Hash) (*MsgEthereumTx, error) return nil, fmt.Errorf("eth tx not found: %s", ethHash) } -// EncodeTransactionLogs encodes TransactionLogs slice into a protobuf-encoded -// byte slice. -func EncodeTransactionLogs(res *TransactionLogs) ([]byte, error) { - return proto.Marshal(res) -} - -// DecodeTransactionLogs decodes a 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 -} - // DecodeTxResponse decodes an protobuf-encoded byte slice into TxResponse func DecodeTxResponse(in []byte) (*MsgEthereumTxResponse, error) { var txMsgData sdk.TxMsgData diff --git a/x/evm/msg_test.go b/x/evm/msg_test.go index 37bfb5dac..c57c0f5fd 100644 --- a/x/evm/msg_test.go +++ b/x/evm/msg_test.go @@ -955,34 +955,6 @@ func (s *MsgsSuite) TestUnwrapEthererumMsg() { s.Equal(unwrappedMsg, msg) } -func (s *MsgsSuite) TestTransactionLogsEncodeDecode() { - addr := evmtest.NewEthPrivAcc().EthAddr.String() - - txLogs := evm.TransactionLogs{ - Hash: common.BytesToHash([]byte("tx_hash")).String(), - Logs: []*evm.Log{ - { - Address: addr, - Topics: []string{common.BytesToHash([]byte("topic")).String()}, - Data: []byte("data"), - BlockNumber: 1, - TxHash: common.BytesToHash([]byte("tx_hash")).String(), - TxIndex: 1, - BlockHash: common.BytesToHash([]byte("block_hash")).String(), - Index: 1, - Removed: false, - }, - }, - } - - txLogsEncoded, encodeErr := evm.EncodeTransactionLogs(&txLogs) - s.Nil(encodeErr) - - txLogsEncodedDecoded, decodeErr := evm.DecodeTransactionLogs(txLogsEncoded) - s.Nil(decodeErr) - s.Equal(txLogs, txLogsEncodedDecoded) -} - func (s *MsgsSuite) TestMarshalJSON() { addrHex := "0x1111111111111111122222222222222222222222" { diff --git a/x/evm/tx.pb.go b/x/evm/tx.pb.go index f1ab92dae..29b728e61 100644 --- a/x/evm/tx.pb.go +++ b/x/evm/tx.pb.go @@ -44,8 +44,8 @@ type MsgEthereumTx struct { Size_ float64 `protobuf:"fixed64,2,opt,name=size,proto3" json:"-"` // hash of the transaction in hex format Hash string `protobuf:"bytes,3,opt,name=hash,proto3" json:"hash,omitempty" rlp:"-"` - // from is the ethereum signer address in hex format. This address value is checked - // against the address derived from the signature (V, R, S) using the + // from is the 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"` } @@ -103,19 +103,19 @@ type LegacyTx struct { Amount *cosmossdk_io_math.Int `protobuf:"bytes,5,opt,name=value,proto3,customtype=cosmossdk.io/math.Int" json:"value,omitempty"` // data is the data payload bytes of the transaction. Data []byte `protobuf:"bytes,6,opt,name=data,proto3" json:"data,omitempty"` - // v defines the recovery id as the "v" signature value from the elliptic curve - // digital signatute algorithm (ECDSA). It indicates which of two possible - // solutions should be used to reconstruct the public key from the signature. - // In Ethereum, "v" takes the value 27 or 28 for transactions that are not - // relay-protected. + // v defines the recovery id as the "v" signature value from the elliptic + // curve digital signatute algorithm (ECDSA). It indicates which of two + // possible solutions should be used to reconstruct the public key from the + // signature. In Ethereum, "v" takes the value 27 or 28 for transactions that + // are not relay-protected. V []byte `protobuf:"bytes,7,opt,name=v,proto3" json:"v,omitempty"` - // r defines the x-coordinate of a point on the elliptic curve in the elliptic curve - // digital signatute algorithm (ECDSA). It's crucial in ensuring uniqueness of - // the signature. + // r defines the x-coordinate of a point on the elliptic curve in the elliptic + // curve digital signatute algorithm (ECDSA). It's crucial in ensuring + // uniqueness of the signature. R []byte `protobuf:"bytes,8,opt,name=r,proto3" json:"r,omitempty"` - // s define the signature value derived from the private key, message hash, and - // the value of "r". It ensures that the signature is tied to both the message - // and the private key of the sender. + // s define the signature value derived from the private key, message hash, + // and the value of "r". It ensures that the signature is tied to both the + // message and the private key of the sender. S []byte `protobuf:"bytes,9,opt,name=s,proto3" json:"s,omitempty"` } @@ -178,13 +178,13 @@ type AccessListTx struct { // In Ethereum, "v" takes the value 27 or 28 for transactions that are not // relay-protected. V []byte `protobuf:"bytes,9,opt,name=v,proto3" json:"v,omitempty"` - // r defines the x-coordinate of a point on the elliptic curve in the elliptic curve - // digital signatute algorithm (ECDSA). It's crucial in ensuring uniqueness of - // the signature. + // r defines the x-coordinate of a point on the elliptic curve in the elliptic + // curve digital signatute algorithm (ECDSA). It's crucial in ensuring + // uniqueness of the signature. R []byte `protobuf:"bytes,10,opt,name=r,proto3" json:"r,omitempty"` - // s define the signature value derived from the private key, message hash, and - // the value of "r". It ensures that the signature is tied to both the message - // and the private key of the sender. + // s define the signature value derived from the private key, message hash, + // and the value of "r". It ensures that the signature is tied to both the + // message and the private key of the sender. S []byte `protobuf:"bytes,11,opt,name=s,proto3" json:"s,omitempty"` } @@ -249,13 +249,13 @@ type DynamicFeeTx struct { // In Ethereum, "v" takes the value 27 or 28 for transactions that are not // relay-protected. V []byte `protobuf:"bytes,10,opt,name=v,proto3" json:"v,omitempty"` - // r defines the x-coordinate of a point on the elliptic curve in the elliptic curve - // digital signatute algorithm (ECDSA). It's crucial in ensuring uniqueness of - // the signature. + // r defines the x-coordinate of a point on the elliptic curve in the elliptic + // curve digital signatute algorithm (ECDSA). It's crucial in ensuring + // uniqueness of the signature. R []byte `protobuf:"bytes,11,opt,name=r,proto3" json:"r,omitempty"` - // s define the signature value derived from the private key, message hash, and - // the value of "r". It ensures that the signature is tied to both the message - // and the private key of the sender. + // s define the signature value derived from the private key, message hash, + // and the value of "r". It ensures that the signature is tied to both the + // message and the private key of the sender. S []byte `protobuf:"bytes,12,opt,name=s,proto3" json:"s,omitempty"` } @@ -337,9 +337,9 @@ type MsgEthereumTxResponse struct { 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"` - // ret is the returned data from evm function (result or data supplied with revert - // opcode) + Logs []Log `protobuf:"bytes,2,rep,name=logs,proto3" json:"logs"` + // ret is the 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"` @@ -689,85 +689,85 @@ func init() { func init() { proto.RegisterFile("eth/evm/v1/tx.proto", fileDescriptor_82a0bfe4f0bab953) } var fileDescriptor_82a0bfe4f0bab953 = []byte{ - // 1246 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x56, 0xcf, 0x6f, 0x1b, 0xc5, - 0x17, 0xcf, 0xda, 0x8e, 0x7f, 0x3c, 0xbb, 0x49, 0xbe, 0xdb, 0xf4, 0xdb, 0xb5, 0xdb, 0x7a, 0xc3, - 0x56, 0x94, 0x08, 0x29, 0xbb, 0x8d, 0x51, 0x2b, 0x35, 0x27, 0xe2, 0xc4, 0x45, 0x45, 0x09, 0x44, - 0x8b, 0xd3, 0x03, 0x42, 0xb2, 0xc6, 0xbb, 0x93, 0xf5, 0x2a, 0xd9, 0x99, 0xd5, 0xce, 0x78, 0xe5, - 0x70, 0xec, 0x09, 0x89, 0x03, 0x20, 0xee, 0x88, 0x73, 0x4f, 0x1c, 0x7a, 0xe0, 0x4f, 0xa8, 0x38, - 0x55, 0x70, 0x00, 0xf5, 0x60, 0x50, 0x8a, 0x84, 0xd4, 0x63, 0x0f, 0xdc, 0x90, 0xd0, 0xcc, 0xae, - 0x1d, 0x3b, 0x21, 0x29, 0x54, 0x88, 0xdb, 0xbc, 0x79, 0x3f, 0xe6, 0xbd, 0xcf, 0xe7, 0xcd, 0x9b, - 0x81, 0x8b, 0x98, 0xf7, 0x2c, 0x1c, 0x07, 0x56, 0xbc, 0x6a, 0xf1, 0x81, 0x19, 0x46, 0x94, 0x53, - 0x15, 0x30, 0xef, 0x99, 0x38, 0x0e, 0xcc, 0x78, 0xb5, 0x76, 0xd9, 0xa1, 0x2c, 0xa0, 0xcc, 0x0a, - 0x98, 0x27, 0x6c, 0x02, 0xe6, 0x25, 0x46, 0xb5, 0x7a, 0xaa, 0xe8, 0x22, 0x86, 0xad, 0x78, 0xb5, - 0x8b, 0x39, 0x5a, 0xb5, 0x1c, 0xea, 0x93, 0x54, 0x5f, 0x4d, 0xf4, 0x1d, 0x29, 0x59, 0x89, 0x90, - 0xaa, 0x16, 0x27, 0x0e, 0x15, 0xc7, 0xa4, 0xbb, 0x1e, 0xf5, 0x68, 0x62, 0x2d, 0x56, 0xe9, 0xee, - 0x55, 0x8f, 0x52, 0xef, 0x00, 0x5b, 0x28, 0xf4, 0x2d, 0x44, 0x08, 0xe5, 0x88, 0xfb, 0x94, 0x8c, - 0x22, 0x55, 0x53, 0xad, 0x94, 0xba, 0xfd, 0x3d, 0x0b, 0x91, 0xc3, 0x44, 0x65, 0x7c, 0xa6, 0xc0, - 0x85, 0x6d, 0xe6, 0xb5, 0x78, 0x0f, 0x47, 0xb8, 0x1f, 0xb4, 0x07, 0xea, 0x32, 0xe4, 0x5c, 0xc4, - 0x91, 0xa6, 0x2c, 0x29, 0xcb, 0xe5, 0xc6, 0xa2, 0x99, 0xf8, 0x9a, 0x23, 0x5f, 0x73, 0x9d, 0x1c, - 0xda, 0xd2, 0x42, 0xad, 0x42, 0x8e, 0xf9, 0x1f, 0x63, 0x2d, 0xb3, 0xa4, 0x2c, 0x2b, 0xcd, 0xd9, - 0xe7, 0x43, 0x5d, 0x59, 0xb1, 0xe5, 0x96, 0xaa, 0x43, 0xae, 0x87, 0x58, 0x4f, 0xcb, 0x2e, 0x29, - 0xcb, 0xa5, 0x66, 0xf9, 0xc5, 0x50, 0x2f, 0x44, 0x07, 0xe1, 0x9a, 0xb1, 0x62, 0xd8, 0x52, 0xa1, - 0xaa, 0x90, 0xdb, 0x8b, 0x68, 0xa0, 0xe5, 0x84, 0x81, 0x2d, 0xd7, 0x6b, 0xb9, 0x4f, 0xbe, 0xd6, - 0x67, 0x8c, 0x2f, 0x32, 0x50, 0xdc, 0xc2, 0x1e, 0x72, 0x0e, 0xdb, 0x03, 0x75, 0x11, 0x66, 0x09, - 0x25, 0x0e, 0x96, 0xd9, 0xe4, 0xec, 0x44, 0x50, 0x6f, 0x43, 0xc9, 0x43, 0x02, 0x33, 0xdf, 0x49, - 0x4e, 0x2f, 0x35, 0xab, 0x4f, 0x87, 0xfa, 0xa5, 0x04, 0x3e, 0xe6, 0xee, 0x9b, 0x3e, 0xb5, 0x02, - 0xc4, 0x7b, 0xe6, 0x3d, 0xc2, 0xed, 0xa2, 0x87, 0xd8, 0x8e, 0x30, 0x55, 0xeb, 0x90, 0xf5, 0x10, - 0x93, 0x49, 0xe5, 0x9a, 0x95, 0xa3, 0xa1, 0x5e, 0x7c, 0x07, 0xb1, 0x2d, 0x3f, 0xf0, 0xb9, 0x2d, - 0x14, 0xea, 0x1c, 0x64, 0x38, 0x4d, 0x53, 0xca, 0x70, 0xaa, 0xde, 0x81, 0xd9, 0x18, 0x1d, 0xf4, - 0xb1, 0x36, 0x2b, 0xcf, 0xb8, 0x7e, 0xe6, 0x19, 0x47, 0x43, 0x3d, 0xbf, 0x1e, 0xd0, 0x3e, 0xe1, - 0x76, 0xe2, 0x21, 0xea, 0x93, 0x28, 0xe6, 0x97, 0x94, 0xe5, 0x4a, 0x8a, 0x57, 0x05, 0x94, 0x58, - 0x2b, 0xc8, 0x0d, 0x25, 0x16, 0x52, 0xa4, 0x15, 0x13, 0x29, 0x12, 0x12, 0xd3, 0x4a, 0x89, 0xc4, - 0xd6, 0xe6, 0x04, 0x12, 0xdf, 0x3d, 0x5a, 0xc9, 0xb7, 0x07, 0x9b, 0x88, 0x23, 0xe3, 0xdb, 0x2c, - 0x54, 0xd6, 0x1d, 0x07, 0x33, 0xb6, 0xe5, 0x33, 0xde, 0x1e, 0xa8, 0xef, 0x42, 0xd1, 0xe9, 0x21, - 0x9f, 0x74, 0x7c, 0x57, 0x42, 0x53, 0x6a, 0x5a, 0xe7, 0x25, 0x57, 0xd8, 0x10, 0xc6, 0xf7, 0x36, - 0x9f, 0x0f, 0xf5, 0x82, 0x93, 0x2c, 0xed, 0x74, 0xe1, 0x1e, 0x63, 0x9c, 0x39, 0x13, 0xe3, 0xec, - 0x3f, 0xc6, 0x38, 0x77, 0x3e, 0xc6, 0xb3, 0xa7, 0x31, 0xce, 0xbf, 0x32, 0xc6, 0x85, 0x09, 0x8c, - 0x77, 0xa1, 0x88, 0x24, 0x50, 0x98, 0x69, 0xc5, 0xa5, 0xec, 0x72, 0xb9, 0x71, 0xd9, 0x3c, 0xbe, - 0xa7, 0x66, 0x02, 0x62, 0xbb, 0x1f, 0x1e, 0xe0, 0xe6, 0xd2, 0xe3, 0xa1, 0x3e, 0xf3, 0x7c, 0xa8, - 0x03, 0x1a, 0x23, 0xfb, 0xf0, 0x67, 0x1d, 0x8e, 0x71, 0xb6, 0xc7, 0xa1, 0x12, 0xea, 0x4a, 0x53, - 0xd4, 0xc1, 0x14, 0x75, 0xe5, 0xb3, 0xa8, 0xfb, 0x3d, 0x0b, 0x95, 0xcd, 0x43, 0x82, 0x02, 0xdf, - 0xb9, 0x8b, 0xf1, 0x7f, 0x42, 0xdd, 0x1d, 0x28, 0x0b, 0xea, 0xb8, 0x1f, 0x76, 0x1c, 0x14, 0xbe, - 0x9c, 0x3c, 0x41, 0x74, 0xdb, 0x0f, 0x37, 0x50, 0x38, 0x72, 0xdd, 0xc3, 0x58, 0xba, 0xe6, 0xfe, - 0x8e, 0xeb, 0x5d, 0x8c, 0x85, 0x6b, 0x4a, 0xfc, 0xec, 0xf9, 0xc4, 0xe7, 0x4f, 0x13, 0x5f, 0x78, - 0x65, 0xe2, 0x8b, 0x67, 0x10, 0x5f, 0xfa, 0x97, 0x89, 0x87, 0x29, 0xe2, 0xcb, 0x53, 0xc4, 0x57, - 0xce, 0x22, 0xde, 0x80, 0x5a, 0x6b, 0xc0, 0x31, 0x61, 0x3e, 0x25, 0xef, 0x87, 0x72, 0x1c, 0x1f, - 0x4f, 0xd9, 0x74, 0xd6, 0x7d, 0xa5, 0xc0, 0xa5, 0xa9, 0xe9, 0x6b, 0x63, 0x16, 0x52, 0xc2, 0x64, - 0x89, 0x72, 0x80, 0x2a, 0xc9, 0x7c, 0x94, 0x33, 0xf3, 0x3a, 0xe4, 0x0e, 0xa8, 0xc7, 0xb4, 0x8c, - 0x2c, 0x6f, 0x7e, 0xb2, 0xbc, 0x2d, 0xea, 0xd9, 0x52, 0xa9, 0x2e, 0x40, 0x36, 0xc2, 0x5c, 0x92, - 0x5e, 0xb1, 0xc5, 0x52, 0xad, 0x42, 0x31, 0x0e, 0x3a, 0x38, 0x8a, 0x68, 0x94, 0xce, 0xb6, 0x42, - 0x1c, 0xb4, 0x84, 0x28, 0x54, 0x82, 0xee, 0x3e, 0xc3, 0x6e, 0x42, 0x9c, 0x5d, 0xf0, 0x10, 0xdb, - 0x65, 0xd8, 0x4d, 0x13, 0xfc, 0x54, 0x81, 0xf9, 0x6d, 0xe6, 0xed, 0x86, 0x2e, 0xe2, 0x78, 0x07, - 0x45, 0x28, 0x60, 0x62, 0x32, 0xa0, 0x3e, 0xef, 0xd1, 0xc8, 0xe7, 0x87, 0x69, 0x07, 0x6b, 0xdf, - 0x3f, 0x5a, 0x59, 0x4c, 0x1f, 0xaf, 0x75, 0xd7, 0x8d, 0x30, 0x63, 0x1f, 0xf0, 0xc8, 0x27, 0x9e, - 0x7d, 0x6c, 0xaa, 0xde, 0x84, 0x7c, 0x28, 0x23, 0xc8, 0x6e, 0x2d, 0x37, 0xd4, 0xc9, 0x02, 0x92, - 0xd8, 0xcd, 0x9c, 0xa0, 0xc6, 0x4e, 0xed, 0xd6, 0xe6, 0x1e, 0xfc, 0xf6, 0xcd, 0x9b, 0xc7, 0x11, - 0x8c, 0x2a, 0x5c, 0x3e, 0x91, 0xcc, 0x08, 0x2f, 0xe3, 0xa1, 0x02, 0xff, 0xdb, 0x66, 0xde, 0x46, - 0x84, 0x11, 0xc7, 0x77, 0xfb, 0xa4, 0x4d, 0xf7, 0x31, 0x51, 0x77, 0x01, 0xc4, 0xcb, 0xd2, 0xc1, - 0x91, 0xd3, 0xb8, 0x99, 0xe6, 0x7a, 0xfb, 0xf1, 0x50, 0x57, 0x9e, 0x0e, 0x75, 0xd3, 0xf3, 0x79, - 0xaf, 0xdf, 0x35, 0x1d, 0x1a, 0x58, 0xef, 0xf9, 0x5d, 0x3f, 0xea, 0xcb, 0x9b, 0x66, 0x11, 0xb9, - 0xb6, 0xe2, 0x86, 0x25, 0xd2, 0x6b, 0xdd, 0xdb, 0xb9, 0x75, 0x4b, 0x94, 0x64, 0x97, 0x44, 0xa4, - 0x96, 0x08, 0xa4, 0xde, 0x80, 0x79, 0x19, 0xb6, 0x8b, 0xc8, 0x7e, 0xc7, 0xc5, 0x84, 0x06, 0xc9, - 0x2b, 0x64, 0x5f, 0x10, 0xdb, 0x4d, 0x44, 0xf6, 0x37, 0xc5, 0xa6, 0xfa, 0x7f, 0xc8, 0x33, 0x4c, - 0x5c, 0x1c, 0x25, 0x77, 0xd0, 0x4e, 0x25, 0xa3, 0x0b, 0xd5, 0x53, 0xb9, 0x8e, 0x99, 0x6f, 0xc1, - 0xc2, 0x5e, 0x9f, 0x70, 0xb1, 0xd7, 0x09, 0x50, 0x18, 0xfa, 0xc4, 0x1b, 0xbf, 0xc5, 0x13, 0x80, - 0x8d, 0xfc, 0x52, 0xc8, 0xe6, 0x47, 0x3e, 0xdb, 0x89, 0x8b, 0xf1, 0xa3, 0x02, 0x17, 0xc5, 0x21, - 0x94, 0xc4, 0x38, 0xe2, 0x1b, 0xd4, 0x27, 0x6d, 0xda, 0x8a, 0x03, 0xf5, 0x3e, 0x94, 0x39, 0xed, - 0x60, 0xde, 0xeb, 0x20, 0xd7, 0x8d, 0x26, 0x30, 0x99, 0x79, 0x15, 0x4c, 0x38, 0x6d, 0xf1, 0x9e, - 0x58, 0x4e, 0xd4, 0x9a, 0x99, 0xac, 0x55, 0xdd, 0x81, 0x92, 0x84, 0x49, 0xfc, 0x79, 0x24, 0x0c, - 0xe5, 0x46, 0xd5, 0x4c, 0x5b, 0x45, 0x7c, 0x8a, 0xcc, 0xf4, 0x53, 0x64, 0x8a, 0x14, 0x9b, 0x9a, - 0x48, 0xe4, 0xc5, 0x50, 0x5f, 0x38, 0x44, 0xc1, 0xc1, 0x9a, 0x31, 0xf6, 0x34, 0xec, 0xa2, 0x58, - 0x0b, 0x1b, 0xe3, 0x1a, 0x5c, 0xf9, 0x8b, 0xc2, 0x46, 0xf8, 0x35, 0xfe, 0xc8, 0x40, 0x76, 0x9b, - 0x79, 0x2a, 0x01, 0x98, 0xf8, 0xd5, 0x54, 0x27, 0xb1, 0x9b, 0xba, 0x72, 0xb5, 0xd7, 0xce, 0x54, - 0x8d, 0xbb, 0xcb, 0x78, 0xf0, 0xc3, 0xaf, 0x5f, 0x66, 0xae, 0x1a, 0xb5, 0x11, 0x12, 0xa3, 0x6f, - 0x59, 0x6a, 0xda, 0xe1, 0x03, 0x75, 0x07, 0x2a, 0x53, 0xd7, 0xe4, 0xca, 0x89, 0xb0, 0x93, 0xca, - 0xda, 0xf5, 0x73, 0x94, 0xe3, 0x4e, 0xb8, 0x0f, 0x73, 0x27, 0xfa, 0xf9, 0xda, 0x09, 0xb7, 0x69, - 0x75, 0xed, 0xf5, 0x73, 0xd5, 0xe3, 0xb8, 0x1f, 0xc1, 0xc2, 0xa9, 0xb6, 0xd0, 0x4f, 0xba, 0x9e, - 0x30, 0xa8, 0xbd, 0xf1, 0x12, 0x83, 0x51, 0xf4, 0xe6, 0xdb, 0x8f, 0x8f, 0xea, 0xca, 0x93, 0xa3, - 0xba, 0xf2, 0xcb, 0x51, 0x5d, 0xf9, 0xfc, 0x59, 0x7d, 0xe6, 0xc9, 0xb3, 0xfa, 0xcc, 0x4f, 0xcf, - 0xea, 0x33, 0x1f, 0xde, 0x78, 0x69, 0x77, 0x0d, 0x04, 0xb0, 0xdd, 0xbc, 0xfc, 0x6b, 0xbe, 0xf5, - 0x67, 0x00, 0x00, 0x00, 0xff, 0xff, 0x32, 0xcb, 0xec, 0xc3, 0x76, 0x0b, 0x00, 0x00, + // 1247 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x56, 0x4f, 0x6f, 0x1b, 0x45, + 0x14, 0xcf, 0xda, 0x8e, 0xff, 0x3c, 0xbb, 0x49, 0xd8, 0xa6, 0xd4, 0x76, 0x5b, 0x6f, 0xd8, 0x8a, + 0x12, 0x90, 0xb2, 0xdb, 0x18, 0xb5, 0x52, 0x73, 0x22, 0x4e, 0x5c, 0x54, 0x94, 0x40, 0xb4, 0x38, + 0x3d, 0x20, 0x24, 0x6b, 0xbc, 0x3b, 0x59, 0xaf, 0x92, 0x9d, 0x59, 0xed, 0x8c, 0x57, 0x0e, 0xc7, + 0x9e, 0x90, 0x38, 0x00, 0xe2, 0x0b, 0x70, 0xe0, 0xd4, 0x13, 0x87, 0x1e, 0xf8, 0x08, 0x15, 0xa7, + 0x0a, 0x0e, 0xa0, 0x1e, 0x0c, 0x4a, 0x91, 0x90, 0x7a, 0xec, 0x81, 0x1b, 0x12, 0x9a, 0xd9, 0xb5, + 0x63, 0x27, 0x38, 0x85, 0x08, 0x71, 0x9b, 0x37, 0xef, 0xcf, 0xbc, 0xf7, 0xfb, 0xbd, 0x79, 0x33, + 0x70, 0x11, 0xf3, 0xae, 0x89, 0x23, 0xdf, 0x8c, 0x56, 0x4d, 0xde, 0x37, 0x82, 0x90, 0x72, 0xaa, + 0x02, 0xe6, 0x5d, 0x03, 0x47, 0xbe, 0x11, 0xad, 0x56, 0x2f, 0xdb, 0x94, 0xf9, 0x94, 0x99, 0x3e, + 0x73, 0x85, 0x8d, 0xcf, 0xdc, 0xd8, 0xa8, 0x5a, 0x4b, 0x14, 0x1d, 0xc4, 0xb0, 0x19, 0xad, 0x76, + 0x30, 0x47, 0xab, 0xa6, 0x4d, 0x3d, 0x92, 0xe8, 0x2b, 0xb1, 0xbe, 0x2d, 0x25, 0x33, 0x16, 0x12, + 0xd5, 0xe2, 0xd8, 0xa1, 0xe2, 0x98, 0x64, 0xd7, 0xa5, 0x2e, 0x8d, 0xad, 0xc5, 0x2a, 0xd9, 0xbd, + 0xea, 0x52, 0xea, 0x1e, 0x60, 0x13, 0x05, 0x9e, 0x89, 0x08, 0xa1, 0x1c, 0x71, 0x8f, 0x92, 0x61, + 0xa4, 0x4a, 0xa2, 0x95, 0x52, 0xa7, 0xb7, 0x67, 0x22, 0x72, 0x18, 0xab, 0xf4, 0xcf, 0x15, 0xb8, + 0xb0, 0xcd, 0xdc, 0x26, 0xef, 0xe2, 0x10, 0xf7, 0xfc, 0x56, 0x5f, 0x5d, 0x86, 0x8c, 0x83, 0x38, + 0x2a, 0x2b, 0x4b, 0xca, 0x72, 0xb1, 0xbe, 0x68, 0xc4, 0xbe, 0xc6, 0xd0, 0xd7, 0x58, 0x27, 0x87, + 0x96, 0xb4, 0x50, 0x2b, 0x90, 0x61, 0xde, 0x27, 0xb8, 0x9c, 0x5a, 0x52, 0x96, 0x95, 0xc6, 0xec, + 0xf3, 0x81, 0xa6, 0xac, 0x58, 0x72, 0x4b, 0xd5, 0x20, 0xd3, 0x45, 0xac, 0x5b, 0x4e, 0x2f, 0x29, + 0xcb, 0x85, 0x46, 0xf1, 0xc5, 0x40, 0xcb, 0x85, 0x07, 0xc1, 0x9a, 0xbe, 0xa2, 0x5b, 0x52, 0xa1, + 0xaa, 0x90, 0xd9, 0x0b, 0xa9, 0x5f, 0xce, 0x08, 0x03, 0x4b, 0xae, 0xd7, 0x32, 0x9f, 0x7e, 0xad, + 0xcd, 0xe8, 0x5f, 0xa6, 0x20, 0xbf, 0x85, 0x5d, 0x64, 0x1f, 0xb6, 0xfa, 0xea, 0x22, 0xcc, 0x12, + 0x4a, 0x6c, 0x2c, 0xb3, 0xc9, 0x58, 0xb1, 0xa0, 0xde, 0x86, 0x82, 0x8b, 0x04, 0x66, 0x9e, 0x1d, + 0x9f, 0x5e, 0x68, 0x54, 0x9e, 0x0e, 0xb4, 0x4b, 0x31, 0x7c, 0xcc, 0xd9, 0x37, 0x3c, 0x6a, 0xfa, + 0x88, 0x77, 0x8d, 0x7b, 0x84, 0x5b, 0x79, 0x17, 0xb1, 0x1d, 0x61, 0xaa, 0xd6, 0x20, 0xed, 0x22, + 0x26, 0x93, 0xca, 0x34, 0x4a, 0x47, 0x03, 0x2d, 0xff, 0x2e, 0x62, 0x5b, 0x9e, 0xef, 0x71, 0x4b, + 0x28, 0xd4, 0x39, 0x48, 0x71, 0x9a, 0xa4, 0x94, 0xe2, 0x54, 0xbd, 0x03, 0xb3, 0x11, 0x3a, 0xe8, + 0xe1, 0xf2, 0xac, 0x3c, 0xe3, 0xfa, 0xd4, 0x33, 0x8e, 0x06, 0x5a, 0x76, 0xdd, 0xa7, 0x3d, 0xc2, + 0xad, 0xd8, 0x43, 0xd4, 0x27, 0x51, 0xcc, 0x2e, 0x29, 0xcb, 0xa5, 0x04, 0xaf, 0x12, 0x28, 0x51, + 0x39, 0x27, 0x37, 0x94, 0x48, 0x48, 0x61, 0x39, 0x1f, 0x4b, 0xa1, 0x90, 0x58, 0xb9, 0x10, 0x4b, + 0x6c, 0x6d, 0x4e, 0x20, 0xf1, 0xfd, 0xa3, 0x95, 0x6c, 0xab, 0xbf, 0x89, 0x38, 0xd2, 0xbf, 0x4b, + 0x43, 0x69, 0xdd, 0xb6, 0x31, 0x63, 0x5b, 0x1e, 0xe3, 0xad, 0xbe, 0xfa, 0x1e, 0xe4, 0xed, 0x2e, + 0xf2, 0x48, 0xdb, 0x73, 0x24, 0x34, 0x85, 0x86, 0x79, 0x56, 0x72, 0xb9, 0x0d, 0x61, 0x7c, 0x6f, + 0xf3, 0xf9, 0x40, 0xcb, 0xd9, 0xf1, 0xd2, 0x4a, 0x16, 0xce, 0x31, 0xc6, 0xa9, 0xa9, 0x18, 0xa7, + 0xff, 0x35, 0xc6, 0x99, 0xb3, 0x31, 0x9e, 0x3d, 0x8d, 0x71, 0xf6, 0xdc, 0x18, 0xe7, 0xc6, 0x30, + 0xde, 0x85, 0x3c, 0x92, 0x40, 0x61, 0x56, 0xce, 0x2f, 0xa5, 0x97, 0x8b, 0xf5, 0xcb, 0xc6, 0xf1, + 0x3d, 0x35, 0x62, 0x10, 0x5b, 0xbd, 0xe0, 0x00, 0x37, 0x96, 0x1e, 0x0f, 0xb4, 0x99, 0xe7, 0x03, + 0x0d, 0xd0, 0x08, 0xd9, 0x87, 0xbf, 0x68, 0x70, 0x8c, 0xb3, 0x35, 0x0a, 0x15, 0x53, 0x57, 0x98, + 0xa0, 0x0e, 0x26, 0xa8, 0x2b, 0x4e, 0xa3, 0xee, 0x8f, 0x34, 0x94, 0x36, 0x0f, 0x09, 0xf2, 0x3d, + 0xfb, 0x2e, 0xc6, 0xff, 0x0b, 0x75, 0x77, 0xa0, 0x28, 0xa8, 0xe3, 0x5e, 0xd0, 0xb6, 0x51, 0xf0, + 0x72, 0xf2, 0x04, 0xd1, 0x2d, 0x2f, 0xd8, 0x40, 0xc1, 0xd0, 0x75, 0x0f, 0x63, 0xe9, 0x9a, 0xf9, + 0x27, 0xae, 0x77, 0x31, 0x16, 0xae, 0x09, 0xf1, 0xb3, 0x67, 0x13, 0x9f, 0x3d, 0x4d, 0x7c, 0xee, + 0xdc, 0xc4, 0xe7, 0xa7, 0x10, 0x5f, 0xf8, 0x8f, 0x89, 0x87, 0x09, 0xe2, 0x8b, 0x13, 0xc4, 0x97, + 0xa6, 0x11, 0xaf, 0x43, 0xb5, 0xd9, 0xe7, 0x98, 0x30, 0x8f, 0x92, 0x0f, 0x02, 0x39, 0x8e, 0x8f, + 0xa7, 0x6c, 0x32, 0xeb, 0xbe, 0x51, 0xe0, 0xd2, 0xc4, 0xf4, 0xb5, 0x30, 0x0b, 0x28, 0x61, 0xb2, + 0x44, 0x39, 0x40, 0x95, 0x78, 0x3e, 0xca, 0x99, 0xf9, 0x26, 0x64, 0x0e, 0xa8, 0xcb, 0xca, 0x29, + 0x59, 0xde, 0xfc, 0x78, 0x79, 0x5b, 0xd4, 0x6d, 0x64, 0x44, 0x59, 0x96, 0x34, 0x51, 0x17, 0x20, + 0x1d, 0x62, 0x2e, 0xa9, 0x2f, 0x59, 0x62, 0xa9, 0x56, 0x20, 0x1f, 0xf9, 0x6d, 0x1c, 0x86, 0x34, + 0x4c, 0x26, 0x5c, 0x2e, 0xf2, 0x9b, 0x42, 0x14, 0x2a, 0x41, 0x7a, 0x8f, 0x61, 0x27, 0xa6, 0xcf, + 0xca, 0xb9, 0x88, 0xed, 0x32, 0xec, 0x24, 0x69, 0x7e, 0xa6, 0xc0, 0xfc, 0x36, 0x73, 0x77, 0x03, + 0x07, 0x71, 0xbc, 0x83, 0x42, 0xe4, 0x33, 0x31, 0x1f, 0x50, 0x8f, 0x77, 0x69, 0xe8, 0xf1, 0xc3, + 0xa4, 0x8f, 0xcb, 0x3f, 0x3c, 0x5a, 0x59, 0x4c, 0x9e, 0xb0, 0x75, 0xc7, 0x09, 0x31, 0x63, 0x1f, + 0xf2, 0xd0, 0x23, 0xae, 0x75, 0x6c, 0xaa, 0xde, 0x84, 0x6c, 0x20, 0x23, 0xc8, 0x9e, 0x2d, 0xd6, + 0xd5, 0xf1, 0x32, 0xe2, 0xd8, 0x49, 0x25, 0x89, 0xdd, 0xda, 0xdc, 0x83, 0xdf, 0xbf, 0x7d, 0xeb, + 0x38, 0x82, 0x5e, 0x81, 0xcb, 0x27, 0x92, 0x19, 0xa2, 0xa6, 0x3f, 0x54, 0xe0, 0x95, 0x6d, 0xe6, + 0x6e, 0x84, 0x18, 0x71, 0x7c, 0xb7, 0x47, 0x5a, 0x74, 0x1f, 0x13, 0x75, 0x17, 0x40, 0xbc, 0x2f, + 0x6d, 0x1c, 0xda, 0xf5, 0x9b, 0x49, 0xae, 0xb7, 0x1f, 0x0f, 0x34, 0xe5, 0xe9, 0x40, 0x33, 0x5c, + 0x8f, 0x77, 0x7b, 0x1d, 0xc3, 0xa6, 0xbe, 0xf9, 0xbe, 0xd7, 0xf1, 0xc2, 0x9e, 0xbc, 0x6f, 0x26, + 0x91, 0x6b, 0x33, 0xaa, 0x9b, 0x22, 0xbd, 0xe6, 0xbd, 0x9d, 0x5b, 0xb7, 0x44, 0x49, 0x56, 0x41, + 0x44, 0x6a, 0x8a, 0x40, 0xea, 0x0d, 0x98, 0x97, 0x61, 0x3b, 0x88, 0xec, 0xb7, 0x1d, 0x4c, 0xa8, + 0x1f, 0xbf, 0x45, 0xd6, 0x05, 0xb1, 0xdd, 0x40, 0x64, 0x7f, 0x53, 0x6c, 0xaa, 0xaf, 0x42, 0x96, + 0x61, 0xe2, 0xe0, 0x30, 0xbe, 0x89, 0x56, 0x22, 0xe9, 0x1d, 0xa8, 0x9c, 0xca, 0x75, 0xc4, 0x7f, + 0x13, 0x16, 0xf6, 0x7a, 0x84, 0x8b, 0xbd, 0xb6, 0x8f, 0x82, 0xc0, 0x23, 0xee, 0xe8, 0x45, 0x1e, + 0x03, 0x6c, 0xe8, 0x97, 0x40, 0x36, 0x3f, 0xf4, 0xd9, 0x8e, 0x5d, 0xf4, 0x9f, 0x14, 0xb8, 0x28, + 0x0e, 0xa1, 0x24, 0xc2, 0x21, 0xdf, 0xa0, 0x1e, 0x69, 0xd1, 0x66, 0xe4, 0xab, 0xf7, 0xa1, 0xc8, + 0x69, 0x1b, 0xf3, 0x6e, 0x1b, 0x39, 0x4e, 0x38, 0x86, 0xc9, 0xcc, 0x79, 0x30, 0xe1, 0xb4, 0xc9, + 0xbb, 0x62, 0x39, 0x56, 0x6b, 0x6a, 0xbc, 0x56, 0x75, 0x07, 0x0a, 0x12, 0x26, 0xf1, 0xf3, 0x91, + 0x30, 0x14, 0xeb, 0x15, 0x23, 0x69, 0x15, 0xf1, 0x35, 0x32, 0x92, 0xaf, 0x91, 0x21, 0x52, 0x6c, + 0x94, 0x45, 0x22, 0x2f, 0x06, 0xda, 0xc2, 0x21, 0xf2, 0x0f, 0xd6, 0xf4, 0x91, 0xa7, 0x6e, 0xe5, + 0xc5, 0x5a, 0xd8, 0xe8, 0xd7, 0xe0, 0xca, 0xdf, 0x14, 0x36, 0xc4, 0xaf, 0xfe, 0x67, 0x0a, 0xd2, + 0xdb, 0xcc, 0x55, 0x09, 0xc0, 0xd8, 0xdf, 0xa6, 0x32, 0x8e, 0xdd, 0xc4, 0xc5, 0xab, 0xbe, 0x36, + 0x55, 0x35, 0xea, 0x2e, 0xfd, 0xc1, 0x8f, 0xbf, 0x7d, 0x95, 0xba, 0xaa, 0x57, 0x87, 0x48, 0x0c, + 0x3f, 0x67, 0x89, 0x69, 0x9b, 0xf7, 0xd5, 0x1d, 0x28, 0x4d, 0x5c, 0x93, 0x2b, 0x27, 0xc2, 0x8e, + 0x2b, 0xab, 0xd7, 0xcf, 0x50, 0x8e, 0x3a, 0xe1, 0x3e, 0xcc, 0x9d, 0xe8, 0xe7, 0x6b, 0x27, 0xdc, + 0x26, 0xd5, 0xd5, 0xd7, 0xcf, 0x54, 0x8f, 0xe2, 0x7e, 0x0c, 0x0b, 0xa7, 0xda, 0x42, 0x3b, 0xe9, + 0x7a, 0xc2, 0xa0, 0xfa, 0xc6, 0x4b, 0x0c, 0x86, 0xd1, 0x1b, 0xef, 0x3c, 0x3e, 0xaa, 0x29, 0x4f, + 0x8e, 0x6a, 0xca, 0xaf, 0x47, 0x35, 0xe5, 0x8b, 0x67, 0xb5, 0x99, 0x27, 0xcf, 0x6a, 0x33, 0x3f, + 0x3f, 0xab, 0xcd, 0x7c, 0x74, 0xe3, 0xa5, 0xdd, 0xd5, 0x17, 0xc0, 0x76, 0xb2, 0xf2, 0xc7, 0xf9, + 0xf6, 0x5f, 0x01, 0x00, 0x00, 0xff, 0xff, 0xcc, 0xdd, 0x8f, 0x11, 0x7c, 0x0b, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. @@ -789,7 +789,8 @@ type MsgClient interface { UpdateParams(ctx context.Context, in *MsgUpdateParams, opts ...grpc.CallOption) (*MsgUpdateParamsResponse, error) // CreateFunToken: Create a "FunToken" mapping. Either the ERC20 contract // address can be given to create the mapping to a Bank Coin, or the - // denomination for a Bank Coin can be given to create the mapping to an ERC20. + // denomination for a Bank Coin can be given to create the mapping to an + // ERC20. CreateFunToken(ctx context.Context, in *MsgCreateFunToken, opts ...grpc.CallOption) (*MsgCreateFunTokenResponse, error) // ConvertCoinToEvm: Sends a coin with a valid "FunToken" mapping to the // given recipient address ("to_eth_addr") in the corresponding ERC20 @@ -850,7 +851,8 @@ type MsgServer interface { UpdateParams(context.Context, *MsgUpdateParams) (*MsgUpdateParamsResponse, error) // CreateFunToken: Create a "FunToken" mapping. Either the ERC20 contract // address can be given to create the mapping to a Bank Coin, or the - // denomination for a Bank Coin can be given to create the mapping to an ERC20. + // denomination for a Bank Coin can be given to create the mapping to an + // ERC20. CreateFunToken(context.Context, *MsgCreateFunToken) (*MsgCreateFunTokenResponse, error) // ConvertCoinToEvm: Sends a coin with a valid "FunToken" mapping to the // given recipient address ("to_eth_addr") in the corresponding ERC20 @@ -3451,7 +3453,7 @@ func (m *MsgEthereumTxResponse) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Logs = append(m.Logs, &Log{}) + m.Logs = append(m.Logs, Log{}) if err := m.Logs[len(m.Logs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err }