swagger: '2.0' info: title: Ethermint Chain - Legacy REST and gRPC Gateway docs description: A REST interface for state queries, legacy transactions version: 1.0.0 paths: /ethermint/evm/v1/account/{address}: get: summary: Account queries an Ethereum account. operationId: Account responses: '200': description: A successful response. schema: type: object properties: balance: type: string description: balance is the balance of the EVM denomination. code_hash: type: string description: code hash is the hex-formatted code bytes from the EOA. nonce: type: string format: uint64 description: nonce is the account's sequence number. description: >- QueryAccountResponse is the response type for the Query/Account RPC method. default: description: An unexpected error response. schema: type: object properties: error: type: string code: type: integer format: int32 message: type: string details: type: array items: type: object properties: type_url: type: string description: >- A URL/resource name that uniquely identifies the type of the serialized protocol buffer message. This string must contain at least one "/" character. The last segment of the URL's path must represent the fully qualified name of the type (as in `path/google.protobuf.Duration`). The name should be in a canonical form (e.g., leading "." is not accepted). In practice, teams usually precompile into the binary all types that they expect it to use in the context of Any. However, for URLs which use the scheme `http`, `https`, or no scheme, one can optionally set up a type server that maps type URLs to message definitions as follows: * If no scheme is provided, `https` is assumed. * An HTTP GET on the URL must yield a [google.protobuf.Type][] value in binary format, or produce an error. * Applications are allowed to cache lookup results based on the URL, or have them precompiled into a binary to avoid any lookup. Therefore, binary compatibility needs to be preserved on changes to types. (Use versioned type names to manage breaking changes.) Note: this functionality is not currently available in the official protobuf release, and it is not used for type URLs beginning with type.googleapis.com. Schemes other than `http`, `https` (or the empty scheme) might be used with implementation specific semantics. value: type: string format: byte description: >- Must be a valid serialized protocol buffer of the above specified type. description: >- `Any` contains an arbitrary serialized protocol buffer message along with a URL that describes the type of the serialized message. Protobuf library provides support to pack/unpack Any values in the form of utility functions or additional generated methods of the Any type. Example 1: Pack and unpack a message in C++. Foo foo = ...; Any any; any.PackFrom(foo); ... if (any.UnpackTo(&foo)) { ... } Example 2: Pack and unpack a message in Java. Foo foo = ...; Any any = Any.pack(foo); ... if (any.is(Foo.class)) { foo = any.unpack(Foo.class); } Example 3: Pack and unpack a message in Python. foo = Foo(...) any = Any() any.Pack(foo) ... if any.Is(Foo.DESCRIPTOR): any.Unpack(foo) ... Example 4: Pack and unpack a message in Go foo := &pb.Foo{...} any, err := anypb.New(foo) if err != nil { ... } ... foo := &pb.Foo{} if err := any.UnmarshalTo(foo); err != nil { ... } The pack methods provided by protobuf library will by default use 'type.googleapis.com/full.type.name' as the type URL and the unpack methods only use the fully qualified type name after the last '/' in the type URL, for example "foo.bar.com/x/y.z" will yield type name "y.z". JSON ==== The JSON representation of an `Any` value uses the regular representation of the deserialized, embedded message, with an additional field `@type` which contains the type URL. Example: package google.profile; message Person { string first_name = 1; string last_name = 2; } { "@type": "type.googleapis.com/google.profile.Person", "firstName": , "lastName": } If the embedded message type is well-known and has a custom JSON representation, that representation will be embedded adding a field `value` which holds the custom JSON in addition to the `@type` field. Example (for message [google.protobuf.Duration][]): { "@type": "type.googleapis.com/google.protobuf.Duration", "value": "1.212s" } parameters: - name: address description: address is the ethereum hex address to query the account for. in: path required: true type: string tags: - Query /ethermint/evm/v1/balances/{address}: get: summary: |- Balance queries the balance of a the EVM denomination for a single EthAccount. operationId: Balance responses: '200': description: A successful response. schema: type: object properties: balance: type: string description: balance is the balance of the EVM denomination. description: >- QueryBalanceResponse is the response type for the Query/Balance RPC method. default: description: An unexpected error response. schema: type: object properties: error: type: string code: type: integer format: int32 message: type: string details: type: array items: type: object properties: type_url: type: string description: >- A URL/resource name that uniquely identifies the type of the serialized protocol buffer message. This string must contain at least one "/" character. The last segment of the URL's path must represent the fully qualified name of the type (as in `path/google.protobuf.Duration`). The name should be in a canonical form (e.g., leading "." is not accepted). In practice, teams usually precompile into the binary all types that they expect it to use in the context of Any. However, for URLs which use the scheme `http`, `https`, or no scheme, one can optionally set up a type server that maps type URLs to message definitions as follows: * If no scheme is provided, `https` is assumed. * An HTTP GET on the URL must yield a [google.protobuf.Type][] value in binary format, or produce an error. * Applications are allowed to cache lookup results based on the URL, or have them precompiled into a binary to avoid any lookup. Therefore, binary compatibility needs to be preserved on changes to types. (Use versioned type names to manage breaking changes.) Note: this functionality is not currently available in the official protobuf release, and it is not used for type URLs beginning with type.googleapis.com. Schemes other than `http`, `https` (or the empty scheme) might be used with implementation specific semantics. value: type: string format: byte description: >- Must be a valid serialized protocol buffer of the above specified type. description: >- `Any` contains an arbitrary serialized protocol buffer message along with a URL that describes the type of the serialized message. Protobuf library provides support to pack/unpack Any values in the form of utility functions or additional generated methods of the Any type. Example 1: Pack and unpack a message in C++. Foo foo = ...; Any any; any.PackFrom(foo); ... if (any.UnpackTo(&foo)) { ... } Example 2: Pack and unpack a message in Java. Foo foo = ...; Any any = Any.pack(foo); ... if (any.is(Foo.class)) { foo = any.unpack(Foo.class); } Example 3: Pack and unpack a message in Python. foo = Foo(...) any = Any() any.Pack(foo) ... if any.Is(Foo.DESCRIPTOR): any.Unpack(foo) ... Example 4: Pack and unpack a message in Go foo := &pb.Foo{...} any, err := anypb.New(foo) if err != nil { ... } ... foo := &pb.Foo{} if err := any.UnmarshalTo(foo); err != nil { ... } The pack methods provided by protobuf library will by default use 'type.googleapis.com/full.type.name' as the type URL and the unpack methods only use the fully qualified type name after the last '/' in the type URL, for example "foo.bar.com/x/y.z" will yield type name "y.z". JSON ==== The JSON representation of an `Any` value uses the regular representation of the deserialized, embedded message, with an additional field `@type` which contains the type URL. Example: package google.profile; message Person { string first_name = 1; string last_name = 2; } { "@type": "type.googleapis.com/google.profile.Person", "firstName": , "lastName": } If the embedded message type is well-known and has a custom JSON representation, that representation will be embedded adding a field `value` which holds the custom JSON in addition to the `@type` field. Example (for message [google.protobuf.Duration][]): { "@type": "type.googleapis.com/google.protobuf.Duration", "value": "1.212s" } parameters: - name: address description: address is the ethereum hex address to query the balance for. in: path required: true type: string tags: - Query /ethermint/evm/v1/base_fee: get: summary: >- BaseFee queries the base fee of the parent block of the current block, it's similar to feemarket module's method, but also checks london hardfork status. operationId: BaseFee responses: '200': description: A successful response. schema: type: object properties: base_fee: type: string description: BaseFeeResponse returns the EIP1559 base fee. default: description: An unexpected error response. schema: type: object properties: error: type: string code: type: integer format: int32 message: type: string details: type: array items: type: object properties: type_url: type: string description: >- A URL/resource name that uniquely identifies the type of the serialized protocol buffer message. This string must contain at least one "/" character. The last segment of the URL's path must represent the fully qualified name of the type (as in `path/google.protobuf.Duration`). The name should be in a canonical form (e.g., leading "." is not accepted). In practice, teams usually precompile into the binary all types that they expect it to use in the context of Any. However, for URLs which use the scheme `http`, `https`, or no scheme, one can optionally set up a type server that maps type URLs to message definitions as follows: * If no scheme is provided, `https` is assumed. * An HTTP GET on the URL must yield a [google.protobuf.Type][] value in binary format, or produce an error. * Applications are allowed to cache lookup results based on the URL, or have them precompiled into a binary to avoid any lookup. Therefore, binary compatibility needs to be preserved on changes to types. (Use versioned type names to manage breaking changes.) Note: this functionality is not currently available in the official protobuf release, and it is not used for type URLs beginning with type.googleapis.com. Schemes other than `http`, `https` (or the empty scheme) might be used with implementation specific semantics. value: type: string format: byte description: >- Must be a valid serialized protocol buffer of the above specified type. description: >- `Any` contains an arbitrary serialized protocol buffer message along with a URL that describes the type of the serialized message. Protobuf library provides support to pack/unpack Any values in the form of utility functions or additional generated methods of the Any type. Example 1: Pack and unpack a message in C++. Foo foo = ...; Any any; any.PackFrom(foo); ... if (any.UnpackTo(&foo)) { ... } Example 2: Pack and unpack a message in Java. Foo foo = ...; Any any = Any.pack(foo); ... if (any.is(Foo.class)) { foo = any.unpack(Foo.class); } Example 3: Pack and unpack a message in Python. foo = Foo(...) any = Any() any.Pack(foo) ... if any.Is(Foo.DESCRIPTOR): any.Unpack(foo) ... Example 4: Pack and unpack a message in Go foo := &pb.Foo{...} any, err := anypb.New(foo) if err != nil { ... } ... foo := &pb.Foo{} if err := any.UnmarshalTo(foo); err != nil { ... } The pack methods provided by protobuf library will by default use 'type.googleapis.com/full.type.name' as the type URL and the unpack methods only use the fully qualified type name after the last '/' in the type URL, for example "foo.bar.com/x/y.z" will yield type name "y.z". JSON ==== The JSON representation of an `Any` value uses the regular representation of the deserialized, embedded message, with an additional field `@type` which contains the type URL. Example: package google.profile; message Person { string first_name = 1; string last_name = 2; } { "@type": "type.googleapis.com/google.profile.Person", "firstName": , "lastName": } If the embedded message type is well-known and has a custom JSON representation, that representation will be embedded adding a field `value` which holds the custom JSON in addition to the `@type` field. Example (for message [google.protobuf.Duration][]): { "@type": "type.googleapis.com/google.protobuf.Duration", "value": "1.212s" } tags: - Query /ethermint/evm/v1/codes/{address}: get: summary: Code queries the balance of all coins for a single account. operationId: Code responses: '200': description: A successful response. schema: type: object properties: code: type: string format: byte description: code represents the code bytes from an ethereum address. description: |- QueryCodeResponse is the response type for the Query/Code RPC method. default: description: An unexpected error response. schema: type: object properties: error: type: string code: type: integer format: int32 message: type: string details: type: array items: type: object properties: type_url: type: string description: >- A URL/resource name that uniquely identifies the type of the serialized protocol buffer message. This string must contain at least one "/" character. The last segment of the URL's path must represent the fully qualified name of the type (as in `path/google.protobuf.Duration`). The name should be in a canonical form (e.g., leading "." is not accepted). In practice, teams usually precompile into the binary all types that they expect it to use in the context of Any. However, for URLs which use the scheme `http`, `https`, or no scheme, one can optionally set up a type server that maps type URLs to message definitions as follows: * If no scheme is provided, `https` is assumed. * An HTTP GET on the URL must yield a [google.protobuf.Type][] value in binary format, or produce an error. * Applications are allowed to cache lookup results based on the URL, or have them precompiled into a binary to avoid any lookup. Therefore, binary compatibility needs to be preserved on changes to types. (Use versioned type names to manage breaking changes.) Note: this functionality is not currently available in the official protobuf release, and it is not used for type URLs beginning with type.googleapis.com. Schemes other than `http`, `https` (or the empty scheme) might be used with implementation specific semantics. value: type: string format: byte description: >- Must be a valid serialized protocol buffer of the above specified type. description: >- `Any` contains an arbitrary serialized protocol buffer message along with a URL that describes the type of the serialized message. Protobuf library provides support to pack/unpack Any values in the form of utility functions or additional generated methods of the Any type. Example 1: Pack and unpack a message in C++. Foo foo = ...; Any any; any.PackFrom(foo); ... if (any.UnpackTo(&foo)) { ... } Example 2: Pack and unpack a message in Java. Foo foo = ...; Any any = Any.pack(foo); ... if (any.is(Foo.class)) { foo = any.unpack(Foo.class); } Example 3: Pack and unpack a message in Python. foo = Foo(...) any = Any() any.Pack(foo) ... if any.Is(Foo.DESCRIPTOR): any.Unpack(foo) ... Example 4: Pack and unpack a message in Go foo := &pb.Foo{...} any, err := anypb.New(foo) if err != nil { ... } ... foo := &pb.Foo{} if err := any.UnmarshalTo(foo); err != nil { ... } The pack methods provided by protobuf library will by default use 'type.googleapis.com/full.type.name' as the type URL and the unpack methods only use the fully qualified type name after the last '/' in the type URL, for example "foo.bar.com/x/y.z" will yield type name "y.z". JSON ==== The JSON representation of an `Any` value uses the regular representation of the deserialized, embedded message, with an additional field `@type` which contains the type URL. Example: package google.profile; message Person { string first_name = 1; string last_name = 2; } { "@type": "type.googleapis.com/google.profile.Person", "firstName": , "lastName": } If the embedded message type is well-known and has a custom JSON representation, that representation will be embedded adding a field `value` which holds the custom JSON in addition to the `@type` field. Example (for message [google.protobuf.Duration][]): { "@type": "type.googleapis.com/google.protobuf.Duration", "value": "1.212s" } parameters: - name: address description: address is the ethereum hex address to query the code for. in: path required: true type: string tags: - Query /ethermint/evm/v1/cosmos_account/{address}: get: summary: CosmosAccount queries an Ethereum account's Cosmos Address. operationId: CosmosAccount responses: '200': description: A successful response. schema: type: object properties: cosmos_address: type: string description: cosmos_address is the cosmos address of the account. sequence: type: string format: uint64 description: sequence is the account's sequence number. account_number: type: string format: uint64 title: account_number is the account numbert description: >- QueryCosmosAccountResponse is the response type for the Query/CosmosAccount RPC method. default: description: An unexpected error response. schema: type: object properties: error: type: string code: type: integer format: int32 message: type: string details: type: array items: type: object properties: type_url: type: string description: >- A URL/resource name that uniquely identifies the type of the serialized protocol buffer message. This string must contain at least one "/" character. The last segment of the URL's path must represent the fully qualified name of the type (as in `path/google.protobuf.Duration`). The name should be in a canonical form (e.g., leading "." is not accepted). In practice, teams usually precompile into the binary all types that they expect it to use in the context of Any. However, for URLs which use the scheme `http`, `https`, or no scheme, one can optionally set up a type server that maps type URLs to message definitions as follows: * If no scheme is provided, `https` is assumed. * An HTTP GET on the URL must yield a [google.protobuf.Type][] value in binary format, or produce an error. * Applications are allowed to cache lookup results based on the URL, or have them precompiled into a binary to avoid any lookup. Therefore, binary compatibility needs to be preserved on changes to types. (Use versioned type names to manage breaking changes.) Note: this functionality is not currently available in the official protobuf release, and it is not used for type URLs beginning with type.googleapis.com. Schemes other than `http`, `https` (or the empty scheme) might be used with implementation specific semantics. value: type: string format: byte description: >- Must be a valid serialized protocol buffer of the above specified type. description: >- `Any` contains an arbitrary serialized protocol buffer message along with a URL that describes the type of the serialized message. Protobuf library provides support to pack/unpack Any values in the form of utility functions or additional generated methods of the Any type. Example 1: Pack and unpack a message in C++. Foo foo = ...; Any any; any.PackFrom(foo); ... if (any.UnpackTo(&foo)) { ... } Example 2: Pack and unpack a message in Java. Foo foo = ...; Any any = Any.pack(foo); ... if (any.is(Foo.class)) { foo = any.unpack(Foo.class); } Example 3: Pack and unpack a message in Python. foo = Foo(...) any = Any() any.Pack(foo) ... if any.Is(Foo.DESCRIPTOR): any.Unpack(foo) ... Example 4: Pack and unpack a message in Go foo := &pb.Foo{...} any, err := anypb.New(foo) if err != nil { ... } ... foo := &pb.Foo{} if err := any.UnmarshalTo(foo); err != nil { ... } The pack methods provided by protobuf library will by default use 'type.googleapis.com/full.type.name' as the type URL and the unpack methods only use the fully qualified type name after the last '/' in the type URL, for example "foo.bar.com/x/y.z" will yield type name "y.z". JSON ==== The JSON representation of an `Any` value uses the regular representation of the deserialized, embedded message, with an additional field `@type` which contains the type URL. Example: package google.profile; message Person { string first_name = 1; string last_name = 2; } { "@type": "type.googleapis.com/google.profile.Person", "firstName": , "lastName": } If the embedded message type is well-known and has a custom JSON representation, that representation will be embedded adding a field `value` which holds the custom JSON in addition to the `@type` field. Example (for message [google.protobuf.Duration][]): { "@type": "type.googleapis.com/google.protobuf.Duration", "value": "1.212s" } parameters: - name: address description: address is the ethereum hex address to query the account for. in: path required: true type: string tags: - Query /ethermint/evm/v1/estimate_gas: get: summary: EstimateGas implements the `eth_estimateGas` rpc api operationId: EstimateGas responses: '200': description: A successful response. schema: type: object properties: gas: type: string format: uint64 title: the estimated gas title: EstimateGasResponse defines EstimateGas response default: description: An unexpected error response. schema: type: object properties: error: type: string code: type: integer format: int32 message: type: string details: type: array items: type: object properties: type_url: type: string description: >- A URL/resource name that uniquely identifies the type of the serialized protocol buffer message. This string must contain at least one "/" character. The last segment of the URL's path must represent the fully qualified name of the type (as in `path/google.protobuf.Duration`). The name should be in a canonical form (e.g., leading "." is not accepted). In practice, teams usually precompile into the binary all types that they expect it to use in the context of Any. However, for URLs which use the scheme `http`, `https`, or no scheme, one can optionally set up a type server that maps type URLs to message definitions as follows: * If no scheme is provided, `https` is assumed. * An HTTP GET on the URL must yield a [google.protobuf.Type][] value in binary format, or produce an error. * Applications are allowed to cache lookup results based on the URL, or have them precompiled into a binary to avoid any lookup. Therefore, binary compatibility needs to be preserved on changes to types. (Use versioned type names to manage breaking changes.) Note: this functionality is not currently available in the official protobuf release, and it is not used for type URLs beginning with type.googleapis.com. Schemes other than `http`, `https` (or the empty scheme) might be used with implementation specific semantics. value: type: string format: byte description: >- Must be a valid serialized protocol buffer of the above specified type. description: >- `Any` contains an arbitrary serialized protocol buffer message along with a URL that describes the type of the serialized message. Protobuf library provides support to pack/unpack Any values in the form of utility functions or additional generated methods of the Any type. Example 1: Pack and unpack a message in C++. Foo foo = ...; Any any; any.PackFrom(foo); ... if (any.UnpackTo(&foo)) { ... } Example 2: Pack and unpack a message in Java. Foo foo = ...; Any any = Any.pack(foo); ... if (any.is(Foo.class)) { foo = any.unpack(Foo.class); } Example 3: Pack and unpack a message in Python. foo = Foo(...) any = Any() any.Pack(foo) ... if any.Is(Foo.DESCRIPTOR): any.Unpack(foo) ... Example 4: Pack and unpack a message in Go foo := &pb.Foo{...} any, err := anypb.New(foo) if err != nil { ... } ... foo := &pb.Foo{} if err := any.UnmarshalTo(foo); err != nil { ... } The pack methods provided by protobuf library will by default use 'type.googleapis.com/full.type.name' as the type URL and the unpack methods only use the fully qualified type name after the last '/' in the type URL, for example "foo.bar.com/x/y.z" will yield type name "y.z". JSON ==== The JSON representation of an `Any` value uses the regular representation of the deserialized, embedded message, with an additional field `@type` which contains the type URL. Example: package google.profile; message Person { string first_name = 1; string last_name = 2; } { "@type": "type.googleapis.com/google.profile.Person", "firstName": , "lastName": } If the embedded message type is well-known and has a custom JSON representation, that representation will be embedded adding a field `value` which holds the custom JSON in addition to the `@type` field. Example (for message [google.protobuf.Duration][]): { "@type": "type.googleapis.com/google.protobuf.Duration", "value": "1.212s" } parameters: - name: args description: same json format as the json rpc api. in: query required: false type: string format: byte - name: gas_cap description: the default gas cap to be used. in: query required: false type: string format: uint64 - name: proposer_address description: the proposer of the requested block. in: query required: false type: string format: byte - name: chain_id description: the eip155 chain id parsed from the requested block header. in: query required: false type: string format: int64 tags: - Query /ethermint/evm/v1/eth_call: get: summary: EthCall implements the `eth_call` rpc api operationId: EthCall responses: '200': description: A successful response. schema: type: object properties: hash: type: string title: >- ethereum transaction hash in hex format. This hash differs from the Tendermint sha256 hash of the transaction bytes. See https://github.com/tendermint/tendermint/issues/6539 for reference logs: type: array items: type: object properties: address: type: string title: address of the contract that generated the event topics: type: array items: type: string description: list of topics provided by the contract. data: type: string format: byte title: supplied by the contract, usually ABI-encoded block_number: type: string format: uint64 title: block in which the transaction was included tx_hash: type: string title: hash of the transaction tx_index: type: string format: uint64 title: index of the transaction in the block block_hash: type: string title: hash of the block in which the transaction was included index: type: string format: uint64 title: index of the log in the block removed: type: boolean description: >- The Removed field is true if this log was reverted due to a chain reorganisation. You must pay attention to this field if you receive logs through a filter query. description: >- 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. description: >- logs contains the transaction hash and the proto-compatible ethereum logs. ret: type: string format: byte title: >- returned data from evm function (result or data supplied with revert opcode) vm_error: type: string title: vm error is the error returned by vm execution gas_used: type: string format: uint64 title: gas consumed by the transaction description: MsgEthereumTxResponse defines the Msg/EthereumTx response type. default: description: An unexpected error response. schema: type: object properties: error: type: string code: type: integer format: int32 message: type: string details: type: array items: type: object properties: type_url: type: string description: >- A URL/resource name that uniquely identifies the type of the serialized protocol buffer message. This string must contain at least one "/" character. The last segment of the URL's path must represent the fully qualified name of the type (as in `path/google.protobuf.Duration`). The name should be in a canonical form (e.g., leading "." is not accepted). In practice, teams usually precompile into the binary all types that they expect it to use in the context of Any. However, for URLs which use the scheme `http`, `https`, or no scheme, one can optionally set up a type server that maps type URLs to message definitions as follows: * If no scheme is provided, `https` is assumed. * An HTTP GET on the URL must yield a [google.protobuf.Type][] value in binary format, or produce an error. * Applications are allowed to cache lookup results based on the URL, or have them precompiled into a binary to avoid any lookup. Therefore, binary compatibility needs to be preserved on changes to types. (Use versioned type names to manage breaking changes.) Note: this functionality is not currently available in the official protobuf release, and it is not used for type URLs beginning with type.googleapis.com. Schemes other than `http`, `https` (or the empty scheme) might be used with implementation specific semantics. value: type: string format: byte description: >- Must be a valid serialized protocol buffer of the above specified type. description: >- `Any` contains an arbitrary serialized protocol buffer message along with a URL that describes the type of the serialized message. Protobuf library provides support to pack/unpack Any values in the form of utility functions or additional generated methods of the Any type. Example 1: Pack and unpack a message in C++. Foo foo = ...; Any any; any.PackFrom(foo); ... if (any.UnpackTo(&foo)) { ... } Example 2: Pack and unpack a message in Java. Foo foo = ...; Any any = Any.pack(foo); ... if (any.is(Foo.class)) { foo = any.unpack(Foo.class); } Example 3: Pack and unpack a message in Python. foo = Foo(...) any = Any() any.Pack(foo) ... if any.Is(Foo.DESCRIPTOR): any.Unpack(foo) ... Example 4: Pack and unpack a message in Go foo := &pb.Foo{...} any, err := anypb.New(foo) if err != nil { ... } ... foo := &pb.Foo{} if err := any.UnmarshalTo(foo); err != nil { ... } The pack methods provided by protobuf library will by default use 'type.googleapis.com/full.type.name' as the type URL and the unpack methods only use the fully qualified type name after the last '/' in the type URL, for example "foo.bar.com/x/y.z" will yield type name "y.z". JSON ==== The JSON representation of an `Any` value uses the regular representation of the deserialized, embedded message, with an additional field `@type` which contains the type URL. Example: package google.profile; message Person { string first_name = 1; string last_name = 2; } { "@type": "type.googleapis.com/google.profile.Person", "firstName": , "lastName": } If the embedded message type is well-known and has a custom JSON representation, that representation will be embedded adding a field `value` which holds the custom JSON in addition to the `@type` field. Example (for message [google.protobuf.Duration][]): { "@type": "type.googleapis.com/google.protobuf.Duration", "value": "1.212s" } parameters: - name: args description: same json format as the json rpc api. in: query required: false type: string format: byte - name: gas_cap description: the default gas cap to be used. in: query required: false type: string format: uint64 - name: proposer_address description: the proposer of the requested block. in: query required: false type: string format: byte - name: chain_id description: the eip155 chain id parsed from the requested block header. in: query required: false type: string format: int64 tags: - Query /ethermint/evm/v1/params: get: summary: Params queries the parameters of x/evm module. operationId: EvmParams responses: '200': description: A successful response. schema: type: object properties: params: description: params define the evm module parameters. type: object properties: evm_denom: type: string description: >- evm denom represents the token denomination used to run the EVM state transitions. enable_create: type: boolean title: >- enable create toggles state transitions that use the vm.Create function enable_call: type: boolean title: >- enable call toggles state transitions that use the vm.Call function extra_eips: type: array items: type: string format: int64 title: extra eips defines the additional EIPs for the vm.Config chain_config: title: >- chain config defines the EVM chain configuration parameters type: object properties: homestead_block: type: string title: >- Homestead switch block (nil no fork, 0 = already homestead) dao_fork_block: type: string title: TheDAO hard-fork switch block (nil no fork) dao_fork_support: type: boolean title: >- Whether the nodes supports or opposes the DAO hard-fork eip150_block: type: string title: >- EIP150 implements the Gas price changes (https://github.com/ethereum/EIPs/issues/150) EIP150 HF block (nil no fork) eip150_hash: type: string title: >- EIP150 HF hash (needed for header only clients as only gas pricing changed) eip155_block: type: string title: EIP155Block HF block eip158_block: type: string title: EIP158 HF block byzantium_block: type: string title: >- Byzantium switch block (nil no fork, 0 = already on byzantium) constantinople_block: type: string title: >- Constantinople switch block (nil no fork, 0 = already activated) petersburg_block: type: string title: Petersburg switch block (nil same as Constantinople) istanbul_block: type: string title: >- Istanbul switch block (nil no fork, 0 = already on istanbul) muir_glacier_block: type: string title: >- Eip-2384 (bomb delay) switch block (nil no fork, 0 = already activated) berlin_block: type: string title: >- Berlin switch block (nil = no fork, 0 = already on berlin) london_block: type: string title: >- London switch block (nil = no fork, 0 = already on london) arrow_glacier_block: type: string title: >- Eip-4345 (bomb delay) switch block (nil = no fork, 0 = already activated) gray_glacier_block: type: string title: >- EIP-5133 (bomb delay) switch block (nil = no fork, 0 = already activated) merge_netsplit_block: type: string title: >- Virtual fork after The Merge to use as a network splitter description: >- ChainConfig defines the Ethereum ChainConfig parameters using *sdk.Int values instead of *big.Int. allow_unprotected_txs: type: boolean description: >- Allow unprotected transactions defines if replay-protected (i.e non EIP155 signed) transactions can be executed on the state machine. title: Params defines the EVM module parameters description: >- QueryParamsResponse defines the response type for querying x/evm parameters. default: description: An unexpected error response. schema: type: object properties: error: type: string code: type: integer format: int32 message: type: string details: type: array items: type: object properties: type_url: type: string description: >- A URL/resource name that uniquely identifies the type of the serialized protocol buffer message. This string must contain at least one "/" character. The last segment of the URL's path must represent the fully qualified name of the type (as in `path/google.protobuf.Duration`). The name should be in a canonical form (e.g., leading "." is not accepted). In practice, teams usually precompile into the binary all types that they expect it to use in the context of Any. However, for URLs which use the scheme `http`, `https`, or no scheme, one can optionally set up a type server that maps type URLs to message definitions as follows: * If no scheme is provided, `https` is assumed. * An HTTP GET on the URL must yield a [google.protobuf.Type][] value in binary format, or produce an error. * Applications are allowed to cache lookup results based on the URL, or have them precompiled into a binary to avoid any lookup. Therefore, binary compatibility needs to be preserved on changes to types. (Use versioned type names to manage breaking changes.) Note: this functionality is not currently available in the official protobuf release, and it is not used for type URLs beginning with type.googleapis.com. Schemes other than `http`, `https` (or the empty scheme) might be used with implementation specific semantics. value: type: string format: byte description: >- Must be a valid serialized protocol buffer of the above specified type. description: >- `Any` contains an arbitrary serialized protocol buffer message along with a URL that describes the type of the serialized message. Protobuf library provides support to pack/unpack Any values in the form of utility functions or additional generated methods of the Any type. Example 1: Pack and unpack a message in C++. Foo foo = ...; Any any; any.PackFrom(foo); ... if (any.UnpackTo(&foo)) { ... } Example 2: Pack and unpack a message in Java. Foo foo = ...; Any any = Any.pack(foo); ... if (any.is(Foo.class)) { foo = any.unpack(Foo.class); } Example 3: Pack and unpack a message in Python. foo = Foo(...) any = Any() any.Pack(foo) ... if any.Is(Foo.DESCRIPTOR): any.Unpack(foo) ... Example 4: Pack and unpack a message in Go foo := &pb.Foo{...} any, err := anypb.New(foo) if err != nil { ... } ... foo := &pb.Foo{} if err := any.UnmarshalTo(foo); err != nil { ... } The pack methods provided by protobuf library will by default use 'type.googleapis.com/full.type.name' as the type URL and the unpack methods only use the fully qualified type name after the last '/' in the type URL, for example "foo.bar.com/x/y.z" will yield type name "y.z". JSON ==== The JSON representation of an `Any` value uses the regular representation of the deserialized, embedded message, with an additional field `@type` which contains the type URL. Example: package google.profile; message Person { string first_name = 1; string last_name = 2; } { "@type": "type.googleapis.com/google.profile.Person", "firstName": , "lastName": } If the embedded message type is well-known and has a custom JSON representation, that representation will be embedded adding a field `value` which holds the custom JSON in addition to the `@type` field. Example (for message [google.protobuf.Duration][]): { "@type": "type.googleapis.com/google.protobuf.Duration", "value": "1.212s" } tags: - Query /ethermint/evm/v1/storage/{address}/{key}: get: summary: Storage queries the balance of all coins for a single account. operationId: Storage responses: '200': description: A successful response. schema: type: object properties: value: type: string description: >- key defines the storage state value hash associated with the given key. description: >- QueryStorageResponse is the response type for the Query/Storage RPC method. default: description: An unexpected error response. schema: type: object properties: error: type: string code: type: integer format: int32 message: type: string details: type: array items: type: object properties: type_url: type: string description: >- A URL/resource name that uniquely identifies the type of the serialized protocol buffer message. This string must contain at least one "/" character. The last segment of the URL's path must represent the fully qualified name of the type (as in `path/google.protobuf.Duration`). The name should be in a canonical form (e.g., leading "." is not accepted). In practice, teams usually precompile into the binary all types that they expect it to use in the context of Any. However, for URLs which use the scheme `http`, `https`, or no scheme, one can optionally set up a type server that maps type URLs to message definitions as follows: * If no scheme is provided, `https` is assumed. * An HTTP GET on the URL must yield a [google.protobuf.Type][] value in binary format, or produce an error. * Applications are allowed to cache lookup results based on the URL, or have them precompiled into a binary to avoid any lookup. Therefore, binary compatibility needs to be preserved on changes to types. (Use versioned type names to manage breaking changes.) Note: this functionality is not currently available in the official protobuf release, and it is not used for type URLs beginning with type.googleapis.com. Schemes other than `http`, `https` (or the empty scheme) might be used with implementation specific semantics. value: type: string format: byte description: >- Must be a valid serialized protocol buffer of the above specified type. description: >- `Any` contains an arbitrary serialized protocol buffer message along with a URL that describes the type of the serialized message. Protobuf library provides support to pack/unpack Any values in the form of utility functions or additional generated methods of the Any type. Example 1: Pack and unpack a message in C++. Foo foo = ...; Any any; any.PackFrom(foo); ... if (any.UnpackTo(&foo)) { ... } Example 2: Pack and unpack a message in Java. Foo foo = ...; Any any = Any.pack(foo); ... if (any.is(Foo.class)) { foo = any.unpack(Foo.class); } Example 3: Pack and unpack a message in Python. foo = Foo(...) any = Any() any.Pack(foo) ... if any.Is(Foo.DESCRIPTOR): any.Unpack(foo) ... Example 4: Pack and unpack a message in Go foo := &pb.Foo{...} any, err := anypb.New(foo) if err != nil { ... } ... foo := &pb.Foo{} if err := any.UnmarshalTo(foo); err != nil { ... } The pack methods provided by protobuf library will by default use 'type.googleapis.com/full.type.name' as the type URL and the unpack methods only use the fully qualified type name after the last '/' in the type URL, for example "foo.bar.com/x/y.z" will yield type name "y.z". JSON ==== The JSON representation of an `Any` value uses the regular representation of the deserialized, embedded message, with an additional field `@type` which contains the type URL. Example: package google.profile; message Person { string first_name = 1; string last_name = 2; } { "@type": "type.googleapis.com/google.profile.Person", "firstName": , "lastName": } If the embedded message type is well-known and has a custom JSON representation, that representation will be embedded adding a field `value` which holds the custom JSON in addition to the `@type` field. Example (for message [google.protobuf.Duration][]): { "@type": "type.googleapis.com/google.protobuf.Duration", "value": "1.212s" } parameters: - name: address description: >- / address is the ethereum hex address to query the storage state for. in: path required: true type: string - name: key description: key defines the key of the storage state in: path required: true type: string tags: - Query /ethermint/evm/v1/trace_block: get: summary: >- TraceBlock implements the `debug_traceBlockByNumber` and `debug_traceBlockByHash` rpc api operationId: TraceBlock responses: '200': description: A successful response. schema: type: object properties: data: type: string format: byte title: QueryTraceBlockResponse defines TraceBlock response default: description: An unexpected error response. schema: type: object properties: error: type: string code: type: integer format: int32 message: type: string details: type: array items: type: object properties: type_url: type: string description: >- A URL/resource name that uniquely identifies the type of the serialized protocol buffer message. This string must contain at least one "/" character. The last segment of the URL's path must represent the fully qualified name of the type (as in `path/google.protobuf.Duration`). The name should be in a canonical form (e.g., leading "." is not accepted). In practice, teams usually precompile into the binary all types that they expect it to use in the context of Any. However, for URLs which use the scheme `http`, `https`, or no scheme, one can optionally set up a type server that maps type URLs to message definitions as follows: * If no scheme is provided, `https` is assumed. * An HTTP GET on the URL must yield a [google.protobuf.Type][] value in binary format, or produce an error. * Applications are allowed to cache lookup results based on the URL, or have them precompiled into a binary to avoid any lookup. Therefore, binary compatibility needs to be preserved on changes to types. (Use versioned type names to manage breaking changes.) Note: this functionality is not currently available in the official protobuf release, and it is not used for type URLs beginning with type.googleapis.com. Schemes other than `http`, `https` (or the empty scheme) might be used with implementation specific semantics. value: type: string format: byte description: >- Must be a valid serialized protocol buffer of the above specified type. description: >- `Any` contains an arbitrary serialized protocol buffer message along with a URL that describes the type of the serialized message. Protobuf library provides support to pack/unpack Any values in the form of utility functions or additional generated methods of the Any type. Example 1: Pack and unpack a message in C++. Foo foo = ...; Any any; any.PackFrom(foo); ... if (any.UnpackTo(&foo)) { ... } Example 2: Pack and unpack a message in Java. Foo foo = ...; Any any = Any.pack(foo); ... if (any.is(Foo.class)) { foo = any.unpack(Foo.class); } Example 3: Pack and unpack a message in Python. foo = Foo(...) any = Any() any.Pack(foo) ... if any.Is(Foo.DESCRIPTOR): any.Unpack(foo) ... Example 4: Pack and unpack a message in Go foo := &pb.Foo{...} any, err := anypb.New(foo) if err != nil { ... } ... foo := &pb.Foo{} if err := any.UnmarshalTo(foo); err != nil { ... } The pack methods provided by protobuf library will by default use 'type.googleapis.com/full.type.name' as the type URL and the unpack methods only use the fully qualified type name after the last '/' in the type URL, for example "foo.bar.com/x/y.z" will yield type name "y.z". JSON ==== The JSON representation of an `Any` value uses the regular representation of the deserialized, embedded message, with an additional field `@type` which contains the type URL. Example: package google.profile; message Person { string first_name = 1; string last_name = 2; } { "@type": "type.googleapis.com/google.profile.Person", "firstName": , "lastName": } If the embedded message type is well-known and has a custom JSON representation, that representation will be embedded adding a field `value` which holds the custom JSON in addition to the `@type` field. Example (for message [google.protobuf.Duration][]): { "@type": "type.googleapis.com/google.protobuf.Duration", "value": "1.212s" } parameters: - name: trace_config.tracer description: custom javascript tracer. in: query required: false type: string - name: trace_config.timeout description: >- overrides the default timeout of 5 seconds for JavaScript-based tracing calls. in: query required: false type: string - name: trace_config.reexec description: number of blocks the tracer is willing to go back. in: query required: false type: string format: uint64 - name: trace_config.disable_stack description: disable stack capture. in: query required: false type: boolean - name: trace_config.disable_storage description: disable storage capture. in: query required: false type: boolean - name: trace_config.debug description: print output during capture end. in: query required: false type: boolean - name: trace_config.limit description: maximum length of output, but zero means unlimited. in: query required: false type: integer format: int32 - name: trace_config.overrides.homestead_block description: Homestead switch block (nil no fork, 0 = already homestead). in: query required: false type: string - name: trace_config.overrides.dao_fork_block description: TheDAO hard-fork switch block (nil no fork). in: query required: false type: string - name: trace_config.overrides.dao_fork_support description: Whether the nodes supports or opposes the DAO hard-fork. in: query required: false type: boolean - name: trace_config.overrides.eip150_block description: >- EIP150 implements the Gas price changes (https://github.com/ethereum/EIPs/issues/150) EIP150 HF block (nil no fork). in: query required: false type: string - name: trace_config.overrides.eip150_hash description: >- EIP150 HF hash (needed for header only clients as only gas pricing changed). in: query required: false type: string - name: trace_config.overrides.eip155_block description: EIP155Block HF block. in: query required: false type: string - name: trace_config.overrides.eip158_block description: EIP158 HF block. in: query required: false type: string - name: trace_config.overrides.byzantium_block description: Byzantium switch block (nil no fork, 0 = already on byzantium). in: query required: false type: string - name: trace_config.overrides.constantinople_block description: Constantinople switch block (nil no fork, 0 = already activated). in: query required: false type: string - name: trace_config.overrides.petersburg_block description: Petersburg switch block (nil same as Constantinople). in: query required: false type: string - name: trace_config.overrides.istanbul_block description: Istanbul switch block (nil no fork, 0 = already on istanbul). in: query required: false type: string - name: trace_config.overrides.muir_glacier_block description: >- Eip-2384 (bomb delay) switch block (nil no fork, 0 = already activated). in: query required: false type: string - name: trace_config.overrides.berlin_block description: Berlin switch block (nil = no fork, 0 = already on berlin). in: query required: false type: string - name: trace_config.overrides.london_block description: London switch block (nil = no fork, 0 = already on london). in: query required: false type: string - name: trace_config.overrides.arrow_glacier_block description: >- Eip-4345 (bomb delay) switch block (nil = no fork, 0 = already activated). in: query required: false type: string - name: trace_config.overrides.gray_glacier_block description: >- EIP-5133 (bomb delay) switch block (nil = no fork, 0 = already activated). in: query required: false type: string - name: trace_config.overrides.merge_netsplit_block description: Virtual fork after The Merge to use as a network splitter. in: query required: false type: string - name: trace_config.enable_memory description: enable memory capture. in: query required: false type: boolean - name: trace_config.enable_return_data description: enable return data capture. in: query required: false type: boolean - name: trace_config.tracer_json_config description: tracer config. in: query required: false type: string - name: block_number description: block number. in: query required: false type: string format: int64 - name: block_hash description: block hex hash. in: query required: false type: string - name: block_time description: block time. in: query required: false type: string format: date-time - name: proposer_address description: the proposer of the requested block. in: query required: false type: string format: byte - name: chain_id description: the eip155 chain id parsed from the requested block header. in: query required: false type: string format: int64 tags: - Query /ethermint/evm/v1/trace_tx: get: summary: TraceTx implements the `debug_traceTransaction` rpc api operationId: TraceTx responses: '200': description: A successful response. schema: type: object properties: data: type: string format: byte title: response serialized in bytes title: QueryTraceTxResponse defines TraceTx response default: description: An unexpected error response. schema: type: object properties: error: type: string code: type: integer format: int32 message: type: string details: type: array items: type: object properties: type_url: type: string description: >- A URL/resource name that uniquely identifies the type of the serialized protocol buffer message. This string must contain at least one "/" character. The last segment of the URL's path must represent the fully qualified name of the type (as in `path/google.protobuf.Duration`). The name should be in a canonical form (e.g., leading "." is not accepted). In practice, teams usually precompile into the binary all types that they expect it to use in the context of Any. However, for URLs which use the scheme `http`, `https`, or no scheme, one can optionally set up a type server that maps type URLs to message definitions as follows: * If no scheme is provided, `https` is assumed. * An HTTP GET on the URL must yield a [google.protobuf.Type][] value in binary format, or produce an error. * Applications are allowed to cache lookup results based on the URL, or have them precompiled into a binary to avoid any lookup. Therefore, binary compatibility needs to be preserved on changes to types. (Use versioned type names to manage breaking changes.) Note: this functionality is not currently available in the official protobuf release, and it is not used for type URLs beginning with type.googleapis.com. Schemes other than `http`, `https` (or the empty scheme) might be used with implementation specific semantics. value: type: string format: byte description: >- Must be a valid serialized protocol buffer of the above specified type. description: >- `Any` contains an arbitrary serialized protocol buffer message along with a URL that describes the type of the serialized message. Protobuf library provides support to pack/unpack Any values in the form of utility functions or additional generated methods of the Any type. Example 1: Pack and unpack a message in C++. Foo foo = ...; Any any; any.PackFrom(foo); ... if (any.UnpackTo(&foo)) { ... } Example 2: Pack and unpack a message in Java. Foo foo = ...; Any any = Any.pack(foo); ... if (any.is(Foo.class)) { foo = any.unpack(Foo.class); } Example 3: Pack and unpack a message in Python. foo = Foo(...) any = Any() any.Pack(foo) ... if any.Is(Foo.DESCRIPTOR): any.Unpack(foo) ... Example 4: Pack and unpack a message in Go foo := &pb.Foo{...} any, err := anypb.New(foo) if err != nil { ... } ... foo := &pb.Foo{} if err := any.UnmarshalTo(foo); err != nil { ... } The pack methods provided by protobuf library will by default use 'type.googleapis.com/full.type.name' as the type URL and the unpack methods only use the fully qualified type name after the last '/' in the type URL, for example "foo.bar.com/x/y.z" will yield type name "y.z". JSON ==== The JSON representation of an `Any` value uses the regular representation of the deserialized, embedded message, with an additional field `@type` which contains the type URL. Example: package google.profile; message Person { string first_name = 1; string last_name = 2; } { "@type": "type.googleapis.com/google.profile.Person", "firstName": , "lastName": } If the embedded message type is well-known and has a custom JSON representation, that representation will be embedded adding a field `value` which holds the custom JSON in addition to the `@type` field. Example (for message [google.protobuf.Duration][]): { "@type": "type.googleapis.com/google.protobuf.Duration", "value": "1.212s" } parameters: - name: msg.data.type_url description: >- A URL/resource name that uniquely identifies the type of the serialized protocol buffer message. This string must contain at least one "/" character. The last segment of the URL's path must represent the fully qualified name of the type (as in `path/google.protobuf.Duration`). The name should be in a canonical form (e.g., leading "." is not accepted). In practice, teams usually precompile into the binary all types that they expect it to use in the context of Any. However, for URLs which use the scheme `http`, `https`, or no scheme, one can optionally set up a type server that maps type URLs to message definitions as follows: * If no scheme is provided, `https` is assumed. * An HTTP GET on the URL must yield a [google.protobuf.Type][] value in binary format, or produce an error. * Applications are allowed to cache lookup results based on the URL, or have them precompiled into a binary to avoid any lookup. Therefore, binary compatibility needs to be preserved on changes to types. (Use versioned type names to manage breaking changes.) Note: this functionality is not currently available in the official protobuf release, and it is not used for type URLs beginning with type.googleapis.com. Schemes other than `http`, `https` (or the empty scheme) might be used with implementation specific semantics. in: query required: false type: string - name: msg.data.value description: >- Must be a valid serialized protocol buffer of the above specified type. in: query required: false type: string format: byte - name: msg.size description: 'DEPRECATED: encoded storage size of the transaction.' in: query required: false type: number format: double - name: msg.hash description: transaction hash in hex format. in: query required: false type: string - name: msg.from description: |- 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. in: query required: false type: string - name: trace_config.tracer description: custom javascript tracer. in: query required: false type: string - name: trace_config.timeout description: >- overrides the default timeout of 5 seconds for JavaScript-based tracing calls. in: query required: false type: string - name: trace_config.reexec description: number of blocks the tracer is willing to go back. in: query required: false type: string format: uint64 - name: trace_config.disable_stack description: disable stack capture. in: query required: false type: boolean - name: trace_config.disable_storage description: disable storage capture. in: query required: false type: boolean - name: trace_config.debug description: print output during capture end. in: query required: false type: boolean - name: trace_config.limit description: maximum length of output, but zero means unlimited. in: query required: false type: integer format: int32 - name: trace_config.overrides.homestead_block description: Homestead switch block (nil no fork, 0 = already homestead). in: query required: false type: string - name: trace_config.overrides.dao_fork_block description: TheDAO hard-fork switch block (nil no fork). in: query required: false type: string - name: trace_config.overrides.dao_fork_support description: Whether the nodes supports or opposes the DAO hard-fork. in: query required: false type: boolean - name: trace_config.overrides.eip150_block description: >- EIP150 implements the Gas price changes (https://github.com/ethereum/EIPs/issues/150) EIP150 HF block (nil no fork). in: query required: false type: string - name: trace_config.overrides.eip150_hash description: >- EIP150 HF hash (needed for header only clients as only gas pricing changed). in: query required: false type: string - name: trace_config.overrides.eip155_block description: EIP155Block HF block. in: query required: false type: string - name: trace_config.overrides.eip158_block description: EIP158 HF block. in: query required: false type: string - name: trace_config.overrides.byzantium_block description: Byzantium switch block (nil no fork, 0 = already on byzantium). in: query required: false type: string - name: trace_config.overrides.constantinople_block description: Constantinople switch block (nil no fork, 0 = already activated). in: query required: false type: string - name: trace_config.overrides.petersburg_block description: Petersburg switch block (nil same as Constantinople). in: query required: false type: string - name: trace_config.overrides.istanbul_block description: Istanbul switch block (nil no fork, 0 = already on istanbul). in: query required: false type: string - name: trace_config.overrides.muir_glacier_block description: >- Eip-2384 (bomb delay) switch block (nil no fork, 0 = already activated). in: query required: false type: string - name: trace_config.overrides.berlin_block description: Berlin switch block (nil = no fork, 0 = already on berlin). in: query required: false type: string - name: trace_config.overrides.london_block description: London switch block (nil = no fork, 0 = already on london). in: query required: false type: string - name: trace_config.overrides.arrow_glacier_block description: >- Eip-4345 (bomb delay) switch block (nil = no fork, 0 = already activated). in: query required: false type: string - name: trace_config.overrides.gray_glacier_block description: >- EIP-5133 (bomb delay) switch block (nil = no fork, 0 = already activated). in: query required: false type: string - name: trace_config.overrides.merge_netsplit_block description: Virtual fork after The Merge to use as a network splitter. in: query required: false type: string - name: trace_config.enable_memory description: enable memory capture. in: query required: false type: boolean - name: trace_config.enable_return_data description: enable return data capture. in: query required: false type: boolean - name: trace_config.tracer_json_config description: tracer config. in: query required: false type: string - name: block_number description: block number of requested transaction. in: query required: false type: string format: int64 - name: block_hash description: block hex hash of requested transaction. in: query required: false type: string - name: block_time description: block time of requested transaction. in: query required: false type: string format: date-time - name: proposer_address description: the proposer of the requested block. in: query required: false type: string format: byte - name: chain_id description: the eip155 chain id parsed from the requested block header. in: query required: false type: string format: int64 tags: - Query /ethermint/evm/v1/validator_account/{cons_address}: get: summary: >- ValidatorAccount queries an Ethereum account's from a validator consensus Address. operationId: ValidatorAccount responses: '200': description: A successful response. schema: type: object properties: account_address: type: string description: >- account_address is the cosmos address of the account in bech32 format. sequence: type: string format: uint64 description: sequence is the account's sequence number. account_number: type: string format: uint64 title: account_number is the account number description: |- QueryValidatorAccountResponse is the response type for the Query/ValidatorAccount RPC method. default: description: An unexpected error response. schema: type: object properties: error: type: string code: type: integer format: int32 message: type: string details: type: array items: type: object properties: type_url: type: string description: >- A URL/resource name that uniquely identifies the type of the serialized protocol buffer message. This string must contain at least one "/" character. The last segment of the URL's path must represent the fully qualified name of the type (as in `path/google.protobuf.Duration`). The name should be in a canonical form (e.g., leading "." is not accepted). In practice, teams usually precompile into the binary all types that they expect it to use in the context of Any. However, for URLs which use the scheme `http`, `https`, or no scheme, one can optionally set up a type server that maps type URLs to message definitions as follows: * If no scheme is provided, `https` is assumed. * An HTTP GET on the URL must yield a [google.protobuf.Type][] value in binary format, or produce an error. * Applications are allowed to cache lookup results based on the URL, or have them precompiled into a binary to avoid any lookup. Therefore, binary compatibility needs to be preserved on changes to types. (Use versioned type names to manage breaking changes.) Note: this functionality is not currently available in the official protobuf release, and it is not used for type URLs beginning with type.googleapis.com. Schemes other than `http`, `https` (or the empty scheme) might be used with implementation specific semantics. value: type: string format: byte description: >- Must be a valid serialized protocol buffer of the above specified type. description: >- `Any` contains an arbitrary serialized protocol buffer message along with a URL that describes the type of the serialized message. Protobuf library provides support to pack/unpack Any values in the form of utility functions or additional generated methods of the Any type. Example 1: Pack and unpack a message in C++. Foo foo = ...; Any any; any.PackFrom(foo); ... if (any.UnpackTo(&foo)) { ... } Example 2: Pack and unpack a message in Java. Foo foo = ...; Any any = Any.pack(foo); ... if (any.is(Foo.class)) { foo = any.unpack(Foo.class); } Example 3: Pack and unpack a message in Python. foo = Foo(...) any = Any() any.Pack(foo) ... if any.Is(Foo.DESCRIPTOR): any.Unpack(foo) ... Example 4: Pack and unpack a message in Go foo := &pb.Foo{...} any, err := anypb.New(foo) if err != nil { ... } ... foo := &pb.Foo{} if err := any.UnmarshalTo(foo); err != nil { ... } The pack methods provided by protobuf library will by default use 'type.googleapis.com/full.type.name' as the type URL and the unpack methods only use the fully qualified type name after the last '/' in the type URL, for example "foo.bar.com/x/y.z" will yield type name "y.z". JSON ==== The JSON representation of an `Any` value uses the regular representation of the deserialized, embedded message, with an additional field `@type` which contains the type URL. Example: package google.profile; message Person { string first_name = 1; string last_name = 2; } { "@type": "type.googleapis.com/google.profile.Person", "firstName": , "lastName": } If the embedded message type is well-known and has a custom JSON representation, that representation will be embedded adding a field `value` which holds the custom JSON in addition to the `@type` field. Example (for message [google.protobuf.Duration][]): { "@type": "type.googleapis.com/google.protobuf.Duration", "value": "1.212s" } parameters: - name: cons_address description: cons_address is the validator cons address to query the account for. in: path required: true type: string tags: - Query definitions: ethermint.evm.v1.ChainConfig: type: object properties: homestead_block: type: string title: Homestead switch block (nil no fork, 0 = already homestead) dao_fork_block: type: string title: TheDAO hard-fork switch block (nil no fork) dao_fork_support: type: boolean title: Whether the nodes supports or opposes the DAO hard-fork eip150_block: type: string title: >- EIP150 implements the Gas price changes (https://github.com/ethereum/EIPs/issues/150) EIP150 HF block (nil no fork) eip150_hash: type: string title: >- EIP150 HF hash (needed for header only clients as only gas pricing changed) eip155_block: type: string title: EIP155Block HF block eip158_block: type: string title: EIP158 HF block byzantium_block: type: string title: Byzantium switch block (nil no fork, 0 = already on byzantium) constantinople_block: type: string title: Constantinople switch block (nil no fork, 0 = already activated) petersburg_block: type: string title: Petersburg switch block (nil same as Constantinople) istanbul_block: type: string title: Istanbul switch block (nil no fork, 0 = already on istanbul) muir_glacier_block: type: string title: >- Eip-2384 (bomb delay) switch block (nil no fork, 0 = already activated) berlin_block: type: string title: Berlin switch block (nil = no fork, 0 = already on berlin) london_block: type: string title: London switch block (nil = no fork, 0 = already on london) arrow_glacier_block: type: string title: >- Eip-4345 (bomb delay) switch block (nil = no fork, 0 = already activated) gray_glacier_block: type: string title: >- EIP-5133 (bomb delay) switch block (nil = no fork, 0 = already activated) merge_netsplit_block: type: string title: Virtual fork after The Merge to use as a network splitter description: >- ChainConfig defines the Ethereum ChainConfig parameters using *sdk.Int values instead of *big.Int. ethermint.evm.v1.EstimateGasResponse: type: object properties: gas: type: string format: uint64 title: the estimated gas title: EstimateGasResponse defines EstimateGas response ethermint.evm.v1.Log: type: object properties: address: type: string title: address of the contract that generated the event topics: type: array items: type: string description: list of topics provided by the contract. data: type: string format: byte title: supplied by the contract, usually ABI-encoded block_number: type: string format: uint64 title: block in which the transaction was included tx_hash: type: string title: hash of the transaction tx_index: type: string format: uint64 title: index of the transaction in the block block_hash: type: string title: hash of the block in which the transaction was included index: type: string format: uint64 title: index of the log in the block removed: type: boolean description: >- The Removed field is true if this log was reverted due to a chain reorganisation. You must pay attention to this field if you receive logs through a filter query. description: >- 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. ethermint.evm.v1.MsgEthereumTx: type: object properties: data: type: object properties: type_url: type: string description: >- A URL/resource name that uniquely identifies the type of the serialized protocol buffer message. This string must contain at least one "/" character. The last segment of the URL's path must represent the fully qualified name of the type (as in `path/google.protobuf.Duration`). The name should be in a canonical form (e.g., leading "." is not accepted). In practice, teams usually precompile into the binary all types that they expect it to use in the context of Any. However, for URLs which use the scheme `http`, `https`, or no scheme, one can optionally set up a type server that maps type URLs to message definitions as follows: * If no scheme is provided, `https` is assumed. * An HTTP GET on the URL must yield a [google.protobuf.Type][] value in binary format, or produce an error. * Applications are allowed to cache lookup results based on the URL, or have them precompiled into a binary to avoid any lookup. Therefore, binary compatibility needs to be preserved on changes to types. (Use versioned type names to manage breaking changes.) Note: this functionality is not currently available in the official protobuf release, and it is not used for type URLs beginning with type.googleapis.com. Schemes other than `http`, `https` (or the empty scheme) might be used with implementation specific semantics. value: type: string format: byte description: >- Must be a valid serialized protocol buffer of the above specified type. description: >- `Any` contains an arbitrary serialized protocol buffer message along with a URL that describes the type of the serialized message. Protobuf library provides support to pack/unpack Any values in the form of utility functions or additional generated methods of the Any type. Example 1: Pack and unpack a message in C++. Foo foo = ...; Any any; any.PackFrom(foo); ... if (any.UnpackTo(&foo)) { ... } Example 2: Pack and unpack a message in Java. Foo foo = ...; Any any = Any.pack(foo); ... if (any.is(Foo.class)) { foo = any.unpack(Foo.class); } Example 3: Pack and unpack a message in Python. foo = Foo(...) any = Any() any.Pack(foo) ... if any.Is(Foo.DESCRIPTOR): any.Unpack(foo) ... Example 4: Pack and unpack a message in Go foo := &pb.Foo{...} any, err := anypb.New(foo) if err != nil { ... } ... foo := &pb.Foo{} if err := any.UnmarshalTo(foo); err != nil { ... } The pack methods provided by protobuf library will by default use 'type.googleapis.com/full.type.name' as the type URL and the unpack methods only use the fully qualified type name after the last '/' in the type URL, for example "foo.bar.com/x/y.z" will yield type name "y.z". JSON ==== The JSON representation of an `Any` value uses the regular representation of the deserialized, embedded message, with an additional field `@type` which contains the type URL. Example: package google.profile; message Person { string first_name = 1; string last_name = 2; } { "@type": "type.googleapis.com/google.profile.Person", "firstName": , "lastName": } If the embedded message type is well-known and has a custom JSON representation, that representation will be embedded adding a field `value` which holds the custom JSON in addition to the `@type` field. Example (for message [google.protobuf.Duration][]): { "@type": "type.googleapis.com/google.protobuf.Duration", "value": "1.212s" } title: inner transaction data size: type: number format: double title: 'DEPRECATED: encoded storage size of the transaction' hash: type: string title: transaction hash in hex format from: type: string title: |- 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 description: MsgEthereumTx encapsulates an Ethereum transaction as an SDK message. ethermint.evm.v1.MsgEthereumTxResponse: type: object properties: hash: type: string title: |- ethereum transaction hash in hex format. This hash differs from the Tendermint sha256 hash of the transaction bytes. See https://github.com/tendermint/tendermint/issues/6539 for reference logs: type: array items: type: object properties: address: type: string title: address of the contract that generated the event topics: type: array items: type: string description: list of topics provided by the contract. data: type: string format: byte title: supplied by the contract, usually ABI-encoded block_number: type: string format: uint64 title: block in which the transaction was included tx_hash: type: string title: hash of the transaction tx_index: type: string format: uint64 title: index of the transaction in the block block_hash: type: string title: hash of the block in which the transaction was included index: type: string format: uint64 title: index of the log in the block removed: type: boolean description: >- The Removed field is true if this log was reverted due to a chain reorganisation. You must pay attention to this field if you receive logs through a filter query. description: >- 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. description: |- logs contains the transaction hash and the proto-compatible ethereum logs. ret: type: string format: byte title: |- returned data from evm function (result or data supplied with revert opcode) vm_error: type: string title: vm error is the error returned by vm execution gas_used: type: string format: uint64 title: gas consumed by the transaction description: MsgEthereumTxResponse defines the Msg/EthereumTx response type. ethermint.evm.v1.Params: type: object properties: evm_denom: type: string description: |- evm denom represents the token denomination used to run the EVM state transitions. enable_create: type: boolean title: >- enable create toggles state transitions that use the vm.Create function enable_call: type: boolean title: enable call toggles state transitions that use the vm.Call function extra_eips: type: array items: type: string format: int64 title: extra eips defines the additional EIPs for the vm.Config chain_config: title: chain config defines the EVM chain configuration parameters type: object properties: homestead_block: type: string title: Homestead switch block (nil no fork, 0 = already homestead) dao_fork_block: type: string title: TheDAO hard-fork switch block (nil no fork) dao_fork_support: type: boolean title: Whether the nodes supports or opposes the DAO hard-fork eip150_block: type: string title: >- EIP150 implements the Gas price changes (https://github.com/ethereum/EIPs/issues/150) EIP150 HF block (nil no fork) eip150_hash: type: string title: >- EIP150 HF hash (needed for header only clients as only gas pricing changed) eip155_block: type: string title: EIP155Block HF block eip158_block: type: string title: EIP158 HF block byzantium_block: type: string title: Byzantium switch block (nil no fork, 0 = already on byzantium) constantinople_block: type: string title: Constantinople switch block (nil no fork, 0 = already activated) petersburg_block: type: string title: Petersburg switch block (nil same as Constantinople) istanbul_block: type: string title: Istanbul switch block (nil no fork, 0 = already on istanbul) muir_glacier_block: type: string title: >- Eip-2384 (bomb delay) switch block (nil no fork, 0 = already activated) berlin_block: type: string title: Berlin switch block (nil = no fork, 0 = already on berlin) london_block: type: string title: London switch block (nil = no fork, 0 = already on london) arrow_glacier_block: type: string title: >- Eip-4345 (bomb delay) switch block (nil = no fork, 0 = already activated) gray_glacier_block: type: string title: >- EIP-5133 (bomb delay) switch block (nil = no fork, 0 = already activated) merge_netsplit_block: type: string title: Virtual fork after The Merge to use as a network splitter description: >- ChainConfig defines the Ethereum ChainConfig parameters using *sdk.Int values instead of *big.Int. allow_unprotected_txs: type: boolean description: >- Allow unprotected transactions defines if replay-protected (i.e non EIP155 signed) transactions can be executed on the state machine. title: Params defines the EVM module parameters ethermint.evm.v1.QueryAccountResponse: type: object properties: balance: type: string description: balance is the balance of the EVM denomination. code_hash: type: string description: code hash is the hex-formatted code bytes from the EOA. nonce: type: string format: uint64 description: nonce is the account's sequence number. description: >- QueryAccountResponse is the response type for the Query/Account RPC method. ethermint.evm.v1.QueryBalanceResponse: type: object properties: balance: type: string description: balance is the balance of the EVM denomination. description: >- QueryBalanceResponse is the response type for the Query/Balance RPC method. ethermint.evm.v1.QueryBaseFeeResponse: type: object properties: base_fee: type: string description: BaseFeeResponse returns the EIP1559 base fee. ethermint.evm.v1.QueryCodeResponse: type: object properties: code: type: string format: byte description: code represents the code bytes from an ethereum address. description: |- QueryCodeResponse is the response type for the Query/Code RPC method. ethermint.evm.v1.QueryCosmosAccountResponse: type: object properties: cosmos_address: type: string description: cosmos_address is the cosmos address of the account. sequence: type: string format: uint64 description: sequence is the account's sequence number. account_number: type: string format: uint64 title: account_number is the account numbert description: >- QueryCosmosAccountResponse is the response type for the Query/CosmosAccount RPC method. ethermint.evm.v1.QueryParamsResponse: type: object properties: params: description: params define the evm module parameters. type: object properties: evm_denom: type: string description: >- evm denom represents the token denomination used to run the EVM state transitions. enable_create: type: boolean title: >- enable create toggles state transitions that use the vm.Create function enable_call: type: boolean title: >- enable call toggles state transitions that use the vm.Call function extra_eips: type: array items: type: string format: int64 title: extra eips defines the additional EIPs for the vm.Config chain_config: title: chain config defines the EVM chain configuration parameters type: object properties: homestead_block: type: string title: Homestead switch block (nil no fork, 0 = already homestead) dao_fork_block: type: string title: TheDAO hard-fork switch block (nil no fork) dao_fork_support: type: boolean title: Whether the nodes supports or opposes the DAO hard-fork eip150_block: type: string title: >- EIP150 implements the Gas price changes (https://github.com/ethereum/EIPs/issues/150) EIP150 HF block (nil no fork) eip150_hash: type: string title: >- EIP150 HF hash (needed for header only clients as only gas pricing changed) eip155_block: type: string title: EIP155Block HF block eip158_block: type: string title: EIP158 HF block byzantium_block: type: string title: Byzantium switch block (nil no fork, 0 = already on byzantium) constantinople_block: type: string title: >- Constantinople switch block (nil no fork, 0 = already activated) petersburg_block: type: string title: Petersburg switch block (nil same as Constantinople) istanbul_block: type: string title: Istanbul switch block (nil no fork, 0 = already on istanbul) muir_glacier_block: type: string title: >- Eip-2384 (bomb delay) switch block (nil no fork, 0 = already activated) berlin_block: type: string title: Berlin switch block (nil = no fork, 0 = already on berlin) london_block: type: string title: London switch block (nil = no fork, 0 = already on london) arrow_glacier_block: type: string title: >- Eip-4345 (bomb delay) switch block (nil = no fork, 0 = already activated) gray_glacier_block: type: string title: >- EIP-5133 (bomb delay) switch block (nil = no fork, 0 = already activated) merge_netsplit_block: type: string title: Virtual fork after The Merge to use as a network splitter description: >- ChainConfig defines the Ethereum ChainConfig parameters using *sdk.Int values instead of *big.Int. allow_unprotected_txs: type: boolean description: >- Allow unprotected transactions defines if replay-protected (i.e non EIP155 signed) transactions can be executed on the state machine. title: Params defines the EVM module parameters description: >- QueryParamsResponse defines the response type for querying x/evm parameters. ethermint.evm.v1.QueryStorageResponse: type: object properties: value: type: string description: >- key defines the storage state value hash associated with the given key. description: |- QueryStorageResponse is the response type for the Query/Storage RPC method. ethermint.evm.v1.QueryTraceBlockResponse: type: object properties: data: type: string format: byte title: QueryTraceBlockResponse defines TraceBlock response ethermint.evm.v1.QueryTraceTxResponse: type: object properties: data: type: string format: byte title: response serialized in bytes title: QueryTraceTxResponse defines TraceTx response ethermint.evm.v1.QueryValidatorAccountResponse: type: object properties: account_address: type: string description: account_address is the cosmos address of the account in bech32 format. sequence: type: string format: uint64 description: sequence is the account's sequence number. account_number: type: string format: uint64 title: account_number is the account number description: |- QueryValidatorAccountResponse is the response type for the Query/ValidatorAccount RPC method. ethermint.evm.v1.TraceConfig: type: object properties: tracer: type: string title: custom javascript tracer timeout: type: string title: >- overrides the default timeout of 5 seconds for JavaScript-based tracing calls reexec: type: string format: uint64 title: number of blocks the tracer is willing to go back disable_stack: type: boolean title: disable stack capture disable_storage: type: boolean title: disable storage capture debug: type: boolean title: print output during capture end limit: type: integer format: int32 title: maximum length of output, but zero means unlimited overrides: title: >- Chain overrides, can be used to execute a trace using future fork rules type: object properties: homestead_block: type: string title: Homestead switch block (nil no fork, 0 = already homestead) dao_fork_block: type: string title: TheDAO hard-fork switch block (nil no fork) dao_fork_support: type: boolean title: Whether the nodes supports or opposes the DAO hard-fork eip150_block: type: string title: >- EIP150 implements the Gas price changes (https://github.com/ethereum/EIPs/issues/150) EIP150 HF block (nil no fork) eip150_hash: type: string title: >- EIP150 HF hash (needed for header only clients as only gas pricing changed) eip155_block: type: string title: EIP155Block HF block eip158_block: type: string title: EIP158 HF block byzantium_block: type: string title: Byzantium switch block (nil no fork, 0 = already on byzantium) constantinople_block: type: string title: Constantinople switch block (nil no fork, 0 = already activated) petersburg_block: type: string title: Petersburg switch block (nil same as Constantinople) istanbul_block: type: string title: Istanbul switch block (nil no fork, 0 = already on istanbul) muir_glacier_block: type: string title: >- Eip-2384 (bomb delay) switch block (nil no fork, 0 = already activated) berlin_block: type: string title: Berlin switch block (nil = no fork, 0 = already on berlin) london_block: type: string title: London switch block (nil = no fork, 0 = already on london) arrow_glacier_block: type: string title: >- Eip-4345 (bomb delay) switch block (nil = no fork, 0 = already activated) gray_glacier_block: type: string title: >- EIP-5133 (bomb delay) switch block (nil = no fork, 0 = already activated) merge_netsplit_block: type: string title: Virtual fork after The Merge to use as a network splitter description: >- ChainConfig defines the Ethereum ChainConfig parameters using *sdk.Int values instead of *big.Int. enable_memory: type: boolean title: enable memory capture enable_return_data: type: boolean title: enable return data capture tracer_json_config: type: string title: tracer config description: TraceConfig holds extra parameters to trace functions. google.protobuf.Any: type: object properties: type_url: type: string description: >- A URL/resource name that uniquely identifies the type of the serialized protocol buffer message. This string must contain at least one "/" character. The last segment of the URL's path must represent the fully qualified name of the type (as in `path/google.protobuf.Duration`). The name should be in a canonical form (e.g., leading "." is not accepted). In practice, teams usually precompile into the binary all types that they expect it to use in the context of Any. However, for URLs which use the scheme `http`, `https`, or no scheme, one can optionally set up a type server that maps type URLs to message definitions as follows: * If no scheme is provided, `https` is assumed. * An HTTP GET on the URL must yield a [google.protobuf.Type][] value in binary format, or produce an error. * Applications are allowed to cache lookup results based on the URL, or have them precompiled into a binary to avoid any lookup. Therefore, binary compatibility needs to be preserved on changes to types. (Use versioned type names to manage breaking changes.) Note: this functionality is not currently available in the official protobuf release, and it is not used for type URLs beginning with type.googleapis.com. Schemes other than `http`, `https` (or the empty scheme) might be used with implementation specific semantics. value: type: string format: byte description: >- Must be a valid serialized protocol buffer of the above specified type. description: >- `Any` contains an arbitrary serialized protocol buffer message along with a URL that describes the type of the serialized message. Protobuf library provides support to pack/unpack Any values in the form of utility functions or additional generated methods of the Any type. Example 1: Pack and unpack a message in C++. Foo foo = ...; Any any; any.PackFrom(foo); ... if (any.UnpackTo(&foo)) { ... } Example 2: Pack and unpack a message in Java. Foo foo = ...; Any any = Any.pack(foo); ... if (any.is(Foo.class)) { foo = any.unpack(Foo.class); } Example 3: Pack and unpack a message in Python. foo = Foo(...) any = Any() any.Pack(foo) ... if any.Is(Foo.DESCRIPTOR): any.Unpack(foo) ... Example 4: Pack and unpack a message in Go foo := &pb.Foo{...} any, err := anypb.New(foo) if err != nil { ... } ... foo := &pb.Foo{} if err := any.UnmarshalTo(foo); err != nil { ... } The pack methods provided by protobuf library will by default use 'type.googleapis.com/full.type.name' as the type URL and the unpack methods only use the fully qualified type name after the last '/' in the type URL, for example "foo.bar.com/x/y.z" will yield type name "y.z". JSON ==== The JSON representation of an `Any` value uses the regular representation of the deserialized, embedded message, with an additional field `@type` which contains the type URL. Example: package google.profile; message Person { string first_name = 1; string last_name = 2; } { "@type": "type.googleapis.com/google.profile.Person", "firstName": , "lastName": } If the embedded message type is well-known and has a custom JSON representation, that representation will be embedded adding a field `value` which holds the custom JSON in addition to the `@type` field. Example (for message [google.protobuf.Duration][]): { "@type": "type.googleapis.com/google.protobuf.Duration", "value": "1.212s" } grpc.gateway.runtime.Error: type: object properties: error: type: string code: type: integer format: int32 message: type: string details: type: array items: type: object properties: type_url: type: string description: >- A URL/resource name that uniquely identifies the type of the serialized protocol buffer message. This string must contain at least one "/" character. The last segment of the URL's path must represent the fully qualified name of the type (as in `path/google.protobuf.Duration`). The name should be in a canonical form (e.g., leading "." is not accepted). In practice, teams usually precompile into the binary all types that they expect it to use in the context of Any. However, for URLs which use the scheme `http`, `https`, or no scheme, one can optionally set up a type server that maps type URLs to message definitions as follows: * If no scheme is provided, `https` is assumed. * An HTTP GET on the URL must yield a [google.protobuf.Type][] value in binary format, or produce an error. * Applications are allowed to cache lookup results based on the URL, or have them precompiled into a binary to avoid any lookup. Therefore, binary compatibility needs to be preserved on changes to types. (Use versioned type names to manage breaking changes.) Note: this functionality is not currently available in the official protobuf release, and it is not used for type URLs beginning with type.googleapis.com. Schemes other than `http`, `https` (or the empty scheme) might be used with implementation specific semantics. value: type: string format: byte description: >- Must be a valid serialized protocol buffer of the above specified type. description: >- `Any` contains an arbitrary serialized protocol buffer message along with a URL that describes the type of the serialized message. Protobuf library provides support to pack/unpack Any values in the form of utility functions or additional generated methods of the Any type. Example 1: Pack and unpack a message in C++. Foo foo = ...; Any any; any.PackFrom(foo); ... if (any.UnpackTo(&foo)) { ... } Example 2: Pack and unpack a message in Java. Foo foo = ...; Any any = Any.pack(foo); ... if (any.is(Foo.class)) { foo = any.unpack(Foo.class); } Example 3: Pack and unpack a message in Python. foo = Foo(...) any = Any() any.Pack(foo) ... if any.Is(Foo.DESCRIPTOR): any.Unpack(foo) ... Example 4: Pack and unpack a message in Go foo := &pb.Foo{...} any, err := anypb.New(foo) if err != nil { ... } ... foo := &pb.Foo{} if err := any.UnmarshalTo(foo); err != nil { ... } The pack methods provided by protobuf library will by default use 'type.googleapis.com/full.type.name' as the type URL and the unpack methods only use the fully qualified type name after the last '/' in the type URL, for example "foo.bar.com/x/y.z" will yield type name "y.z". JSON ==== The JSON representation of an `Any` value uses the regular representation of the deserialized, embedded message, with an additional field `@type` which contains the type URL. Example: package google.profile; message Person { string first_name = 1; string last_name = 2; } { "@type": "type.googleapis.com/google.profile.Person", "firstName": , "lastName": } If the embedded message type is well-known and has a custom JSON representation, that representation will be embedded adding a field `value` which holds the custom JSON in addition to the `@type` field. Example (for message [google.protobuf.Duration][]): { "@type": "type.googleapis.com/google.protobuf.Duration", "value": "1.212s" }