> ## Documentation Index > Fetch the complete documentation index at: https://docs.cosmos.network/llms.txt > Use this file to discover all available pages before exploring further. # GetTxsEvent > gRPC: `cosmos.tx.v1beta1.Service/GetTxsEvent` ([reference](/sdk/latest/api-reference/grpc/tx#gettxsevent)) GetTxsEvent fetches txs by event. ## OpenAPI ````yaml /sdk/latest/api-reference/rest/openapi.yaml get /cosmos/tx/v1beta1/txs openapi: 3.0.0 info: title: Cosmos SDK REST API description: >- HTTP bindings for the gRPC query services of the standard Cosmos SDK modules, documenting Cosmos SDK v0.55. Generated from cosmos/cosmos-sdk at commit 2086680ff8b08fd269ee653e087ea577bab79534 on ref `release/v0.55.x`. A chain exposes only the modules its application registers, so it may serve a subset of these routes alongside routes of its own. version: v0.55 servers: - url: https://cosmos-rest.publicnode.com description: >- Community-run public endpoint serving Cosmos Hub. Not operated by the Cosmos SDK team, and running a different SDK version than these pages document. Endpoints for modules the chain does not include return 501. - url: http://localhost:1317 description: Your own node. Requires api.enable in app.toml. security: [] tags: - name: auth - name: authz - name: bank - name: base - name: consensus - name: distribution - name: epochs - name: evidence - name: feegrant - name: gov - name: mint - name: slashing - name: staking - name: tx - name: upgrade paths: /cosmos/tx/v1beta1/txs: get: tags: - tx summary: GetTxsEvent description: >- gRPC: `cosmos.tx.v1beta1.Service/GetTxsEvent` ([reference](/sdk/latest/api-reference/grpc/tx#gettxsevent)) GetTxsEvent fetches txs by event. operationId: tx_v1beta1_GetTxsEvent parameters: - name: events description: >- events is the list of transaction event type. Deprecated post v0.47.x: use query instead, which should contain a valid events query. in: query required: false explode: true schema: type: array items: type: string - name: pagination.key description: |- key is a value returned in PageResponse.next_key to begin querying the next page most efficiently. Only one of offset or key should be set. in: query required: false schema: type: string format: byte - name: pagination.offset description: >- offset is a numeric offset that can be used when key is unavailable. It is less efficient than using key. Only one of offset or key should be set. in: query required: false schema: type: string format: uint64 - name: pagination.limit description: >- limit is the total number of results to be returned in the result page. If left empty it will default to a value to be set by each app. in: query required: false schema: type: string format: uint64 - name: pagination.countTotal description: >- count_total is set to true to indicate that the result set should include a count of the total number of items available for pagination in UIs. count_total is only respected when offset is used. It is ignored when key is set. in: query required: false schema: type: boolean - name: pagination.reverse description: >- reverse is set to true if results are to be returned in the descending order. in: query required: false schema: type: boolean - name: orderBy description: |2- - ORDER_BY_UNSPECIFIED: ORDER_BY_UNSPECIFIED specifies an unknown sorting order. OrderBy defaults to ASC in this case. - ORDER_BY_ASC: ORDER_BY_ASC defines ascending order - ORDER_BY_DESC: ORDER_BY_DESC defines descending order in: query required: false schema: type: string enum: - ORDER_BY_UNSPECIFIED - ORDER_BY_ASC - ORDER_BY_DESC default: ORDER_BY_UNSPECIFIED - name: page description: |- page is the page number to query, starts at 1. If not provided, will default to first page. in: query required: false schema: type: string format: uint64 - name: limit description: >- limit is the total number of results to be returned in the result page. If left empty it will default to a value to be set by each app. in: query required: false schema: type: string format: uint64 - name: query description: >- query defines the transaction event query that is proxied to Tendermint's TxSearch RPC method. The query must be valid. in: query required: false schema: type: string responses: '200': description: A successful response. content: '*/*': schema: $ref: '#/components/schemas/cosmos.tx.v1beta1.GetTxsEventResponse' default: description: An unexpected error response. content: '*/*': schema: type: object properties: code: type: integer format: int32 message: type: string details: type: array items: type: object properties: '@type': 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. As of May 2023, there are no widely used type server implementations and no plans to implement one. Schemes other than `http`, `https` (or the empty scheme) might be used with implementation specific semantics. additionalProperties: {} 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); } // or ... if (any.isSameTypeAs(Foo.getDefaultInstance())) { foo = any.unpack(Foo.getDefaultInstance()); } 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" } components: schemas: cosmos.tx.v1beta1.GetTxsEventResponse: type: object properties: txs: type: array items: $ref: '#/components/schemas/cosmos.tx.v1beta1.Tx' type: object description: txs is the list of queried transactions. nullable: true tx_responses: type: array items: type: object properties: height: type: string format: int64 title: The block height txhash: type: string description: The transaction hash. codespace: type: string title: Namespace for the Code code: type: integer format: int64 description: Response code. data: type: string description: Result bytes, if any. raw_log: type: string description: |- The output of the application's logger (raw string). May be non-deterministic. logs: type: array items: type: object properties: msg_index: type: integer format: int64 log: type: string events: type: array items: type: object properties: type: type: string attributes: type: array items: type: object properties: key: type: string value: type: string description: >- Attribute defines an attribute wrapper where the key and value are strings instead of raw bytes. additionalProperties: false nullable: true description: >- StringEvent defines en Event object wrapper where all the attributes contain key/value pairs that are strings instead of raw bytes. additionalProperties: false description: >- Events contains a slice of Event objects that were emitted during some execution. nullable: true description: >- ABCIMessageLog defines a structure containing an indexed tx ABCI message log. additionalProperties: false description: >- The output of the application's logger (typed). May be non-deterministic. nullable: true info: type: string description: Additional information. May be non-deterministic. gas_wanted: type: string format: int64 description: Amount of gas requested for transaction. gas_used: type: string format: int64 description: Amount of gas consumed by transaction. tx: description: The request transaction bytes. type: object properties: '@type': 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. As of May 2023, there are no widely used type server implementations and no plans to implement one. Schemes other than `http`, `https` (or the empty scheme) might be used with implementation specific semantics. additionalProperties: {} nullable: true timestamp: type: string description: >- Time of the previous block. For heights > 1, it's the weighted median of the timestamps of the valid votes in the block.LastCommit. For height == 1, it's genesis time. events: type: array items: type: object properties: type: type: string attributes: type: array items: type: object properties: key: type: string value: type: string index: type: boolean title: nondeterministic description: >- EventAttribute is a single key-value pair, associated with an event. additionalProperties: false nullable: true description: >- Event allows application developers to attach additional information to ResponseFinalizeBlock and ResponseCheckTx. Later, transactions may be queried using these events. additionalProperties: false description: >- Events defines all the events emitted by processing a transaction. Note, these events include those emitted by processing all the messages and those emitted from the ante. Whereas Logs contains the events, with additional metadata, emitted only by processing the messages. nullable: true description: >- TxResponse defines a structure containing relevant tx data and metadata. The tags are stringified and the log is JSON decoded. description: tx_responses is the list of queried TxResponses. nullable: true pagination: description: |- pagination defines a pagination for the response. Deprecated post v0.46.x: use total instead. type: object properties: next_key: type: string format: byte description: |- next_key is the key to be passed to PageRequest.key to query the next page most efficiently. It will be empty if there are no more results. nullable: true total: type: string format: uint64 title: >- total is total number of results available if PageRequest.count_total was set, its value is undefined otherwise nullable: true additionalProperties: false total: type: string format: uint64 title: total is total number of results available description: |- GetTxsEventResponse is the response type for the Service.TxsByEvents RPC method. additionalProperties: false cosmos.tx.v1beta1.Tx: type: object properties: body: title: body is the processable content of the transaction type: object properties: messages: type: array items: type: object properties: '@type': 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. As of May 2023, there are no widely used type server implementations and no plans to implement one. Schemes other than `http`, `https` (or the empty scheme) might be used with implementation specific semantics. additionalProperties: {} 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); } // or ... if (any.isSameTypeAs(Foo.getDefaultInstance())) { foo = any.unpack(Foo.getDefaultInstance()); } 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" } description: >- messages is a list of messages to be executed. The required signers of those messages define the number and order of elements in AuthInfo's signer_infos and Tx's signatures. Each required signer address is added to the list only the first time it occurs. By convention, the first required signer (usually from the first message) is referred to as the primary signer and pays the fee for the whole transaction. nullable: true memo: type: string description: >- memo is any arbitrary note/comment to be added to the transaction. WARNING: in clients, any publicly exposed text should not be called memo, but should be called `note` instead (see https://github.com/cosmos/cosmos-sdk/issues/9122). timeout_height: type: string format: uint64 description: >- timeout_height is the block height after which this transaction will not be processed by the chain. unordered: type: boolean description: >- unordered, when set to true, indicates that the transaction signer(s) intend for the transaction to be evaluated and executed in an un-ordered fashion. Specifically, the account's nonce will NOT be checked or incremented, which allows for fire-and-forget as well as concurrent transaction execution. Note, when set to true, the existing 'timeout_timestamp' value must be set and will be used to correspond to a timestamp in which the transaction is deemed valid. When true, the sequence value MUST be 0, and any transaction with unordered=true and a non-zero sequence value will be rejected. External services that make assumptions about sequence values may need to be updated because of this. timeout_timestamp: type: string format: date-time description: >- timeout_timestamp is the block time after which this transaction will not be processed by the chain. Note, if unordered=true this value MUST be set and will act as a short-lived TTL in which the transaction is deemed valid and kept in memory to prevent duplicates. nullable: true extension_options: type: array items: type: object properties: '@type': 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. As of May 2023, there are no widely used type server implementations and no plans to implement one. Schemes other than `http`, `https` (or the empty scheme) might be used with implementation specific semantics. additionalProperties: {} 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); } // or ... if (any.isSameTypeAs(Foo.getDefaultInstance())) { foo = any.unpack(Foo.getDefaultInstance()); } 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: >- extension_options are arbitrary options that can be added by chains when the default options are not sufficient. If any of these are present and can't be handled, the transaction will be rejected nullable: true non_critical_extension_options: type: array items: type: object properties: '@type': 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. As of May 2023, there are no widely used type server implementations and no plans to implement one. Schemes other than `http`, `https` (or the empty scheme) might be used with implementation specific semantics. additionalProperties: {} 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); } // or ... if (any.isSameTypeAs(Foo.getDefaultInstance())) { foo = any.unpack(Foo.getDefaultInstance()); } 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: >- extension_options are arbitrary options that can be added by chains when the default options are not sufficient. If any of these are present and can't be handled, they will be ignored nullable: true description: TxBody is the body of a transaction that all signers sign over. nullable: true auth_info: $ref: '#/components/schemas/cosmos.tx.v1beta1.AuthInfo' title: |- auth_info is the authorization related content of the transaction, specifically signers, signer modes and fee nullable: true signatures: type: array items: type: string format: byte description: >- signatures is a list of signatures that matches the length and order of AuthInfo's signer_infos to allow connecting signature meta information like public key and signing mode by position. nullable: true description: Tx is the standard type used for broadcasting transactions. additionalProperties: false cosmos.tx.v1beta1.AuthInfo: type: object properties: signer_infos: type: array items: $ref: '#/components/schemas/cosmos.tx.v1beta1.SignerInfo' type: object description: >- signer_infos defines the signing modes for the required signers. The number and order of elements must match the required signers from TxBody's messages. The first element is the primary signer and the one which pays the fee. nullable: true fee: description: >- Fee is the fee and gas limit for the transaction. The first signer is the primary signer and the one which pays the fee. The fee can be calculated based on the cost of evaluating the body and doing signature verification of the signers. This can be estimated via simulation. type: object properties: amount: type: array items: type: object properties: denom: type: string amount: type: string description: >- Coin defines a token with a denomination and an amount. NOTE: The amount field is an Int which implements the custom method signatures required by gogoproto. additionalProperties: false title: amount is the amount of coins to be paid as a fee nullable: true gas_limit: type: string format: uint64 title: >- gas_limit is the maximum gas that can be used in transaction processing before an out of gas error occurs payer: type: string description: >- if unset, the first signer is responsible for paying the fees. If set, the specified account must pay the fees. the payer must be a tx signer (and thus have signed this field in AuthInfo). setting this field does *not* change the ordering of required signers for the transaction. granter: type: string title: >- if set, the fee payer (either the first signer or the value of the payer field) requests that a fee grant be used to pay fees instead of the fee payer's own balance. If an appropriate fee grant does not exist or the chain does not support fee grants, this will fail nullable: true additionalProperties: false tip: description: >- Tip is the optional tip used for transactions fees paid in another denom. This field is ignored if the chain didn't enable tips, i.e. didn't add the `TipDecorator` in its posthandler. type: object properties: amount: type: array items: type: object properties: denom: type: string amount: type: string description: >- Coin defines a token with a denomination and an amount. NOTE: The amount field is an Int which implements the custom method signatures required by gogoproto. additionalProperties: false title: amount is the amount of the tip nullable: true tipper: type: string title: tipper is the address of the account paying for the tip nullable: true additionalProperties: false description: |- AuthInfo describes the fee and signer modes that are used to sign a transaction. additionalProperties: false cosmos.tx.v1beta1.SignerInfo: type: object properties: public_key: description: >- public_key is the public key of the signer. It is optional for accounts that already exist in state. If unset, the verifier can use the required \ signer address for this position and lookup the public key. type: object properties: '@type': 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. As of May 2023, there are no widely used type server implementations and no plans to implement one. Schemes other than `http`, `https` (or the empty scheme) might be used with implementation specific semantics. additionalProperties: {} nullable: true mode_info: $ref: '#/components/schemas/cosmos.tx.v1beta1.ModeInfo' title: |- mode_info describes the signing mode of the signer and is a nested structure to support nested multisig pubkey's nullable: true sequence: type: string format: uint64 description: >- sequence is the sequence of the account, which describes the number of committed transactions signed by a given address. It is used to prevent replay attacks. description: >- SignerInfo describes the public key and signing mode of a single top-level signer. cosmos.tx.v1beta1.ModeInfo: type: object properties: single: title: single represents a single signer type: object properties: mode: title: mode is the signing mode of the single signer type: string enum: - SIGN_MODE_UNSPECIFIED - SIGN_MODE_DIRECT - SIGN_MODE_TEXTUAL - SIGN_MODE_DIRECT_AUX - SIGN_MODE_LEGACY_AMINO_JSON - SIGN_MODE_EIP_191 default: SIGN_MODE_UNSPECIFIED description: >- SignMode represents a signing mode with its own security guarantees. This enum should be considered a registry of all known sign modes in the Cosmos ecosystem. Apps are not expected to support all known sign modes. Apps that would like to support custom sign modes are encouraged to open a small PR against this file to add a new case to this SignMode enum describing their sign mode so that different apps have a consistent version of this enum. - SIGN_MODE_UNSPECIFIED: SIGN_MODE_UNSPECIFIED specifies an unknown signing mode and will be rejected. - SIGN_MODE_DIRECT: SIGN_MODE_DIRECT specifies a signing mode which uses SignDoc and is verified with raw bytes from Tx. - SIGN_MODE_TEXTUAL: SIGN_MODE_TEXTUAL is a future signing mode that will verify some human-readable textual representation on top of the binary representation from SIGN_MODE_DIRECT. Since: cosmos-sdk 0.50 - SIGN_MODE_DIRECT_AUX: SIGN_MODE_DIRECT_AUX specifies a signing mode which uses SignDocDirectAux. As opposed to SIGN_MODE_DIRECT, this sign mode does not require signers signing over other signers' `signer_info`. Since: cosmos-sdk 0.46 - SIGN_MODE_LEGACY_AMINO_JSON: SIGN_MODE_LEGACY_AMINO_JSON is a backwards compatibility mode which uses Amino JSON and will be removed in the future. - SIGN_MODE_EIP_191: SIGN_MODE_EIP_191 specifies the sign mode for EIP 191 signing on the Cosmos SDK. Ref: https://eips.ethereum.org/EIPS/eip-191 Currently, SIGN_MODE_EIP_191 is registered as a SignMode enum variant, but is not implemented on the SDK by default. To enable EIP-191, you need to pass a custom `TxConfig` that has an implementation of `SignModeHandler` for EIP-191. The SDK may decide to fully support EIP-191 in the future. Since: cosmos-sdk 0.45.2 nullable: true nullable: true additionalProperties: false multi: $ref: '#/components/schemas/cosmos.tx.v1beta1.ModeInfo.Multi' title: multi represents a nested multisig signer nullable: true description: >- ModeInfo describes the signing mode of a single or nested multisig signer. additionalProperties: false cosmos.tx.v1beta1.ModeInfo.Multi: type: object properties: bitarray: title: bitarray specifies which keys within the multisig are signing type: object properties: extra_bits_stored: type: integer format: int64 elems: type: string format: byte nullable: true description: >- CompactBitArray is an implementation of a space efficient bit array. This is used to ensure that the encoded data takes up a minimal amount of space after proto encoding. This is not thread safe, and is not intended for concurrent usage. nullable: true additionalProperties: false mode_infos: type: array items: $ref: '#/components/schemas/cosmos.tx.v1beta1.ModeInfo' type: object title: |- mode_infos is the corresponding modes of the signers of the multisig which could include nested multisig public keys nullable: true title: Multi is the mode info for a multisig public key additionalProperties: false ````