Variable v1Const

Type declaration

• ChannelStateData: {
      typeUrl: string;
      decode(input: Uint8Array | BinaryReader, length?: number): ChannelStateData;
      encode(message: ChannelStateData, writer?: BinaryWriter): BinaryWriter;
      fromAmino(object: ChannelStateDataAmino): ChannelStateData;
      fromAminoMsg(object: ChannelStateDataAminoMsg): ChannelStateData;
      fromPartial(object: {
          channel?: {
              connectionHops?: string[];
              counterparty?: {
                  channelId?: string;
                  portId?: string;
              };
              ordering?: Order;
              state?: State;
              version?: string;
          };
          path?: Uint8Array;
      }): ChannelStateData;
      fromProtoMsg(message: ChannelStateDataProtoMsg): ChannelStateData;
      toAmino(message: ChannelStateData): ChannelStateDataAmino;
      toAminoMsg(message: ChannelStateData): ChannelStateDataAminoMsg;
      toProto(message: ChannelStateData): Uint8Array;
      toProtoMsg(message: ChannelStateData): ChannelStateDataProtoMsg;
  }

  • typeUrl: string

  • decode:function

    • decode(input, length?): ChannelStateData

    • Parameters

      • input: Uint8Array | BinaryReader
      • Optionallength: number

      Returns ChannelStateData

  • encode:function

    • encode(message, writer?): BinaryWriter

    • Parameters

      • message: ChannelStateData
      • writer: BinaryWriter = ...

      Returns BinaryWriter

  • fromAmino:function

    • fromAmino(object): ChannelStateData

    • Parameters

      • object: ChannelStateDataAmino

      Returns ChannelStateData

  • fromAminoMsg:function

    • fromAminoMsg(object): ChannelStateData

    • Parameters

      • object: ChannelStateDataAminoMsg

      Returns ChannelStateData

  • fromPartial:function

    • fromPartial(object): ChannelStateData

    • Parameters

      • object: {
            channel?: {
                connectionHops?: string[];
                counterparty?: {
                    channelId?: string;
                    portId?: string;
                };
                ordering?: Order;
                state?: State;
                version?: string;
            };
            path?: Uint8Array;
        }

        • Optionalchannel?: {
              connectionHops?: string[];
              counterparty?: {
                  channelId?: string;
                  portId?: string;
              };
              ordering?: Order;
              state?: State;
              version?: string;
          }

          • OptionalconnectionHops?: string[]

            list of connection identifiers, in order, along which packets sent on this channel will travel

          • Optionalcounterparty?: {
                channelId?: string;
                portId?: string;
            }

            counterparty channel end

            • OptionalchannelId?: string

              channel end on the counterparty chain

            • OptionalportId?: string

              port on the counterparty chain which owns the other end of the channel.

          • Optionalordering?: Order

            whether the channel is ordered or unordered

          • Optionalstate?: State

            current state of the channel end

          • Optionalversion?: string

            opaque channel version, which is agreed upon during the handshake

        • Optionalpath?: Uint8Array

      Returns ChannelStateData

  • fromProtoMsg:function

    • fromProtoMsg(message): ChannelStateData

    • Parameters

      • message: ChannelStateDataProtoMsg

      Returns ChannelStateData

  • toAmino:function

    • toAmino(message): ChannelStateDataAmino

    • Parameters

      • message: ChannelStateData

      Returns ChannelStateDataAmino

  • toAminoMsg:function

    • toAminoMsg(message): ChannelStateDataAminoMsg

    • Parameters

      • message: ChannelStateData

      Returns ChannelStateDataAminoMsg

  • toProto:function

    • toProto(message): Uint8Array

    • Parameters

      • message: ChannelStateData

      Returns Uint8Array

  • toProtoMsg:function

    • toProtoMsg(message): ChannelStateDataProtoMsg

    • Parameters

      • message: ChannelStateData

      Returns ChannelStateDataProtoMsg

• ClientState: {
      typeUrl: string;
      decode(input: Uint8Array | BinaryReader, length?: number): ClientState;
      encode(message: ClientState, writer?: BinaryWriter): BinaryWriter;
      fromAmino(object: ClientStateAmino): ClientState;
      fromAminoMsg(object: ClientStateAminoMsg): ClientState;
      fromPartial(object: {
          allowUpdateAfterProposal?: boolean;
          consensusState?: {
              diversifier?: string;
              publicKey?: {
                  $typeUrl?: string;
                  typeUrl?: string;
                  value?: Uint8Array;
              };
              timestamp?: bigint;
          };
          frozenSequence?: bigint;
          sequence?: bigint;
      }): ClientState;
      fromProtoMsg(message: ClientStateProtoMsg): ClientState;
      toAmino(message: ClientState): ClientStateAmino;
      toAminoMsg(message: ClientState): ClientStateAminoMsg;
      toProto(message: ClientState): Uint8Array;
      toProtoMsg(message: ClientState): ClientStateProtoMsg;
  }

  • typeUrl: string

  • decode:function

    • decode(input, length?): ClientState

    • Parameters

      • input: Uint8Array | BinaryReader
      • Optionallength: number

      Returns ClientState

  • encode:function

    • encode(message, writer?): BinaryWriter

    • Parameters

      • message: ClientState
      • writer: BinaryWriter = ...

      Returns BinaryWriter

  • fromAmino:function

    • fromAmino(object): ClientState

    • Parameters

      • object: ClientStateAmino

      Returns ClientState

  • fromAminoMsg:function

    • fromAminoMsg(object): ClientState

    • Parameters

      • object: ClientStateAminoMsg

      Returns ClientState

  • fromPartial:function

    • fromPartial(object): ClientState

    • Parameters

      • object: {
            allowUpdateAfterProposal?: boolean;
            consensusState?: {
                diversifier?: string;
                publicKey?: {
                    $typeUrl?: string;
                    typeUrl?: string;
                    value?: Uint8Array;
                };
                timestamp?: bigint;
            };
            frozenSequence?: bigint;
            sequence?: bigint;
        }

        • OptionalallowUpdateAfterProposal?: boolean

          when set to true, will allow governance to update a solo machine client. The client will be unfrozen if it is frozen.

        • OptionalconsensusState?: {
              diversifier?: string;
              publicKey?: {
                  $typeUrl?: string;
                  typeUrl?: string;
                  value?: Uint8Array;
              };
              timestamp?: bigint;
          }

          • Optionaldiversifier?: string

            diversifier allows the same public key to be re-used across different solo machine clients (potentially on different chains) without being considered misbehaviour.

          • OptionalpublicKey?: {
                $typeUrl?: string;
                typeUrl?: string;
                value?: Uint8Array;
            }

            public key of the solo machine

            • Optional$typeUrl?: string

            • OptionaltypeUrl?: string

              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.

            • Optionalvalue?: Uint8Array

              Must be a valid serialized protocol buffer of the above specified type.

          • Optionaltimestamp?: bigint

        • OptionalfrozenSequence?: bigint

          frozen sequence of the solo machine

        • Optionalsequence?: bigint

          latest sequence of the client state

      Returns ClientState

  • fromProtoMsg:function

    • fromProtoMsg(message): ClientState

    • Parameters

      • message: ClientStateProtoMsg

      Returns ClientState

  • toAmino:function

    • toAmino(message): ClientStateAmino

    • Parameters

      • message: ClientState

      Returns ClientStateAmino

  • toAminoMsg:function

    • toAminoMsg(message): ClientStateAminoMsg

    • Parameters

      • message: ClientState

      Returns ClientStateAminoMsg

  • toProto:function

    • toProto(message): Uint8Array

    • Parameters

      • message: ClientState

      Returns Uint8Array

  • toProtoMsg:function

    • toProtoMsg(message): ClientStateProtoMsg

    • Parameters

      • message: ClientState

      Returns ClientStateProtoMsg

• ClientStateData: {
      typeUrl: string;
      decode(input: Uint8Array | BinaryReader, length?: number): ClientStateData;
      encode(message: ClientStateData, writer?: BinaryWriter): BinaryWriter;
      fromAmino(object: ClientStateDataAmino): ClientStateData;
      fromAminoMsg(object: ClientStateDataAminoMsg): ClientStateData;
      fromPartial(object: {
          clientState?: {
              $typeUrl?: string;
              typeUrl?: string;
              value?: Uint8Array;
          };
          path?: Uint8Array;
      }): ClientStateData;
      fromProtoMsg(message: ClientStateDataProtoMsg): ClientStateData;
      toAmino(message: ClientStateData): ClientStateDataAmino;
      toAminoMsg(message: ClientStateData): ClientStateDataAminoMsg;
      toProto(message: ClientStateData): Uint8Array;
      toProtoMsg(message: ClientStateData): ClientStateDataProtoMsg;
  }

  • typeUrl: string

  • decode:function

    • decode(input, length?): ClientStateData

    • Parameters

      • input: Uint8Array | BinaryReader
      • Optionallength: number

      Returns ClientStateData

  • encode:function

    • encode(message, writer?): BinaryWriter

    • Parameters

      • message: ClientStateData
      • writer: BinaryWriter = ...

      Returns BinaryWriter

  • fromAmino:function

    • fromAmino(object): ClientStateData

    • Parameters

      • object: ClientStateDataAmino

      Returns ClientStateData

  • fromAminoMsg:function

    • fromAminoMsg(object): ClientStateData

    • Parameters

      • object: ClientStateDataAminoMsg

      Returns ClientStateData

  • fromPartial:function

    • fromPartial(object): ClientStateData

    • Parameters

      • object: {
            clientState?: {
                $typeUrl?: string;
                typeUrl?: string;
                value?: Uint8Array;
            };
            path?: Uint8Array;
        }

        • OptionalclientState?: {
              $typeUrl?: string;
              typeUrl?: string;
              value?: Uint8Array;
          }

          • Optional$typeUrl?: string

          • OptionaltypeUrl?: string

            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.

          • Optionalvalue?: Uint8Array

            Must be a valid serialized protocol buffer of the above specified type.

        • Optionalpath?: Uint8Array

      Returns ClientStateData

  • fromProtoMsg:function

    • fromProtoMsg(message): ClientStateData

    • Parameters

      • message: ClientStateDataProtoMsg

      Returns ClientStateData

  • toAmino:function

    • toAmino(message): ClientStateDataAmino

    • Parameters

      • message: ClientStateData

      Returns ClientStateDataAmino

  • toAminoMsg:function

    • toAminoMsg(message): ClientStateDataAminoMsg

    • Parameters

      • message: ClientStateData

      Returns ClientStateDataAminoMsg

  • toProto:function

    • toProto(message): Uint8Array

    • Parameters

      • message: ClientStateData

      Returns Uint8Array

  • toProtoMsg:function

    • toProtoMsg(message): ClientStateDataProtoMsg

    • Parameters

      • message: ClientStateData

      Returns ClientStateDataProtoMsg

• ConnectionStateData: {
      typeUrl: string;
      decode(input: Uint8Array | BinaryReader, length?: number): ConnectionStateData;
      encode(message: ConnectionStateData, writer?: BinaryWriter): BinaryWriter;
      fromAmino(object: ConnectionStateDataAmino): ConnectionStateData;
      fromAminoMsg(object: ConnectionStateDataAminoMsg): ConnectionStateData;
      fromPartial(object: {
          connection?: {
              clientId?: string;
              counterparty?: {
                  clientId?: string;
                  connectionId?: string;
                  prefix?: {
                      keyPrefix?: Uint8Array;
                  };
              };
              delayPeriod?: bigint;
              state?: State;
              versions?: {
                  features?: string[];
                  identifier?: string;
              }[];
          };
          path?: Uint8Array;
      }): ConnectionStateData;
      fromProtoMsg(message: ConnectionStateDataProtoMsg): ConnectionStateData;
      toAmino(message: ConnectionStateData): ConnectionStateDataAmino;
      toAminoMsg(message: ConnectionStateData): ConnectionStateDataAminoMsg;
      toProto(message: ConnectionStateData): Uint8Array;
      toProtoMsg(message: ConnectionStateData): ConnectionStateDataProtoMsg;
  }

  • typeUrl: string

  • decode:function

    • decode(input, length?): ConnectionStateData

    • Parameters

      • input: Uint8Array | BinaryReader
      • Optionallength: number

      Returns ConnectionStateData

  • encode:function

    • encode(message, writer?): BinaryWriter

    • Parameters

      • message: ConnectionStateData
      • writer: BinaryWriter = ...

      Returns BinaryWriter

  • fromAmino:function

    • fromAmino(object): ConnectionStateData

    • Parameters

      • object: ConnectionStateDataAmino

      Returns ConnectionStateData

  • fromAminoMsg:function

    • fromAminoMsg(object): ConnectionStateData

    • Parameters

      • object: ConnectionStateDataAminoMsg

      Returns ConnectionStateData

  • fromPartial:function

    • fromPartial(object): ConnectionStateData

    • Parameters

      • object: {
            connection?: {
                clientId?: string;
                counterparty?: {
                    clientId?: string;
                    connectionId?: string;
                    prefix?: {
                        keyPrefix?: Uint8Array;
                    };
                };
                delayPeriod?: bigint;
                state?: State;
                versions?: {
                    features?: string[];
                    identifier?: string;
                }[];
            };
            path?: Uint8Array;
        }

        • Optionalconnection?: {
              clientId?: string;
              counterparty?: {
                  clientId?: string;
                  connectionId?: string;
                  prefix?: {
                      keyPrefix?: Uint8Array;
                  };
              };
              delayPeriod?: bigint;
              state?: State;
              versions?: {
                  features?: string[];
                  identifier?: string;
              }[];
          }

          • OptionalclientId?: string

            client associated with this connection.

          • Optionalcounterparty?: {
                clientId?: string;
                connectionId?: string;
                prefix?: {
                    keyPrefix?: Uint8Array;
                };
            }

            counterparty chain associated with this connection.

            • OptionalclientId?: string

              identifies the client on the counterparty chain associated with a given connection.

            • OptionalconnectionId?: string

              identifies the connection end on the counterparty chain associated with a given connection.

            • Optionalprefix?: {
                  keyPrefix?: Uint8Array;
              }

              commitment merkle prefix of the counterparty chain.

              • OptionalkeyPrefix?: Uint8Array

          • OptionaldelayPeriod?: bigint

            delay period that must pass before a consensus state can be used for packet-verification NOTE: delay period logic is only implemented by some clients.

          • Optionalstate?: State

            current state of the connection end.

          • Optionalversions?: {
                features?: string[];
                identifier?: string;
            }[]

            IBC version which can be utilised to determine encodings or protocols for channels or packets utilising this connection.

        • Optionalpath?: Uint8Array

      Returns ConnectionStateData

  • fromProtoMsg:function

    • fromProtoMsg(message): ConnectionStateData

    • Parameters

      • message: ConnectionStateDataProtoMsg

      Returns ConnectionStateData

  • toAmino:function

    • toAmino(message): ConnectionStateDataAmino

    • Parameters

      • message: ConnectionStateData

      Returns ConnectionStateDataAmino

  • toAminoMsg:function

    • toAminoMsg(message): ConnectionStateDataAminoMsg

    • Parameters

      • message: ConnectionStateData

      Returns ConnectionStateDataAminoMsg

  • toProto:function

    • toProto(message): Uint8Array

    • Parameters

      • message: ConnectionStateData

      Returns Uint8Array

  • toProtoMsg:function

    • toProtoMsg(message): ConnectionStateDataProtoMsg

    • Parameters

      • message: ConnectionStateData

      Returns ConnectionStateDataProtoMsg

• ConsensusState: {
      typeUrl: string;
      decode(input: Uint8Array | BinaryReader, length?: number): ConsensusState;
      encode(message: ConsensusState, writer?: BinaryWriter): BinaryWriter;
      fromAmino(object: ConsensusStateAmino): ConsensusState;
      fromAminoMsg(object: ConsensusStateAminoMsg): ConsensusState;
      fromPartial(object: {
          diversifier?: string;
          publicKey?: {
              $typeUrl?: string;
              typeUrl?: string;
              value?: Uint8Array;
          };
          timestamp?: bigint;
      }): ConsensusState;
      fromProtoMsg(message: ConsensusStateProtoMsg): ConsensusState;
      toAmino(message: ConsensusState): ConsensusStateAmino;
      toAminoMsg(message: ConsensusState): ConsensusStateAminoMsg;
      toProto(message: ConsensusState): Uint8Array;
      toProtoMsg(message: ConsensusState): ConsensusStateProtoMsg;
  }

  • typeUrl: string

  • decode:function

    • decode(input, length?): ConsensusState

    • Parameters

      • input: Uint8Array | BinaryReader
      • Optionallength: number

      Returns ConsensusState

  • encode:function

    • encode(message, writer?): BinaryWriter

    • Parameters

      • message: ConsensusState
      • writer: BinaryWriter = ...

      Returns BinaryWriter

  • fromAmino:function

    • fromAmino(object): ConsensusState

    • Parameters

      • object: ConsensusStateAmino

      Returns ConsensusState

  • fromAminoMsg:function

    • fromAminoMsg(object): ConsensusState

    • Parameters

      • object: ConsensusStateAminoMsg

      Returns ConsensusState

  • fromPartial:function

    • fromPartial(object): ConsensusState

    • Parameters

      • object: {
            diversifier?: string;
            publicKey?: {
                $typeUrl?: string;
                typeUrl?: string;
                value?: Uint8Array;
            };
            timestamp?: bigint;
        }

        • Optionaldiversifier?: string

          diversifier allows the same public key to be re-used across different solo machine clients (potentially on different chains) without being considered misbehaviour.

        • OptionalpublicKey?: {
              $typeUrl?: string;
              typeUrl?: string;
              value?: Uint8Array;
          }

          public key of the solo machine

          • Optional$typeUrl?: string

          • OptionaltypeUrl?: string

            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.

          • Optionalvalue?: Uint8Array

            Must be a valid serialized protocol buffer of the above specified type.

        • Optionaltimestamp?: bigint

      Returns ConsensusState

  • fromProtoMsg:function

    • fromProtoMsg(message): ConsensusState

    • Parameters

      • message: ConsensusStateProtoMsg

      Returns ConsensusState

  • toAmino:function

    • toAmino(message): ConsensusStateAmino

    • Parameters

      • message: ConsensusState

      Returns ConsensusStateAmino

  • toAminoMsg:function

    • toAminoMsg(message): ConsensusStateAminoMsg

    • Parameters

      • message: ConsensusState

      Returns ConsensusStateAminoMsg

  • toProto:function

    • toProto(message): Uint8Array

    • Parameters

      • message: ConsensusState

      Returns Uint8Array

  • toProtoMsg:function

    • toProtoMsg(message): ConsensusStateProtoMsg

    • Parameters

      • message: ConsensusState

      Returns ConsensusStateProtoMsg

• ConsensusStateData: {
      typeUrl: string;
      decode(input: Uint8Array | BinaryReader, length?: number): ConsensusStateData;
      encode(message: ConsensusStateData, writer?: BinaryWriter): BinaryWriter;
      fromAmino(object: ConsensusStateDataAmino): ConsensusStateData;
      fromAminoMsg(object: ConsensusStateDataAminoMsg): ConsensusStateData;
      fromPartial(object: {
          consensusState?: {
              $typeUrl?: string;
              typeUrl?: string;
              value?: Uint8Array;
          };
          path?: Uint8Array;
      }): ConsensusStateData;
      fromProtoMsg(message: ConsensusStateDataProtoMsg): ConsensusStateData;
      toAmino(message: ConsensusStateData): ConsensusStateDataAmino;
      toAminoMsg(message: ConsensusStateData): ConsensusStateDataAminoMsg;
      toProto(message: ConsensusStateData): Uint8Array;
      toProtoMsg(message: ConsensusStateData): ConsensusStateDataProtoMsg;
  }

  • typeUrl: string

  • decode:function

    • decode(input, length?): ConsensusStateData

    • Parameters

      • input: Uint8Array | BinaryReader
      • Optionallength: number

      Returns ConsensusStateData

  • encode:function

    • encode(message, writer?): BinaryWriter

    • Parameters

      • message: ConsensusStateData
      • writer: BinaryWriter = ...

      Returns BinaryWriter

  • fromAmino:function

    • fromAmino(object): ConsensusStateData

    • Parameters

      • object: ConsensusStateDataAmino

      Returns ConsensusStateData

  • fromAminoMsg:function

    • fromAminoMsg(object): ConsensusStateData

    • Parameters

      • object: ConsensusStateDataAminoMsg

      Returns ConsensusStateData

  • fromPartial:function

    • fromPartial(object): ConsensusStateData

    • Parameters

      • object: {
            consensusState?: {
                $typeUrl?: string;
                typeUrl?: string;
                value?: Uint8Array;
            };
            path?: Uint8Array;
        }

        • OptionalconsensusState?: {
              $typeUrl?: string;
              typeUrl?: string;
              value?: Uint8Array;
          }

          • Optional$typeUrl?: string

          • OptionaltypeUrl?: string

            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.

          • Optionalvalue?: Uint8Array

            Must be a valid serialized protocol buffer of the above specified type.

        • Optionalpath?: Uint8Array

      Returns ConsensusStateData

  • fromProtoMsg:function

    • fromProtoMsg(message): ConsensusStateData

    • Parameters

      • message: ConsensusStateDataProtoMsg

      Returns ConsensusStateData

  • toAmino:function

    • toAmino(message): ConsensusStateDataAmino

    • Parameters

      • message: ConsensusStateData

      Returns ConsensusStateDataAmino

  • toAminoMsg:function

    • toAminoMsg(message): ConsensusStateDataAminoMsg

    • Parameters

      • message: ConsensusStateData

      Returns ConsensusStateDataAminoMsg

  • toProto:function

    • toProto(message): Uint8Array

    • Parameters

      • message: ConsensusStateData

      Returns Uint8Array

  • toProtoMsg:function

    • toProtoMsg(message): ConsensusStateDataProtoMsg

    • Parameters

      • message: ConsensusStateData

      Returns ConsensusStateDataProtoMsg

• DataTypeAmino: typeof DataType

• DataTypeSDKType: typeof DataType

• Header: {
      typeUrl: string;
      decode(input: Uint8Array | BinaryReader, length?: number): Header;
      encode(message: Header, writer?: BinaryWriter): BinaryWriter;
      fromAmino(object: HeaderAmino): Header;
      fromAminoMsg(object: HeaderAminoMsg): Header;
      fromPartial(object: {
          newDiversifier?: string;
          newPublicKey?: {
              $typeUrl?: string;
              typeUrl?: string;
              value?: Uint8Array;
          };
          sequence?: bigint;
          signature?: Uint8Array;
          timestamp?: bigint;
      }): Header;
      fromProtoMsg(message: HeaderProtoMsg): Header;
      toAmino(message: Header): HeaderAmino;
      toAminoMsg(message: Header): HeaderAminoMsg;
      toProto(message: Header): Uint8Array;
      toProtoMsg(message: Header): HeaderProtoMsg;
  }

  • typeUrl: string

  • decode:function

    • decode(input, length?): Header

    • Parameters

      • input: Uint8Array | BinaryReader
      • Optionallength: number

      Returns Header

  • encode:function

    • encode(message, writer?): BinaryWriter

    • Parameters

      • message: Header
      • writer: BinaryWriter = ...

      Returns BinaryWriter

  • fromAmino:function

    • fromAmino(object): Header

    • Parameters

      • object: HeaderAmino

      Returns Header

  • fromAminoMsg:function

    • fromAminoMsg(object): Header

    • Parameters

      • object: HeaderAminoMsg

      Returns Header

  • fromPartial:function

    • fromPartial(object): Header

    • Parameters

      • object: {
            newDiversifier?: string;
            newPublicKey?: {
                $typeUrl?: string;
                typeUrl?: string;
                value?: Uint8Array;
            };
            sequence?: bigint;
            signature?: Uint8Array;
            timestamp?: bigint;
        }

        • OptionalnewDiversifier?: string

        • OptionalnewPublicKey?: {
              $typeUrl?: string;
              typeUrl?: string;
              value?: Uint8Array;
          }

          • Optional$typeUrl?: string

          • OptionaltypeUrl?: string

            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.

          • Optionalvalue?: Uint8Array

            Must be a valid serialized protocol buffer of the above specified type.

        • Optionalsequence?: bigint

          sequence to update solo machine public key at

        • Optionalsignature?: Uint8Array

        • Optionaltimestamp?: bigint

      Returns Header

  • fromProtoMsg:function

    • fromProtoMsg(message): Header

    • Parameters

      • message: HeaderProtoMsg

      Returns Header

  • toAmino:function

    • toAmino(message): HeaderAmino

    • Parameters

      • message: Header

      Returns HeaderAmino

  • toAminoMsg:function

    • toAminoMsg(message): HeaderAminoMsg

    • Parameters

      • message: Header

      Returns HeaderAminoMsg

  • toProto:function

    • toProto(message): Uint8Array

    • Parameters

      • message: Header

      Returns Uint8Array

  • toProtoMsg:function

    • toProtoMsg(message): HeaderProtoMsg

    • Parameters

      • message: Header

      Returns HeaderProtoMsg

• HeaderData: {
      typeUrl: string;
      decode(input: Uint8Array | BinaryReader, length?: number): HeaderData;
      encode(message: HeaderData, writer?: BinaryWriter): BinaryWriter;
      fromAmino(object: HeaderDataAmino): HeaderData;
      fromAminoMsg(object: HeaderDataAminoMsg): HeaderData;
      fromPartial(object: {
          newDiversifier?: string;
          newPubKey?: {
              $typeUrl?: string;
              typeUrl?: string;
              value?: Uint8Array;
          };
      }): HeaderData;
      fromProtoMsg(message: HeaderDataProtoMsg): HeaderData;
      toAmino(message: HeaderData): HeaderDataAmino;
      toAminoMsg(message: HeaderData): HeaderDataAminoMsg;
      toProto(message: HeaderData): Uint8Array;
      toProtoMsg(message: HeaderData): HeaderDataProtoMsg;
  }

  • typeUrl: string

  • decode:function

    • decode(input, length?): HeaderData

    • Parameters

      • input: Uint8Array | BinaryReader
      • Optionallength: number

      Returns HeaderData

  • encode:function

    • encode(message, writer?): BinaryWriter

    • Parameters

      • message: HeaderData
      • writer: BinaryWriter = ...

      Returns BinaryWriter

  • fromAmino:function

    • fromAmino(object): HeaderData

    • Parameters

      • object: HeaderDataAmino

      Returns HeaderData

  • fromAminoMsg:function

    • fromAminoMsg(object): HeaderData

    • Parameters

      • object: HeaderDataAminoMsg

      Returns HeaderData

  • fromPartial:function

    • fromPartial(object): HeaderData

    • Parameters

      • object: {
            newDiversifier?: string;
            newPubKey?: {
                $typeUrl?: string;
                typeUrl?: string;
                value?: Uint8Array;
            };
        }

        • OptionalnewDiversifier?: string

          header diversifier

        • OptionalnewPubKey?: {
              $typeUrl?: string;
              typeUrl?: string;
              value?: Uint8Array;
          }

          header public key

          • Optional$typeUrl?: string

          • OptionaltypeUrl?: string

            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.

          • Optionalvalue?: Uint8Array

            Must be a valid serialized protocol buffer of the above specified type.

      Returns HeaderData

  • fromProtoMsg:function

    • fromProtoMsg(message): HeaderData

    • Parameters

      • message: HeaderDataProtoMsg

      Returns HeaderData

  • toAmino:function

    • toAmino(message): HeaderDataAmino

    • Parameters

      • message: HeaderData

      Returns HeaderDataAmino

  • toAminoMsg:function

    • toAminoMsg(message): HeaderDataAminoMsg

    • Parameters

      • message: HeaderData

      Returns HeaderDataAminoMsg

  • toProto:function

    • toProto(message): Uint8Array

    • Parameters

      • message: HeaderData

      Returns Uint8Array

  • toProtoMsg:function

    • toProtoMsg(message): HeaderDataProtoMsg

    • Parameters

      • message: HeaderData

      Returns HeaderDataProtoMsg

• Misbehaviour: {
      typeUrl: string;
      decode(input: Uint8Array | BinaryReader, length?: number): Misbehaviour;
      encode(message: Misbehaviour, writer?: BinaryWriter): BinaryWriter;
      fromAmino(object: MisbehaviourAmino): Misbehaviour;
      fromAminoMsg(object: MisbehaviourAminoMsg): Misbehaviour;
      fromPartial(object: {
          clientId?: string;
          sequence?: bigint;
          signatureOne?: {
              data?: Uint8Array;
              dataType?: DataType;
              signature?: Uint8Array;
              timestamp?: bigint;
          };
          signatureTwo?: {
              data?: Uint8Array;
              dataType?: DataType;
              signature?: Uint8Array;
              timestamp?: bigint;
          };
      }): Misbehaviour;
      fromProtoMsg(message: MisbehaviourProtoMsg): Misbehaviour;
      toAmino(message: Misbehaviour): MisbehaviourAmino;
      toAminoMsg(message: Misbehaviour): MisbehaviourAminoMsg;
      toProto(message: Misbehaviour): Uint8Array;
      toProtoMsg(message: Misbehaviour): MisbehaviourProtoMsg;
  }

  • typeUrl: string

  • decode:function

    • decode(input, length?): Misbehaviour

    • Parameters

      • input: Uint8Array | BinaryReader
      • Optionallength: number

      Returns Misbehaviour

  • encode:function

    • encode(message, writer?): BinaryWriter

    • Parameters

      • message: Misbehaviour
      • writer: BinaryWriter = ...

      Returns BinaryWriter

  • fromAmino:function

    • fromAmino(object): Misbehaviour

    • Parameters

      • object: MisbehaviourAmino

      Returns Misbehaviour

  • fromAminoMsg:function

    • fromAminoMsg(object): Misbehaviour

    • Parameters

      • object: MisbehaviourAminoMsg

      Returns Misbehaviour

  • fromPartial:function

    • fromPartial(object): Misbehaviour

    • Parameters

      • object: {
            clientId?: string;
            sequence?: bigint;
            signatureOne?: {
                data?: Uint8Array;
                dataType?: DataType;
                signature?: Uint8Array;
                timestamp?: bigint;
            };
            signatureTwo?: {
                data?: Uint8Array;
                dataType?: DataType;
                signature?: Uint8Array;
                timestamp?: bigint;
            };
        }

        • OptionalclientId?: string

        • Optionalsequence?: bigint

        • OptionalsignatureOne?: {
              data?: Uint8Array;
              dataType?: DataType;
              signature?: Uint8Array;
              timestamp?: bigint;
          }

          • Optionaldata?: Uint8Array

          • OptionaldataType?: DataType

          • Optionalsignature?: Uint8Array

          • Optionaltimestamp?: bigint

        • OptionalsignatureTwo?: {
              data?: Uint8Array;
              dataType?: DataType;
              signature?: Uint8Array;
              timestamp?: bigint;
          }

          • Optionaldata?: Uint8Array

          • OptionaldataType?: DataType

          • Optionalsignature?: Uint8Array

          • Optionaltimestamp?: bigint

      Returns Misbehaviour

  • fromProtoMsg:function

    • fromProtoMsg(message): Misbehaviour

    • Parameters

      • message: MisbehaviourProtoMsg

      Returns Misbehaviour

  • toAmino:function

    • toAmino(message): MisbehaviourAmino

    • Parameters

      • message: Misbehaviour

      Returns MisbehaviourAmino

  • toAminoMsg:function

    • toAminoMsg(message): MisbehaviourAminoMsg

    • Parameters

      • message: Misbehaviour

      Returns MisbehaviourAminoMsg

  • toProto:function

    • toProto(message): Uint8Array

    • Parameters

      • message: Misbehaviour

      Returns Uint8Array

  • toProtoMsg:function

    • toProtoMsg(message): MisbehaviourProtoMsg

    • Parameters

      • message: Misbehaviour

      Returns MisbehaviourProtoMsg

• NextSequenceRecvData: {
      typeUrl: string;
      decode(input: Uint8Array | BinaryReader, length?: number): NextSequenceRecvData;
      encode(message: NextSequenceRecvData, writer?: BinaryWriter): BinaryWriter;
      fromAmino(object: NextSequenceRecvDataAmino): NextSequenceRecvData;
      fromAminoMsg(object: NextSequenceRecvDataAminoMsg): NextSequenceRecvData;
      fromPartial(object: {
          nextSeqRecv?: bigint;
          path?: Uint8Array;
      }): NextSequenceRecvData;
      fromProtoMsg(message: NextSequenceRecvDataProtoMsg): NextSequenceRecvData;
      toAmino(message: NextSequenceRecvData): NextSequenceRecvDataAmino;
      toAminoMsg(message: NextSequenceRecvData): NextSequenceRecvDataAminoMsg;
      toProto(message: NextSequenceRecvData): Uint8Array;
      toProtoMsg(message: NextSequenceRecvData): NextSequenceRecvDataProtoMsg;
  }

  • typeUrl: string

  • decode:function

    • decode(input, length?): NextSequenceRecvData

    • Parameters

      • input: Uint8Array | BinaryReader
      • Optionallength: number

      Returns NextSequenceRecvData

  • encode:function

    • encode(message, writer?): BinaryWriter

    • Parameters

      • message: NextSequenceRecvData
      • writer: BinaryWriter = ...

      Returns BinaryWriter

  • fromAmino:function

    • fromAmino(object): NextSequenceRecvData

    • Parameters

      • object: NextSequenceRecvDataAmino

      Returns NextSequenceRecvData

  • fromAminoMsg:function

    • fromAminoMsg(object): NextSequenceRecvData

    • Parameters

      • object: NextSequenceRecvDataAminoMsg

      Returns NextSequenceRecvData

  • fromPartial:function

    • fromPartial(object): NextSequenceRecvData

    • Parameters

      • object: {
            nextSeqRecv?: bigint;
            path?: Uint8Array;
        }

        • OptionalnextSeqRecv?: bigint

        • Optionalpath?: Uint8Array

      Returns NextSequenceRecvData

  • fromProtoMsg:function

    • fromProtoMsg(message): NextSequenceRecvData

    • Parameters

      • message: NextSequenceRecvDataProtoMsg

      Returns NextSequenceRecvData

  • toAmino:function

    • toAmino(message): NextSequenceRecvDataAmino

    • Parameters

      • message: NextSequenceRecvData

      Returns NextSequenceRecvDataAmino

  • toAminoMsg:function

    • toAminoMsg(message): NextSequenceRecvDataAminoMsg

    • Parameters

      • message: NextSequenceRecvData

      Returns NextSequenceRecvDataAminoMsg

  • toProto:function

    • toProto(message): Uint8Array

    • Parameters

      • message: NextSequenceRecvData

      Returns Uint8Array

  • toProtoMsg:function

    • toProtoMsg(message): NextSequenceRecvDataProtoMsg

    • Parameters

      • message: NextSequenceRecvData

      Returns NextSequenceRecvDataProtoMsg

• PacketAcknowledgementData: {
      typeUrl: string;
      decode(input: Uint8Array | BinaryReader, length?: number): PacketAcknowledgementData;
      encode(message: PacketAcknowledgementData, writer?: BinaryWriter): BinaryWriter;
      fromAmino(object: PacketAcknowledgementDataAmino): PacketAcknowledgementData;
      fromAminoMsg(object: PacketAcknowledgementDataAminoMsg): PacketAcknowledgementData;
      fromPartial(object: {
          acknowledgement?: Uint8Array;
          path?: Uint8Array;
      }): PacketAcknowledgementData;
      fromProtoMsg(message: PacketAcknowledgementDataProtoMsg): PacketAcknowledgementData;
      toAmino(message: PacketAcknowledgementData): PacketAcknowledgementDataAmino;
      toAminoMsg(message: PacketAcknowledgementData): PacketAcknowledgementDataAminoMsg;
      toProto(message: PacketAcknowledgementData): Uint8Array;
      toProtoMsg(message: PacketAcknowledgementData): PacketAcknowledgementDataProtoMsg;
  }

  • typeUrl: string

  • decode:function

    • decode(input, length?): PacketAcknowledgementData

    • Parameters

      • input: Uint8Array | BinaryReader
      • Optionallength: number

      Returns PacketAcknowledgementData

  • encode:function

    • encode(message, writer?): BinaryWriter

    • Parameters

      • message: PacketAcknowledgementData
      • writer: BinaryWriter = ...

      Returns BinaryWriter

  • fromAmino:function

    • fromAmino(object): PacketAcknowledgementData

    • Parameters

      • object: PacketAcknowledgementDataAmino

      Returns PacketAcknowledgementData

  • fromAminoMsg:function

    • fromAminoMsg(object): PacketAcknowledgementData

    • Parameters

      • object: PacketAcknowledgementDataAminoMsg

      Returns PacketAcknowledgementData

  • fromPartial:function

    • fromPartial(object): PacketAcknowledgementData

    • Parameters

      • object: {
            acknowledgement?: Uint8Array;
            path?: Uint8Array;
        }

        • Optionalacknowledgement?: Uint8Array

        • Optionalpath?: Uint8Array

      Returns PacketAcknowledgementData

  • fromProtoMsg:function

    • fromProtoMsg(message): PacketAcknowledgementData

    • Parameters

      • message: PacketAcknowledgementDataProtoMsg

      Returns PacketAcknowledgementData

  • toAmino:function

    • toAmino(message): PacketAcknowledgementDataAmino

    • Parameters

      • message: PacketAcknowledgementData

      Returns PacketAcknowledgementDataAmino

  • toAminoMsg:function

    • toAminoMsg(message): PacketAcknowledgementDataAminoMsg

    • Parameters

      • message: PacketAcknowledgementData

      Returns PacketAcknowledgementDataAminoMsg

  • toProto:function

    • toProto(message): Uint8Array

    • Parameters

      • message: PacketAcknowledgementData

      Returns Uint8Array

  • toProtoMsg:function

    • toProtoMsg(message): PacketAcknowledgementDataProtoMsg

    • Parameters

      • message: PacketAcknowledgementData

      Returns PacketAcknowledgementDataProtoMsg

• PacketCommitmentData: {
      typeUrl: string;
      decode(input: Uint8Array | BinaryReader, length?: number): PacketCommitmentData;
      encode(message: PacketCommitmentData, writer?: BinaryWriter): BinaryWriter;
      fromAmino(object: PacketCommitmentDataAmino): PacketCommitmentData;
      fromAminoMsg(object: PacketCommitmentDataAminoMsg): PacketCommitmentData;
      fromPartial(object: {
          commitment?: Uint8Array;
          path?: Uint8Array;
      }): PacketCommitmentData;
      fromProtoMsg(message: PacketCommitmentDataProtoMsg): PacketCommitmentData;
      toAmino(message: PacketCommitmentData): PacketCommitmentDataAmino;
      toAminoMsg(message: PacketCommitmentData): PacketCommitmentDataAminoMsg;
      toProto(message: PacketCommitmentData): Uint8Array;
      toProtoMsg(message: PacketCommitmentData): PacketCommitmentDataProtoMsg;
  }

  • typeUrl: string

  • decode:function

    • decode(input, length?): PacketCommitmentData

    • Parameters

      • input: Uint8Array | BinaryReader
      • Optionallength: number

      Returns PacketCommitmentData

  • encode:function

    • encode(message, writer?): BinaryWriter

    • Parameters

      • message: PacketCommitmentData
      • writer: BinaryWriter = ...

      Returns BinaryWriter

  • fromAmino:function

    • fromAmino(object): PacketCommitmentData

    • Parameters

      • object: PacketCommitmentDataAmino

      Returns PacketCommitmentData

  • fromAminoMsg:function

    • fromAminoMsg(object): PacketCommitmentData

    • Parameters

      • object: PacketCommitmentDataAminoMsg

      Returns PacketCommitmentData

  • fromPartial:function

    • fromPartial(object): PacketCommitmentData

    • Parameters

      • object: {
            commitment?: Uint8Array;
            path?: Uint8Array;
        }

        • Optionalcommitment?: Uint8Array

        • Optionalpath?: Uint8Array

      Returns PacketCommitmentData

  • fromProtoMsg:function

    • fromProtoMsg(message): PacketCommitmentData

    • Parameters

      • message: PacketCommitmentDataProtoMsg

      Returns PacketCommitmentData

  • toAmino:function

    • toAmino(message): PacketCommitmentDataAmino

    • Parameters

      • message: PacketCommitmentData

      Returns PacketCommitmentDataAmino

  • toAminoMsg:function

    • toAminoMsg(message): PacketCommitmentDataAminoMsg

    • Parameters

      • message: PacketCommitmentData

      Returns PacketCommitmentDataAminoMsg

  • toProto:function

    • toProto(message): Uint8Array

    • Parameters

      • message: PacketCommitmentData

      Returns Uint8Array

  • toProtoMsg:function

    • toProtoMsg(message): PacketCommitmentDataProtoMsg

    • Parameters

      • message: PacketCommitmentData

      Returns PacketCommitmentDataProtoMsg

• PacketReceiptAbsenceData: {
      typeUrl: string;
      decode(input: Uint8Array | BinaryReader, length?: number): PacketReceiptAbsenceData;
      encode(message: PacketReceiptAbsenceData, writer?: BinaryWriter): BinaryWriter;
      fromAmino(object: PacketReceiptAbsenceDataAmino): PacketReceiptAbsenceData;
      fromAminoMsg(object: PacketReceiptAbsenceDataAminoMsg): PacketReceiptAbsenceData;
      fromPartial(object: {
          path?: Uint8Array;
      }): PacketReceiptAbsenceData;
      fromProtoMsg(message: PacketReceiptAbsenceDataProtoMsg): PacketReceiptAbsenceData;
      toAmino(message: PacketReceiptAbsenceData): PacketReceiptAbsenceDataAmino;
      toAminoMsg(message: PacketReceiptAbsenceData): PacketReceiptAbsenceDataAminoMsg;
      toProto(message: PacketReceiptAbsenceData): Uint8Array;
      toProtoMsg(message: PacketReceiptAbsenceData): PacketReceiptAbsenceDataProtoMsg;
  }

  • typeUrl: string

  • decode:function

    • decode(input, length?): PacketReceiptAbsenceData

    • Parameters

      • input: Uint8Array | BinaryReader
      • Optionallength: number

      Returns PacketReceiptAbsenceData

  • encode:function

    • encode(message, writer?): BinaryWriter

    • Parameters

      • message: PacketReceiptAbsenceData
      • writer: BinaryWriter = ...

      Returns BinaryWriter

  • fromAmino:function

    • fromAmino(object): PacketReceiptAbsenceData

    • Parameters

      • object: PacketReceiptAbsenceDataAmino

      Returns PacketReceiptAbsenceData

  • fromAminoMsg:function

    • fromAminoMsg(object): PacketReceiptAbsenceData

    • Parameters

      • object: PacketReceiptAbsenceDataAminoMsg

      Returns PacketReceiptAbsenceData

  • fromPartial:function

    • fromPartial(object): PacketReceiptAbsenceData

    • Parameters

      • object: {
            path?: Uint8Array;
        }

        • Optionalpath?: Uint8Array

      Returns PacketReceiptAbsenceData

  • fromProtoMsg:function

    • fromProtoMsg(message): PacketReceiptAbsenceData

    • Parameters

      • message: PacketReceiptAbsenceDataProtoMsg

      Returns PacketReceiptAbsenceData

  • toAmino:function

    • toAmino(message): PacketReceiptAbsenceDataAmino

    • Parameters

      • message: PacketReceiptAbsenceData

      Returns PacketReceiptAbsenceDataAmino

  • toAminoMsg:function

    • toAminoMsg(message): PacketReceiptAbsenceDataAminoMsg

    • Parameters

      • message: PacketReceiptAbsenceData

      Returns PacketReceiptAbsenceDataAminoMsg

  • toProto:function

    • toProto(message): Uint8Array

    • Parameters

      • message: PacketReceiptAbsenceData

      Returns Uint8Array

  • toProtoMsg:function

    • toProtoMsg(message): PacketReceiptAbsenceDataProtoMsg

    • Parameters

      • message: PacketReceiptAbsenceData

      Returns PacketReceiptAbsenceDataProtoMsg

• SignBytes: {
      typeUrl: string;
      decode(input: Uint8Array | BinaryReader, length?: number): SignBytes;
      encode(message: SignBytes, writer?: BinaryWriter): BinaryWriter;
      fromAmino(object: SignBytesAmino): SignBytes;
      fromAminoMsg(object: SignBytesAminoMsg): SignBytes;
      fromPartial(object: {
          data?: Uint8Array;
          dataType?: DataType;
          diversifier?: string;
          sequence?: bigint;
          timestamp?: bigint;
      }): SignBytes;
      fromProtoMsg(message: SignBytesProtoMsg): SignBytes;
      toAmino(message: SignBytes): SignBytesAmino;
      toAminoMsg(message: SignBytes): SignBytesAminoMsg;
      toProto(message: SignBytes): Uint8Array;
      toProtoMsg(message: SignBytes): SignBytesProtoMsg;
  }

  • typeUrl: string

  • decode:function

    • decode(input, length?): SignBytes

    • Parameters

      • input: Uint8Array | BinaryReader
      • Optionallength: number

      Returns SignBytes

  • encode:function

    • encode(message, writer?): BinaryWriter

    • Parameters

      • message: SignBytes
      • writer: BinaryWriter = ...

      Returns BinaryWriter

  • fromAmino:function

    • fromAmino(object): SignBytes

    • Parameters

      • object: SignBytesAmino

      Returns SignBytes

  • fromAminoMsg:function

    • fromAminoMsg(object): SignBytes

    • Parameters

      • object: SignBytesAminoMsg

      Returns SignBytes

  • fromPartial:function

    • fromPartial(object): SignBytes

    • Parameters

      • object: {
            data?: Uint8Array;
            dataType?: DataType;
            diversifier?: string;
            sequence?: bigint;
            timestamp?: bigint;
        }

        • Optionaldata?: Uint8Array

          marshaled data

        • OptionaldataType?: DataType

          type of the data used

        • Optionaldiversifier?: string

        • Optionalsequence?: bigint

        • Optionaltimestamp?: bigint

      Returns SignBytes

  • fromProtoMsg:function

    • fromProtoMsg(message): SignBytes

    • Parameters

      • message: SignBytesProtoMsg

      Returns SignBytes

  • toAmino:function

    • toAmino(message): SignBytesAmino

    • Parameters

      • message: SignBytes

      Returns SignBytesAmino

  • toAminoMsg:function

    • toAminoMsg(message): SignBytesAminoMsg

    • Parameters

      • message: SignBytes

      Returns SignBytesAminoMsg

  • toProto:function

    • toProto(message): Uint8Array

    • Parameters

      • message: SignBytes

      Returns Uint8Array

  • toProtoMsg:function

    • toProtoMsg(message): SignBytesProtoMsg

    • Parameters

      • message: SignBytes

      Returns SignBytesProtoMsg

• SignatureAndData: {
      typeUrl: string;
      decode(input: Uint8Array | BinaryReader, length?: number): SignatureAndData;
      encode(message: SignatureAndData, writer?: BinaryWriter): BinaryWriter;
      fromAmino(object: SignatureAndDataAmino): SignatureAndData;
      fromAminoMsg(object: SignatureAndDataAminoMsg): SignatureAndData;
      fromPartial(object: {
          data?: Uint8Array;
          dataType?: DataType;
          signature?: Uint8Array;
          timestamp?: bigint;
      }): SignatureAndData;
      fromProtoMsg(message: SignatureAndDataProtoMsg): SignatureAndData;
      toAmino(message: SignatureAndData): SignatureAndDataAmino;
      toAminoMsg(message: SignatureAndData): SignatureAndDataAminoMsg;
      toProto(message: SignatureAndData): Uint8Array;
      toProtoMsg(message: SignatureAndData): SignatureAndDataProtoMsg;
  }

  • typeUrl: string

  • decode:function

    • decode(input, length?): SignatureAndData

    • Parameters

      • input: Uint8Array | BinaryReader
      • Optionallength: number

      Returns SignatureAndData

  • encode:function

    • encode(message, writer?): BinaryWriter

    • Parameters

      • message: SignatureAndData
      • writer: BinaryWriter = ...

      Returns BinaryWriter

  • fromAmino:function

    • fromAmino(object): SignatureAndData

    • Parameters

      • object: SignatureAndDataAmino

      Returns SignatureAndData

  • fromAminoMsg:function

    • fromAminoMsg(object): SignatureAndData

    • Parameters

      • object: SignatureAndDataAminoMsg

      Returns SignatureAndData

  • fromPartial:function

    • fromPartial(object): SignatureAndData

    • Parameters

      • object: {
            data?: Uint8Array;
            dataType?: DataType;
            signature?: Uint8Array;
            timestamp?: bigint;
        }

        • Optionaldata?: Uint8Array

        • OptionaldataType?: DataType

        • Optionalsignature?: Uint8Array

        • Optionaltimestamp?: bigint

      Returns SignatureAndData

  • fromProtoMsg:function

    • fromProtoMsg(message): SignatureAndData

    • Parameters

      • message: SignatureAndDataProtoMsg

      Returns SignatureAndData

  • toAmino:function

    • toAmino(message): SignatureAndDataAmino

    • Parameters

      • message: SignatureAndData

      Returns SignatureAndDataAmino

  • toAminoMsg:function

    • toAminoMsg(message): SignatureAndDataAminoMsg

    • Parameters

      • message: SignatureAndData

      Returns SignatureAndDataAminoMsg

  • toProto:function

    • toProto(message): Uint8Array

    • Parameters

      • message: SignatureAndData

      Returns Uint8Array

  • toProtoMsg:function

    • toProtoMsg(message): SignatureAndDataProtoMsg

    • Parameters

      • message: SignatureAndData

      Returns SignatureAndDataProtoMsg

• TimestampedSignatureData: {
      typeUrl: string;
      decode(input: Uint8Array | BinaryReader, length?: number): TimestampedSignatureData;
      encode(message: TimestampedSignatureData, writer?: BinaryWriter): BinaryWriter;
      fromAmino(object: TimestampedSignatureDataAmino): TimestampedSignatureData;
      fromAminoMsg(object: TimestampedSignatureDataAminoMsg): TimestampedSignatureData;
      fromPartial(object: {
          signatureData?: Uint8Array;
          timestamp?: bigint;
      }): TimestampedSignatureData;
      fromProtoMsg(message: TimestampedSignatureDataProtoMsg): TimestampedSignatureData;
      toAmino(message: TimestampedSignatureData): TimestampedSignatureDataAmino;
      toAminoMsg(message: TimestampedSignatureData): TimestampedSignatureDataAminoMsg;
      toProto(message: TimestampedSignatureData): Uint8Array;
      toProtoMsg(message: TimestampedSignatureData): TimestampedSignatureDataProtoMsg;
  }

  • typeUrl: string

  • decode:function

    • decode(input, length?): TimestampedSignatureData

    • Parameters

      • input: Uint8Array | BinaryReader
      • Optionallength: number

      Returns TimestampedSignatureData

  • encode:function

    • encode(message, writer?): BinaryWriter

    • Parameters

      • message: TimestampedSignatureData
      • writer: BinaryWriter = ...

      Returns BinaryWriter

  • fromAmino:function

    • fromAmino(object): TimestampedSignatureData

    • Parameters

      • object: TimestampedSignatureDataAmino

      Returns TimestampedSignatureData

  • fromAminoMsg:function

    • fromAminoMsg(object): TimestampedSignatureData

    • Parameters

      • object: TimestampedSignatureDataAminoMsg

      Returns TimestampedSignatureData

  • fromPartial:function

    • fromPartial(object): TimestampedSignatureData

    • Parameters

      • object: {
            signatureData?: Uint8Array;
            timestamp?: bigint;
        }

        • OptionalsignatureData?: Uint8Array

        • Optionaltimestamp?: bigint

      Returns TimestampedSignatureData

  • fromProtoMsg:function

    • fromProtoMsg(message): TimestampedSignatureData

    • Parameters

      • message: TimestampedSignatureDataProtoMsg

      Returns TimestampedSignatureData

  • toAmino:function

    • toAmino(message): TimestampedSignatureDataAmino

    • Parameters

      • message: TimestampedSignatureData

      Returns TimestampedSignatureDataAmino

  • toAminoMsg:function

    • toAminoMsg(message): TimestampedSignatureDataAminoMsg

    • Parameters

      • message: TimestampedSignatureData

      Returns TimestampedSignatureDataAminoMsg

  • toProto:function

    • toProto(message): Uint8Array

    • Parameters

      • message: TimestampedSignatureData

      Returns Uint8Array

  • toProtoMsg:function

    • toProtoMsg(message): TimestampedSignatureDataProtoMsg

    • Parameters

      • message: TimestampedSignatureData

      Returns TimestampedSignatureDataProtoMsg

• dataTypeFromJSON:function

  • dataTypeFromJSON(object): DataType

  • Parameters

    • object: any

    Returns DataType

• dataTypeToJSON:function

  • dataTypeToJSON(object): string

  • Parameters

    • object: DataType

    Returns string