Variable v1beta1Const

Type declaration

• AllowedMsgAllowance: {
      typeUrl: string;
      decode(input: Uint8Array | BinaryReader, length?: number): AllowedMsgAllowance;
      encode(message: AllowedMsgAllowance, writer?: BinaryWriter): BinaryWriter;
      fromAmino(object: AllowedMsgAllowanceAmino): AllowedMsgAllowance;
      fromAminoMsg(object: AllowedMsgAllowanceAminoMsg): AllowedMsgAllowance;
      fromPartial(object: {
          $typeUrl?: "/cosmos.feegrant.v1beta1.AllowedMsgAllowance";
          allowance?:
              | {
                  $typeUrl?: string;
                  typeUrl?: string;
                  value?: Uint8Array;
              }
              | {
                  $typeUrl?: "/cosmos.feegrant.v1beta1.BasicAllowance";
                  expiration?: Date;
                  spendLimit?: {
                      amount?: string;
                      denom?: string;
                  }[];
              }
              | {
                  $typeUrl?: "/cosmos.feegrant.v1beta1.PeriodicAllowance";
                  basic?: {
                      $typeUrl?: "/cosmos.feegrant.v1beta1.BasicAllowance";
                      expiration?: Date;
                      spendLimit?: {
                          amount?: (...) | (...);
                          denom?: (...) | (...);
                      }[];
                  };
                  period?: {
                      nanos?: number;
                      seconds?: bigint;
                  };
                  periodCanSpend?: {
                      amount?: string;
                      denom?: string;
                  }[];
                  periodReset?: Date;
                  periodSpendLimit?: {
                      amount?: string;
                      denom?: string;
                  }[];
              }
              | ({ $typeUrl?: "/cosmos.feegrant.v1beta1.AllowedMsgAllowance" | undefined; allowance?: { $typeUrl?: string | undefined; typeUrl?: string | undefined; value?: Uint8Array | undefined; } | { ...; } | { ...; } | ... | undefined; allowedMessages?: string[] | undefined; });
          allowedMessages?: string[];
      }): AllowedMsgAllowance;
      fromProtoMsg(message: AllowedMsgAllowanceProtoMsg): AllowedMsgAllowance;
      toAmino(message: AllowedMsgAllowance): AllowedMsgAllowanceAmino;
      toAminoMsg(message: AllowedMsgAllowance): AllowedMsgAllowanceAminoMsg;
      toProto(message: AllowedMsgAllowance): Uint8Array;
      toProtoMsg(message: AllowedMsgAllowance): AllowedMsgAllowanceProtoMsg;
  }

  • typeUrl: string

  • decode:function

    • decode(input, length?): AllowedMsgAllowance

    • Parameters

      • input: Uint8Array | BinaryReader
      • Optionallength: number

      Returns AllowedMsgAllowance

  • encode:function

    • encode(message, writer?): BinaryWriter

    • Parameters

      • message: AllowedMsgAllowance
      • writer: BinaryWriter = ...

      Returns BinaryWriter

  • fromAmino:function

    • fromAmino(object): AllowedMsgAllowance

    • Parameters

      • object: AllowedMsgAllowanceAmino

      Returns AllowedMsgAllowance

  • fromAminoMsg:function

    • fromAminoMsg(object): AllowedMsgAllowance

    • Parameters

      • object: AllowedMsgAllowanceAminoMsg

      Returns AllowedMsgAllowance

  • fromPartial:function

    • fromPartial(object): AllowedMsgAllowance

    • Parameters

      • object: {
            $typeUrl?: "/cosmos.feegrant.v1beta1.AllowedMsgAllowance";
            allowance?:
                | {
                    $typeUrl?: string;
                    typeUrl?: string;
                    value?: Uint8Array;
                }
                | {
                    $typeUrl?: "/cosmos.feegrant.v1beta1.BasicAllowance";
                    expiration?: Date;
                    spendLimit?: {
                        amount?: string;
                        denom?: string;
                    }[];
                }
                | {
                    $typeUrl?: "/cosmos.feegrant.v1beta1.PeriodicAllowance";
                    basic?: {
                        $typeUrl?: "/cosmos.feegrant.v1beta1.BasicAllowance";
                        expiration?: Date;
                        spendLimit?: {
                            amount?: (...) | (...);
                            denom?: (...) | (...);
                        }[];
                    };
                    period?: {
                        nanos?: number;
                        seconds?: bigint;
                    };
                    periodCanSpend?: {
                        amount?: string;
                        denom?: string;
                    }[];
                    periodReset?: Date;
                    periodSpendLimit?: {
                        amount?: string;
                        denom?: string;
                    }[];
                }
                | ({ $typeUrl?: "/cosmos.feegrant.v1beta1.AllowedMsgAllowance" | undefined; allowance?: { $typeUrl?: string | undefined; typeUrl?: string | undefined; value?: Uint8Array | undefined; } | { ...; } | { ...; } | ... | undefined; allowedMessages?: string[] | undefined; });
            allowedMessages?: string[];
        }

        • Optional$typeUrl?: "/cosmos.feegrant.v1beta1.AllowedMsgAllowance"

        • Optionalallowance?:
              | {
                  $typeUrl?: string;
                  typeUrl?: string;
                  value?: Uint8Array;
              }
              | {
                  $typeUrl?: "/cosmos.feegrant.v1beta1.BasicAllowance";
                  expiration?: Date;
                  spendLimit?: {
                      amount?: string;
                      denom?: string;
                  }[];
              }
              | {
                  $typeUrl?: "/cosmos.feegrant.v1beta1.PeriodicAllowance";
                  basic?: {
                      $typeUrl?: "/cosmos.feegrant.v1beta1.BasicAllowance";
                      expiration?: Date;
                      spendLimit?: {
                          amount?: (...) | (...);
                          denom?: (...) | (...);
                      }[];
                  };
                  period?: {
                      nanos?: number;
                      seconds?: bigint;
                  };
                  periodCanSpend?: {
                      amount?: string;
                      denom?: string;
                  }[];
                  periodReset?: Date;
                  periodSpendLimit?: {
                      amount?: string;
                      denom?: string;
                  }[];
              }
              | ({ $typeUrl?: "/cosmos.feegrant.v1beta1.AllowedMsgAllowance" | undefined; allowance?: { $typeUrl?: string | undefined; typeUrl?: string | undefined; value?: Uint8Array | undefined; } | { ...; } | { ...; } | ... | undefined; allowedMessages?: string[] | undefined; })

          allowance can be any of basic and filtered fee allowance.

        • OptionalallowedMessages?: string[]

          allowed_messages are the messages for which the grantee has the access.

      Returns AllowedMsgAllowance

  • fromProtoMsg:function

    • fromProtoMsg(message): AllowedMsgAllowance

    • Parameters

      • message: AllowedMsgAllowanceProtoMsg

      Returns AllowedMsgAllowance

  • toAmino:function

    • toAmino(message): AllowedMsgAllowanceAmino

    • Parameters

      • message: AllowedMsgAllowance

      Returns AllowedMsgAllowanceAmino

  • toAminoMsg:function

    • toAminoMsg(message): AllowedMsgAllowanceAminoMsg

    • Parameters

      • message: AllowedMsgAllowance

      Returns AllowedMsgAllowanceAminoMsg

  • toProto:function

    • toProto(message): Uint8Array

    • Parameters

      • message: AllowedMsgAllowance

      Returns Uint8Array

  • toProtoMsg:function

    • toProtoMsg(message): AllowedMsgAllowanceProtoMsg

    • Parameters

      • message: AllowedMsgAllowance

      Returns AllowedMsgAllowanceProtoMsg

• AminoConverter: {
      /cosmos.feegrant.v1beta1.MsgGrantAllowance: {
          aminoType: string;
          fromAmino: ((object: MsgGrantAllowanceAmino) => MsgGrantAllowance);
          toAmino: ((message: MsgGrantAllowance) => MsgGrantAllowanceAmino);
      };
      /cosmos.feegrant.v1beta1.MsgRevokeAllowance: {
          aminoType: string;
          fromAmino: ((object: MsgRevokeAllowanceAmino) => MsgRevokeAllowance);
          toAmino: ((message: MsgRevokeAllowance) => MsgRevokeAllowanceAmino);
      };
  }

  • /cosmos.feegrant.v1beta1.MsgGrantAllowance: {
        aminoType: string;
        fromAmino: ((object: MsgGrantAllowanceAmino) => MsgGrantAllowance);
        toAmino: ((message: MsgGrantAllowance) => MsgGrantAllowanceAmino);
    }

    • aminoType: string

    • fromAmino: ((object: MsgGrantAllowanceAmino) => MsgGrantAllowance)

      • • (object): MsgGrantAllowance

        • Parameters

          • object: MsgGrantAllowanceAmino

          Returns MsgGrantAllowance

    • toAmino: ((message: MsgGrantAllowance) => MsgGrantAllowanceAmino)

      • • (message): MsgGrantAllowanceAmino

        • Parameters

          • message: MsgGrantAllowance

          Returns MsgGrantAllowanceAmino

  • /cosmos.feegrant.v1beta1.MsgRevokeAllowance: {
        aminoType: string;
        fromAmino: ((object: MsgRevokeAllowanceAmino) => MsgRevokeAllowance);
        toAmino: ((message: MsgRevokeAllowance) => MsgRevokeAllowanceAmino);
    }

    • aminoType: string

    • fromAmino: ((object: MsgRevokeAllowanceAmino) => MsgRevokeAllowance)

      • • (object): MsgRevokeAllowance

        • Parameters

          • object: MsgRevokeAllowanceAmino

          Returns MsgRevokeAllowance

    • toAmino: ((message: MsgRevokeAllowance) => MsgRevokeAllowanceAmino)

      • • (message): MsgRevokeAllowanceAmino

        • Parameters

          • message: MsgRevokeAllowance

          Returns MsgRevokeAllowanceAmino

• BasicAllowance: {
      typeUrl: string;
      decode(input: Uint8Array | BinaryReader, length?: number): BasicAllowance;
      encode(message: BasicAllowance, writer?: BinaryWriter): BinaryWriter;
      fromAmino(object: BasicAllowanceAmino): BasicAllowance;
      fromAminoMsg(object: BasicAllowanceAminoMsg): BasicAllowance;
      fromPartial(object: {
          $typeUrl?: "/cosmos.feegrant.v1beta1.BasicAllowance";
          expiration?: Date;
          spendLimit?: {
              amount?: string;
              denom?: string;
          }[];
      }): BasicAllowance;
      fromProtoMsg(message: BasicAllowanceProtoMsg): BasicAllowance;
      toAmino(message: BasicAllowance): BasicAllowanceAmino;
      toAminoMsg(message: BasicAllowance): BasicAllowanceAminoMsg;
      toProto(message: BasicAllowance): Uint8Array;
      toProtoMsg(message: BasicAllowance): BasicAllowanceProtoMsg;
  }

  • typeUrl: string

  • decode:function

    • decode(input, length?): BasicAllowance

    • Parameters

      • input: Uint8Array | BinaryReader
      • Optionallength: number

      Returns BasicAllowance

  • encode:function

    • encode(message, writer?): BinaryWriter

    • Parameters

      • message: BasicAllowance
      • writer: BinaryWriter = ...

      Returns BinaryWriter

  • fromAmino:function

    • fromAmino(object): BasicAllowance

    • Parameters

      • object: BasicAllowanceAmino

      Returns BasicAllowance

  • fromAminoMsg:function

    • fromAminoMsg(object): BasicAllowance

    • Parameters

      • object: BasicAllowanceAminoMsg

      Returns BasicAllowance

  • fromPartial:function

    • fromPartial(object): BasicAllowance

    • Parameters

      • object: {
            $typeUrl?: "/cosmos.feegrant.v1beta1.BasicAllowance";
            expiration?: Date;
            spendLimit?: {
                amount?: string;
                denom?: string;
            }[];
        }

        • Optional$typeUrl?: "/cosmos.feegrant.v1beta1.BasicAllowance"

        • Optionalexpiration?: Date

          expiration specifies an optional time when this allowance expires

        • OptionalspendLimit?: {
              amount?: string;
              denom?: string;
          }[]

          spend_limit specifies the maximum amount of tokens that can be spent by this allowance and will be updated as tokens are spent. If it is empty, there is no spend limit and any amount of coins can be spent.

      Returns BasicAllowance

  • fromProtoMsg:function

    • fromProtoMsg(message): BasicAllowance

    • Parameters

      • message: BasicAllowanceProtoMsg

      Returns BasicAllowance

  • toAmino:function

    • toAmino(message): BasicAllowanceAmino

    • Parameters

      • message: BasicAllowance

      Returns BasicAllowanceAmino

  • toAminoMsg:function

    • toAminoMsg(message): BasicAllowanceAminoMsg

    • Parameters

      • message: BasicAllowance

      Returns BasicAllowanceAminoMsg

  • toProto:function

    • toProto(message): Uint8Array

    • Parameters

      • message: BasicAllowance

      Returns Uint8Array

  • toProtoMsg:function

    • toProtoMsg(message): BasicAllowanceProtoMsg

    • Parameters

      • message: BasicAllowance

      Returns BasicAllowanceProtoMsg

• FeeAllowanceI_FromAmino: ((content: AnyAmino) => Any)

  • • (content): Any

    • Parameters

      • content: AnyAmino

      Returns Any

• FeeAllowanceI_InterfaceDecoder: ((input: Uint8Array | BinaryReader) =>
      | Any
      | BasicAllowance
      | PeriodicAllowance
      | AllowedMsgAllowance)

  • • (input):
          | Any
          | BasicAllowance
          | PeriodicAllowance
          | AllowedMsgAllowance

    • Parameters

      • input: Uint8Array | BinaryReader

      Returns
          | Any
          | BasicAllowance
          | PeriodicAllowance
          | AllowedMsgAllowance

• FeeAllowanceI_ToAmino: ((content: Any) => AnyAmino)

  • • (content): AnyAmino

    • Parameters

      • content: Any

      Returns AnyAmino

• GenesisState: {
      typeUrl: string;
      decode(input: Uint8Array | BinaryReader, length?: number): GenesisState;
      encode(message: GenesisState, writer?: BinaryWriter): BinaryWriter;
      fromAmino(object: GenesisStateAmino): GenesisState;
      fromAminoMsg(object: GenesisStateAminoMsg): GenesisState;
      fromPartial(object: {
          allowances?: {
              allowance?:
                  | {
                      $typeUrl?: string;
                      typeUrl?: string;
                      value?: Uint8Array;
                  }
                  | {
                      $typeUrl?: "/cosmos.feegrant.v1beta1.BasicAllowance";
                      expiration?: Date;
                      spendLimit?: {
                          amount?: ...;
                          denom?: ...;
                      }[];
                  }
                  | {
                      $typeUrl?: "/cosmos.feegrant.v1beta1.PeriodicAllowance";
                      basic?: {
                          $typeUrl?: (...) | (...);
                          expiration?: (...) | (...);
                          spendLimit?: (...) | (...);
                      };
                      period?: {
                          nanos?: (...) | (...);
                          seconds?: (...) | (...);
                      };
                      periodCanSpend?: {
                          amount?: ...;
                          denom?: ...;
                      }[];
                      periodReset?: Date;
                      periodSpendLimit?: {
                          amount?: ...;
                          denom?: ...;
                      }[];
                  }
                  | {
                      $typeUrl?: "/cosmos.feegrant.v1beta1.AllowedMsgAllowance";
                      allowance?: { $typeUrl?: string | undefined; typeUrl?: string | undefined; value?: Uint8Array | undefined; } | { $typeUrl?: "/cosmos.feegrant.v1beta1.BasicAllowance" | undefined; spendLimit?: { ...; }[] | undefined; expiration?: Date | undefined; } | { ...; } | { ...; } | undefined;
                      allowedMessages?: string[];
                  };
              grantee?: string;
              granter?: string;
          }[];
      }): GenesisState;
      fromProtoMsg(message: GenesisStateProtoMsg): GenesisState;
      toAmino(message: GenesisState): GenesisStateAmino;
      toAminoMsg(message: GenesisState): GenesisStateAminoMsg;
      toProto(message: GenesisState): Uint8Array;
      toProtoMsg(message: GenesisState): GenesisStateProtoMsg;
  }

  • typeUrl: string

  • decode:function

    • decode(input, length?): GenesisState

    • Parameters

      • input: Uint8Array | BinaryReader
      • Optionallength: number

      Returns GenesisState

  • encode:function

    • encode(message, writer?): BinaryWriter

    • Parameters

      • message: GenesisState
      • writer: BinaryWriter = ...

      Returns BinaryWriter

  • fromAmino:function

    • fromAmino(object): GenesisState

    • Parameters

      • object: GenesisStateAmino

      Returns GenesisState

  • fromAminoMsg:function

    • fromAminoMsg(object): GenesisState

    • Parameters

      • object: GenesisStateAminoMsg

      Returns GenesisState

  • fromPartial:function

    • fromPartial(object): GenesisState

    • Parameters

      • object: {
            allowances?: {
                allowance?:
                    | {
                        $typeUrl?: string;
                        typeUrl?: string;
                        value?: Uint8Array;
                    }
                    | {
                        $typeUrl?: "/cosmos.feegrant.v1beta1.BasicAllowance";
                        expiration?: Date;
                        spendLimit?: {
                            amount?: ...;
                            denom?: ...;
                        }[];
                    }
                    | {
                        $typeUrl?: "/cosmos.feegrant.v1beta1.PeriodicAllowance";
                        basic?: {
                            $typeUrl?: (...) | (...);
                            expiration?: (...) | (...);
                            spendLimit?: (...) | (...);
                        };
                        period?: {
                            nanos?: (...) | (...);
                            seconds?: (...) | (...);
                        };
                        periodCanSpend?: {
                            amount?: ...;
                            denom?: ...;
                        }[];
                        periodReset?: Date;
                        periodSpendLimit?: {
                            amount?: ...;
                            denom?: ...;
                        }[];
                    }
                    | {
                        $typeUrl?: "/cosmos.feegrant.v1beta1.AllowedMsgAllowance";
                        allowance?: { $typeUrl?: string | undefined; typeUrl?: string | undefined; value?: Uint8Array | undefined; } | { $typeUrl?: "/cosmos.feegrant.v1beta1.BasicAllowance" | undefined; spendLimit?: { ...; }[] | undefined; expiration?: Date | undefined; } | { ...; } | { ...; } | undefined;
                        allowedMessages?: string[];
                    };
                grantee?: string;
                granter?: string;
            }[];
        }

        • Optionalallowances?: {
              allowance?:
                  | {
                      $typeUrl?: string;
                      typeUrl?: string;
                      value?: Uint8Array;
                  }
                  | {
                      $typeUrl?: "/cosmos.feegrant.v1beta1.BasicAllowance";
                      expiration?: Date;
                      spendLimit?: {
                          amount?: ...;
                          denom?: ...;
                      }[];
                  }
                  | {
                      $typeUrl?: "/cosmos.feegrant.v1beta1.PeriodicAllowance";
                      basic?: {
                          $typeUrl?: (...) | (...);
                          expiration?: (...) | (...);
                          spendLimit?: (...) | (...);
                      };
                      period?: {
                          nanos?: (...) | (...);
                          seconds?: (...) | (...);
                      };
                      periodCanSpend?: {
                          amount?: ...;
                          denom?: ...;
                      }[];
                      periodReset?: Date;
                      periodSpendLimit?: {
                          amount?: ...;
                          denom?: ...;
                      }[];
                  }
                  | {
                      $typeUrl?: "/cosmos.feegrant.v1beta1.AllowedMsgAllowance";
                      allowance?: { $typeUrl?: string | undefined; typeUrl?: string | undefined; value?: Uint8Array | undefined; } | { $typeUrl?: "/cosmos.feegrant.v1beta1.BasicAllowance" | undefined; spendLimit?: { ...; }[] | undefined; expiration?: Date | undefined; } | { ...; } | { ...; } | undefined;
                      allowedMessages?: string[];
                  };
              grantee?: string;
              granter?: string;
          }[]

      Returns GenesisState

  • fromProtoMsg:function

    • fromProtoMsg(message): GenesisState

    • Parameters

      • message: GenesisStateProtoMsg

      Returns GenesisState

  • toAmino:function

    • toAmino(message): GenesisStateAmino

    • Parameters

      • message: GenesisState

      Returns GenesisStateAmino

  • toAminoMsg:function

    • toAminoMsg(message): GenesisStateAminoMsg

    • Parameters

      • message: GenesisState

      Returns GenesisStateAminoMsg

  • toProto:function

    • toProto(message): Uint8Array

    • Parameters

      • message: GenesisState

      Returns Uint8Array

  • toProtoMsg:function

    • toProtoMsg(message): GenesisStateProtoMsg

    • Parameters

      • message: GenesisState

      Returns GenesisStateProtoMsg

• Grant: {
      typeUrl: string;
      decode(input: Uint8Array | BinaryReader, length?: number): Grant;
      encode(message: Grant, writer?: BinaryWriter): BinaryWriter;
      fromAmino(object: GrantAmino): Grant;
      fromAminoMsg(object: GrantAminoMsg): Grant;
      fromPartial(object: {
          allowance?:
              | {
                  $typeUrl?: string;
                  typeUrl?: string;
                  value?: Uint8Array;
              }
              | {
                  $typeUrl?: "/cosmos.feegrant.v1beta1.BasicAllowance";
                  expiration?: Date;
                  spendLimit?: {
                      amount?: string;
                      denom?: string;
                  }[];
              }
              | {
                  $typeUrl?: "/cosmos.feegrant.v1beta1.PeriodicAllowance";
                  basic?: {
                      $typeUrl?: "/cosmos.feegrant.v1beta1.BasicAllowance";
                      expiration?: Date;
                      spendLimit?: {
                          amount?: (...) | (...);
                          denom?: (...) | (...);
                      }[];
                  };
                  period?: {
                      nanos?: number;
                      seconds?: bigint;
                  };
                  periodCanSpend?: {
                      amount?: string;
                      denom?: string;
                  }[];
                  periodReset?: Date;
                  periodSpendLimit?: {
                      amount?: string;
                      denom?: string;
                  }[];
              }
              | {
                  $typeUrl?: "/cosmos.feegrant.v1beta1.AllowedMsgAllowance";
                  allowance?: { $typeUrl?: string | undefined; typeUrl?: string | undefined; value?: Uint8Array | undefined; } | { $typeUrl?: "/cosmos.feegrant.v1beta1.BasicAllowance" | undefined; spendLimit?: { ...; }[] | undefined; expiration?: Date | undefined; } | { ...; } | { ...; } | undefined;
                  allowedMessages?: string[];
              };
          grantee?: string;
          granter?: string;
      }): Grant;
      fromProtoMsg(message: GrantProtoMsg): Grant;
      toAmino(message: Grant): GrantAmino;
      toAminoMsg(message: Grant): GrantAminoMsg;
      toProto(message: Grant): Uint8Array;
      toProtoMsg(message: Grant): GrantProtoMsg;
  }

  • typeUrl: string

  • decode:function

    • decode(input, length?): Grant

    • Parameters

      • input: Uint8Array | BinaryReader
      • Optionallength: number

      Returns Grant

  • encode:function

    • encode(message, writer?): BinaryWriter

    • Parameters

      • message: Grant
      • writer: BinaryWriter = ...

      Returns BinaryWriter

  • fromAmino:function

    • fromAmino(object): Grant

    • Parameters

      • object: GrantAmino

      Returns Grant

  • fromAminoMsg:function

    • fromAminoMsg(object): Grant

    • Parameters

      • object: GrantAminoMsg

      Returns Grant

  • fromPartial:function

    • fromPartial(object): Grant

    • Parameters

      • object: {
            allowance?:
                | {
                    $typeUrl?: string;
                    typeUrl?: string;
                    value?: Uint8Array;
                }
                | {
                    $typeUrl?: "/cosmos.feegrant.v1beta1.BasicAllowance";
                    expiration?: Date;
                    spendLimit?: {
                        amount?: string;
                        denom?: string;
                    }[];
                }
                | {
                    $typeUrl?: "/cosmos.feegrant.v1beta1.PeriodicAllowance";
                    basic?: {
                        $typeUrl?: "/cosmos.feegrant.v1beta1.BasicAllowance";
                        expiration?: Date;
                        spendLimit?: {
                            amount?: (...) | (...);
                            denom?: (...) | (...);
                        }[];
                    };
                    period?: {
                        nanos?: number;
                        seconds?: bigint;
                    };
                    periodCanSpend?: {
                        amount?: string;
                        denom?: string;
                    }[];
                    periodReset?: Date;
                    periodSpendLimit?: {
                        amount?: string;
                        denom?: string;
                    }[];
                }
                | {
                    $typeUrl?: "/cosmos.feegrant.v1beta1.AllowedMsgAllowance";
                    allowance?: { $typeUrl?: string | undefined; typeUrl?: string | undefined; value?: Uint8Array | undefined; } | { $typeUrl?: "/cosmos.feegrant.v1beta1.BasicAllowance" | undefined; spendLimit?: { ...; }[] | undefined; expiration?: Date | undefined; } | { ...; } | { ...; } | undefined;
                    allowedMessages?: string[];
                };
            grantee?: string;
            granter?: string;
        }

        • Optionalallowance?:
              | {
                  $typeUrl?: string;
                  typeUrl?: string;
                  value?: Uint8Array;
              }
              | {
                  $typeUrl?: "/cosmos.feegrant.v1beta1.BasicAllowance";
                  expiration?: Date;
                  spendLimit?: {
                      amount?: string;
                      denom?: string;
                  }[];
              }
              | {
                  $typeUrl?: "/cosmos.feegrant.v1beta1.PeriodicAllowance";
                  basic?: {
                      $typeUrl?: "/cosmos.feegrant.v1beta1.BasicAllowance";
                      expiration?: Date;
                      spendLimit?: {
                          amount?: (...) | (...);
                          denom?: (...) | (...);
                      }[];
                  };
                  period?: {
                      nanos?: number;
                      seconds?: bigint;
                  };
                  periodCanSpend?: {
                      amount?: string;
                      denom?: string;
                  }[];
                  periodReset?: Date;
                  periodSpendLimit?: {
                      amount?: string;
                      denom?: string;
                  }[];
              }
              | {
                  $typeUrl?: "/cosmos.feegrant.v1beta1.AllowedMsgAllowance";
                  allowance?: { $typeUrl?: string | undefined; typeUrl?: string | undefined; value?: Uint8Array | undefined; } | { $typeUrl?: "/cosmos.feegrant.v1beta1.BasicAllowance" | undefined; spendLimit?: { ...; }[] | undefined; expiration?: Date | undefined; } | { ...; } | { ...; } | undefined;
                  allowedMessages?: string[];
              }

          allowance can be any of basic and filtered fee allowance.

        • Optionalgrantee?: string

          grantee is the address of the user being granted an allowance of another user's funds.

        • Optionalgranter?: string

          granter is the address of the user granting an allowance of their funds.

      Returns Grant

  • fromProtoMsg:function

    • fromProtoMsg(message): Grant

    • Parameters

      • message: GrantProtoMsg

      Returns Grant

  • toAmino:function

    • toAmino(message): GrantAmino

    • Parameters

      • message: Grant

      Returns GrantAmino

  • toAminoMsg:function

    • toAminoMsg(message): GrantAminoMsg

    • Parameters

      • message: Grant

      Returns GrantAminoMsg

  • toProto:function

    • toProto(message): Uint8Array

    • Parameters

      • message: Grant

      Returns Uint8Array

  • toProtoMsg:function

    • toProtoMsg(message): GrantProtoMsg

    • Parameters

      • message: Grant

      Returns GrantProtoMsg

• MessageComposer: {
      encoded: {
          grantAllowance(value: MsgGrantAllowance): {
              typeUrl: string;
              value: Uint8Array;
          };
          revokeAllowance(value: MsgRevokeAllowance): {
              typeUrl: string;
              value: Uint8Array;
          };
      };
      fromPartial: {
          grantAllowance(value: MsgGrantAllowance): {
              typeUrl: string;
              value: MsgGrantAllowance;
          };
          revokeAllowance(value: MsgRevokeAllowance): {
              typeUrl: string;
              value: MsgRevokeAllowance;
          };
      };
      withTypeUrl: {
          grantAllowance(value: MsgGrantAllowance): {
              typeUrl: string;
              value: MsgGrantAllowance;
          };
          revokeAllowance(value: MsgRevokeAllowance): {
              typeUrl: string;
              value: MsgRevokeAllowance;
          };
      };
  }

  • encoded: {
        grantAllowance(value: MsgGrantAllowance): {
            typeUrl: string;
            value: Uint8Array;
        };
        revokeAllowance(value: MsgRevokeAllowance): {
            typeUrl: string;
            value: Uint8Array;
        };
    }

    • grantAllowance:function

      • grantAllowance(value): {
            typeUrl: string;
            value: Uint8Array;
        }

      • Parameters

        • value: MsgGrantAllowance

        Returns {
            typeUrl: string;
            value: Uint8Array;
        }

        • typeUrl: string

        • value: Uint8Array

    • revokeAllowance:function

      • revokeAllowance(value): {
            typeUrl: string;
            value: Uint8Array;
        }

      • Parameters

        • value: MsgRevokeAllowance

        Returns {
            typeUrl: string;
            value: Uint8Array;
        }

        • typeUrl: string

        • value: Uint8Array

  • fromPartial: {
        grantAllowance(value: MsgGrantAllowance): {
            typeUrl: string;
            value: MsgGrantAllowance;
        };
        revokeAllowance(value: MsgRevokeAllowance): {
            typeUrl: string;
            value: MsgRevokeAllowance;
        };
    }

    • grantAllowance:function

      • grantAllowance(value): {
            typeUrl: string;
            value: MsgGrantAllowance;
        }

      • Parameters

        • value: MsgGrantAllowance

        Returns {
            typeUrl: string;
            value: MsgGrantAllowance;
        }

        • typeUrl: string

        • value: MsgGrantAllowance

    • revokeAllowance:function

      • revokeAllowance(value): {
            typeUrl: string;
            value: MsgRevokeAllowance;
        }

      • Parameters

        • value: MsgRevokeAllowance

        Returns {
            typeUrl: string;
            value: MsgRevokeAllowance;
        }

        • typeUrl: string

        • value: MsgRevokeAllowance

  • withTypeUrl: {
        grantAllowance(value: MsgGrantAllowance): {
            typeUrl: string;
            value: MsgGrantAllowance;
        };
        revokeAllowance(value: MsgRevokeAllowance): {
            typeUrl: string;
            value: MsgRevokeAllowance;
        };
    }

    • grantAllowance:function

      • grantAllowance(value): {
            typeUrl: string;
            value: MsgGrantAllowance;
        }

      • Parameters

        • value: MsgGrantAllowance

        Returns {
            typeUrl: string;
            value: MsgGrantAllowance;
        }

        • typeUrl: string

        • value: MsgGrantAllowance

    • revokeAllowance:function

      • revokeAllowance(value): {
            typeUrl: string;
            value: MsgRevokeAllowance;
        }

      • Parameters

        • value: MsgRevokeAllowance

        Returns {
            typeUrl: string;
            value: MsgRevokeAllowance;
        }

        • typeUrl: string

        • value: MsgRevokeAllowance

• MsgGrantAllowance: {
      typeUrl: string;
      decode(input: Uint8Array | BinaryReader, length?: number): MsgGrantAllowance;
      encode(message: MsgGrantAllowance, writer?: BinaryWriter): BinaryWriter;
      fromAmino(object: MsgGrantAllowanceAmino): MsgGrantAllowance;
      fromAminoMsg(object: MsgGrantAllowanceAminoMsg): MsgGrantAllowance;
      fromPartial(object: {
          allowance?:
              | {
                  $typeUrl?: string;
                  typeUrl?: string;
                  value?: Uint8Array;
              }
              | {
                  $typeUrl?: "/cosmos.feegrant.v1beta1.BasicAllowance";
                  expiration?: Date;
                  spendLimit?: {
                      amount?: string;
                      denom?: string;
                  }[];
              }
              | {
                  $typeUrl?: "/cosmos.feegrant.v1beta1.PeriodicAllowance";
                  basic?: {
                      $typeUrl?: "/cosmos.feegrant.v1beta1.BasicAllowance";
                      expiration?: Date;
                      spendLimit?: {
                          amount?: (...) | (...);
                          denom?: (...) | (...);
                      }[];
                  };
                  period?: {
                      nanos?: number;
                      seconds?: bigint;
                  };
                  periodCanSpend?: {
                      amount?: string;
                      denom?: string;
                  }[];
                  periodReset?: Date;
                  periodSpendLimit?: {
                      amount?: string;
                      denom?: string;
                  }[];
              }
              | {
                  $typeUrl?: "/cosmos.feegrant.v1beta1.AllowedMsgAllowance";
                  allowance?: { $typeUrl?: string | undefined; typeUrl?: string | undefined; value?: Uint8Array | undefined; } | { $typeUrl?: "/cosmos.feegrant.v1beta1.BasicAllowance" | undefined; spendLimit?: { ...; }[] | undefined; expiration?: Date | undefined; } | { ...; } | { ...; } | undefined;
                  allowedMessages?: string[];
              };
          grantee?: string;
          granter?: string;
      }): MsgGrantAllowance;
      fromProtoMsg(message: MsgGrantAllowanceProtoMsg): MsgGrantAllowance;
      toAmino(message: MsgGrantAllowance): MsgGrantAllowanceAmino;
      toAminoMsg(message: MsgGrantAllowance): MsgGrantAllowanceAminoMsg;
      toProto(message: MsgGrantAllowance): Uint8Array;
      toProtoMsg(message: MsgGrantAllowance): MsgGrantAllowanceProtoMsg;
  }

  • typeUrl: string

  • decode:function

    • decode(input, length?): MsgGrantAllowance

    • Parameters

      • input: Uint8Array | BinaryReader
      • Optionallength: number

      Returns MsgGrantAllowance

  • encode:function

    • encode(message, writer?): BinaryWriter

    • Parameters

      • message: MsgGrantAllowance
      • writer: BinaryWriter = ...

      Returns BinaryWriter

  • fromAmino:function

    • fromAmino(object): MsgGrantAllowance

    • Parameters

      • object: MsgGrantAllowanceAmino

      Returns MsgGrantAllowance

  • fromAminoMsg:function

    • fromAminoMsg(object): MsgGrantAllowance

    • Parameters

      • object: MsgGrantAllowanceAminoMsg

      Returns MsgGrantAllowance

  • fromPartial:function

    • fromPartial(object): MsgGrantAllowance

    • Parameters

      • object: {
            allowance?:
                | {
                    $typeUrl?: string;
                    typeUrl?: string;
                    value?: Uint8Array;
                }
                | {
                    $typeUrl?: "/cosmos.feegrant.v1beta1.BasicAllowance";
                    expiration?: Date;
                    spendLimit?: {
                        amount?: string;
                        denom?: string;
                    }[];
                }
                | {
                    $typeUrl?: "/cosmos.feegrant.v1beta1.PeriodicAllowance";
                    basic?: {
                        $typeUrl?: "/cosmos.feegrant.v1beta1.BasicAllowance";
                        expiration?: Date;
                        spendLimit?: {
                            amount?: (...) | (...);
                            denom?: (...) | (...);
                        }[];
                    };
                    period?: {
                        nanos?: number;
                        seconds?: bigint;
                    };
                    periodCanSpend?: {
                        amount?: string;
                        denom?: string;
                    }[];
                    periodReset?: Date;
                    periodSpendLimit?: {
                        amount?: string;
                        denom?: string;
                    }[];
                }
                | {
                    $typeUrl?: "/cosmos.feegrant.v1beta1.AllowedMsgAllowance";
                    allowance?: { $typeUrl?: string | undefined; typeUrl?: string | undefined; value?: Uint8Array | undefined; } | { $typeUrl?: "/cosmos.feegrant.v1beta1.BasicAllowance" | undefined; spendLimit?: { ...; }[] | undefined; expiration?: Date | undefined; } | { ...; } | { ...; } | undefined;
                    allowedMessages?: string[];
                };
            grantee?: string;
            granter?: string;
        }

        • Optionalallowance?:
              | {
                  $typeUrl?: string;
                  typeUrl?: string;
                  value?: Uint8Array;
              }
              | {
                  $typeUrl?: "/cosmos.feegrant.v1beta1.BasicAllowance";
                  expiration?: Date;
                  spendLimit?: {
                      amount?: string;
                      denom?: string;
                  }[];
              }
              | {
                  $typeUrl?: "/cosmos.feegrant.v1beta1.PeriodicAllowance";
                  basic?: {
                      $typeUrl?: "/cosmos.feegrant.v1beta1.BasicAllowance";
                      expiration?: Date;
                      spendLimit?: {
                          amount?: (...) | (...);
                          denom?: (...) | (...);
                      }[];
                  };
                  period?: {
                      nanos?: number;
                      seconds?: bigint;
                  };
                  periodCanSpend?: {
                      amount?: string;
                      denom?: string;
                  }[];
                  periodReset?: Date;
                  periodSpendLimit?: {
                      amount?: string;
                      denom?: string;
                  }[];
              }
              | {
                  $typeUrl?: "/cosmos.feegrant.v1beta1.AllowedMsgAllowance";
                  allowance?: { $typeUrl?: string | undefined; typeUrl?: string | undefined; value?: Uint8Array | undefined; } | { $typeUrl?: "/cosmos.feegrant.v1beta1.BasicAllowance" | undefined; spendLimit?: { ...; }[] | undefined; expiration?: Date | undefined; } | { ...; } | { ...; } | undefined;
                  allowedMessages?: string[];
              }

          allowance can be any of basic and filtered fee allowance.

        • Optionalgrantee?: string

          grantee is the address of the user being granted an allowance of another user's funds.

        • Optionalgranter?: string

          granter is the address of the user granting an allowance of their funds.

      Returns MsgGrantAllowance

  • fromProtoMsg:function

    • fromProtoMsg(message): MsgGrantAllowance

    • Parameters

      • message: MsgGrantAllowanceProtoMsg

      Returns MsgGrantAllowance

  • toAmino:function

    • toAmino(message): MsgGrantAllowanceAmino

    • Parameters

      • message: MsgGrantAllowance

      Returns MsgGrantAllowanceAmino

  • toAminoMsg:function

    • toAminoMsg(message): MsgGrantAllowanceAminoMsg

    • Parameters

      • message: MsgGrantAllowance

      Returns MsgGrantAllowanceAminoMsg

  • toProto:function

    • toProto(message): Uint8Array

    • Parameters

      • message: MsgGrantAllowance

      Returns Uint8Array

  • toProtoMsg:function

    • toProtoMsg(message): MsgGrantAllowanceProtoMsg

    • Parameters

      • message: MsgGrantAllowance

      Returns MsgGrantAllowanceProtoMsg

• MsgGrantAllowanceResponse: {
      typeUrl: string;
      decode(input: Uint8Array | BinaryReader, length?: number): MsgGrantAllowanceResponse;
      encode(_: MsgGrantAllowanceResponse, writer?: BinaryWriter): BinaryWriter;
      fromAmino(_: MsgGrantAllowanceResponseAmino): MsgGrantAllowanceResponse;
      fromAminoMsg(object: MsgGrantAllowanceResponseAminoMsg): MsgGrantAllowanceResponse;
      fromPartial(_: {}): MsgGrantAllowanceResponse;
      fromProtoMsg(message: MsgGrantAllowanceResponseProtoMsg): MsgGrantAllowanceResponse;
      toAmino(_: MsgGrantAllowanceResponse): MsgGrantAllowanceResponseAmino;
      toAminoMsg(message: MsgGrantAllowanceResponse): MsgGrantAllowanceResponseAminoMsg;
      toProto(message: MsgGrantAllowanceResponse): Uint8Array;
      toProtoMsg(message: MsgGrantAllowanceResponse): MsgGrantAllowanceResponseProtoMsg;
  }

  • typeUrl: string

  • decode:function

    • decode(input, length?): MsgGrantAllowanceResponse

    • Parameters

      • input: Uint8Array | BinaryReader
      • Optionallength: number

      Returns MsgGrantAllowanceResponse

  • encode:function

    • encode(_, writer?): BinaryWriter

    • Parameters

      • _: MsgGrantAllowanceResponse
      • writer: BinaryWriter = ...

      Returns BinaryWriter

  • fromAmino:function

    • fromAmino(_): MsgGrantAllowanceResponse

    • Parameters

      • _: MsgGrantAllowanceResponseAmino

      Returns MsgGrantAllowanceResponse

  • fromAminoMsg:function

    • fromAminoMsg(object): MsgGrantAllowanceResponse

    • Parameters

      • object: MsgGrantAllowanceResponseAminoMsg

      Returns MsgGrantAllowanceResponse

  • fromPartial:function

    • fromPartial(_): MsgGrantAllowanceResponse

    • Parameters

      • _: {}

      Returns MsgGrantAllowanceResponse

  • fromProtoMsg:function

    • fromProtoMsg(message): MsgGrantAllowanceResponse

    • Parameters

      • message: MsgGrantAllowanceResponseProtoMsg

      Returns MsgGrantAllowanceResponse

  • toAmino:function

    • toAmino(_): MsgGrantAllowanceResponseAmino

    • Parameters

      • _: MsgGrantAllowanceResponse

      Returns MsgGrantAllowanceResponseAmino

  • toAminoMsg:function

    • toAminoMsg(message): MsgGrantAllowanceResponseAminoMsg

    • Parameters

      • message: MsgGrantAllowanceResponse

      Returns MsgGrantAllowanceResponseAminoMsg

  • toProto:function

    • toProto(message): Uint8Array

    • Parameters

      • message: MsgGrantAllowanceResponse

      Returns Uint8Array

  • toProtoMsg:function

    • toProtoMsg(message): MsgGrantAllowanceResponseProtoMsg

    • Parameters

      • message: MsgGrantAllowanceResponse

      Returns MsgGrantAllowanceResponseProtoMsg

• MsgRevokeAllowance: {
      typeUrl: string;
      decode(input: Uint8Array | BinaryReader, length?: number): MsgRevokeAllowance;
      encode(message: MsgRevokeAllowance, writer?: BinaryWriter): BinaryWriter;
      fromAmino(object: MsgRevokeAllowanceAmino): MsgRevokeAllowance;
      fromAminoMsg(object: MsgRevokeAllowanceAminoMsg): MsgRevokeAllowance;
      fromPartial(object: {
          grantee?: string;
          granter?: string;
      }): MsgRevokeAllowance;
      fromProtoMsg(message: MsgRevokeAllowanceProtoMsg): MsgRevokeAllowance;
      toAmino(message: MsgRevokeAllowance): MsgRevokeAllowanceAmino;
      toAminoMsg(message: MsgRevokeAllowance): MsgRevokeAllowanceAminoMsg;
      toProto(message: MsgRevokeAllowance): Uint8Array;
      toProtoMsg(message: MsgRevokeAllowance): MsgRevokeAllowanceProtoMsg;
  }

  • typeUrl: string

  • decode:function

    • decode(input, length?): MsgRevokeAllowance

    • Parameters

      • input: Uint8Array | BinaryReader
      • Optionallength: number

      Returns MsgRevokeAllowance

  • encode:function

    • encode(message, writer?): BinaryWriter

    • Parameters

      • message: MsgRevokeAllowance
      • writer: BinaryWriter = ...

      Returns BinaryWriter

  • fromAmino:function

    • fromAmino(object): MsgRevokeAllowance

    • Parameters

      • object: MsgRevokeAllowanceAmino

      Returns MsgRevokeAllowance

  • fromAminoMsg:function

    • fromAminoMsg(object): MsgRevokeAllowance

    • Parameters

      • object: MsgRevokeAllowanceAminoMsg

      Returns MsgRevokeAllowance

  • fromPartial:function

    • fromPartial(object): MsgRevokeAllowance

    • Parameters

      • object: {
            grantee?: string;
            granter?: string;
        }

        • Optionalgrantee?: string

          grantee is the address of the user being granted an allowance of another user's funds.

        • Optionalgranter?: string

          granter is the address of the user granting an allowance of their funds.

      Returns MsgRevokeAllowance

  • fromProtoMsg:function

    • fromProtoMsg(message): MsgRevokeAllowance

    • Parameters

      • message: MsgRevokeAllowanceProtoMsg

      Returns MsgRevokeAllowance

  • toAmino:function

    • toAmino(message): MsgRevokeAllowanceAmino

    • Parameters

      • message: MsgRevokeAllowance

      Returns MsgRevokeAllowanceAmino

  • toAminoMsg:function

    • toAminoMsg(message): MsgRevokeAllowanceAminoMsg

    • Parameters

      • message: MsgRevokeAllowance

      Returns MsgRevokeAllowanceAminoMsg

  • toProto:function

    • toProto(message): Uint8Array

    • Parameters

      • message: MsgRevokeAllowance

      Returns Uint8Array

  • toProtoMsg:function

    • toProtoMsg(message): MsgRevokeAllowanceProtoMsg

    • Parameters

      • message: MsgRevokeAllowance

      Returns MsgRevokeAllowanceProtoMsg

• MsgRevokeAllowanceResponse: {
      typeUrl: string;
      decode(input: Uint8Array | BinaryReader, length?: number): MsgRevokeAllowanceResponse;
      encode(_: MsgRevokeAllowanceResponse, writer?: BinaryWriter): BinaryWriter;
      fromAmino(_: MsgRevokeAllowanceResponseAmino): MsgRevokeAllowanceResponse;
      fromAminoMsg(object: MsgRevokeAllowanceResponseAminoMsg): MsgRevokeAllowanceResponse;
      fromPartial(_: {}): MsgRevokeAllowanceResponse;
      fromProtoMsg(message: MsgRevokeAllowanceResponseProtoMsg): MsgRevokeAllowanceResponse;
      toAmino(_: MsgRevokeAllowanceResponse): MsgRevokeAllowanceResponseAmino;
      toAminoMsg(message: MsgRevokeAllowanceResponse): MsgRevokeAllowanceResponseAminoMsg;
      toProto(message: MsgRevokeAllowanceResponse): Uint8Array;
      toProtoMsg(message: MsgRevokeAllowanceResponse): MsgRevokeAllowanceResponseProtoMsg;
  }

  • typeUrl: string

  • decode:function

    • decode(input, length?): MsgRevokeAllowanceResponse

    • Parameters

      • input: Uint8Array | BinaryReader
      • Optionallength: number

      Returns MsgRevokeAllowanceResponse

  • encode:function

    • encode(_, writer?): BinaryWriter

    • Parameters

      • _: MsgRevokeAllowanceResponse
      • writer: BinaryWriter = ...

      Returns BinaryWriter

  • fromAmino:function

    • fromAmino(_): MsgRevokeAllowanceResponse

    • Parameters

      • _: MsgRevokeAllowanceResponseAmino

      Returns MsgRevokeAllowanceResponse

  • fromAminoMsg:function

    • fromAminoMsg(object): MsgRevokeAllowanceResponse

    • Parameters

      • object: MsgRevokeAllowanceResponseAminoMsg

      Returns MsgRevokeAllowanceResponse

  • fromPartial:function

    • fromPartial(_): MsgRevokeAllowanceResponse

    • Parameters

      • _: {}

      Returns MsgRevokeAllowanceResponse

  • fromProtoMsg:function

    • fromProtoMsg(message): MsgRevokeAllowanceResponse

    • Parameters

      • message: MsgRevokeAllowanceResponseProtoMsg

      Returns MsgRevokeAllowanceResponse

  • toAmino:function

    • toAmino(_): MsgRevokeAllowanceResponseAmino

    • Parameters

      • _: MsgRevokeAllowanceResponse

      Returns MsgRevokeAllowanceResponseAmino

  • toAminoMsg:function

    • toAminoMsg(message): MsgRevokeAllowanceResponseAminoMsg

    • Parameters

      • message: MsgRevokeAllowanceResponse

      Returns MsgRevokeAllowanceResponseAminoMsg

  • toProto:function

    • toProto(message): Uint8Array

    • Parameters

      • message: MsgRevokeAllowanceResponse

      Returns Uint8Array

  • toProtoMsg:function

    • toProtoMsg(message): MsgRevokeAllowanceResponseProtoMsg

    • Parameters

      • message: MsgRevokeAllowanceResponse

      Returns MsgRevokeAllowanceResponseProtoMsg

• PeriodicAllowance: {
      typeUrl: string;
      decode(input: Uint8Array | BinaryReader, length?: number): PeriodicAllowance;
      encode(message: PeriodicAllowance, writer?: BinaryWriter): BinaryWriter;
      fromAmino(object: PeriodicAllowanceAmino): PeriodicAllowance;
      fromAminoMsg(object: PeriodicAllowanceAminoMsg): PeriodicAllowance;
      fromPartial(object: {
          $typeUrl?: "/cosmos.feegrant.v1beta1.PeriodicAllowance";
          basic?: {
              $typeUrl?: "/cosmos.feegrant.v1beta1.BasicAllowance";
              expiration?: Date;
              spendLimit?: {
                  amount?: string;
                  denom?: string;
              }[];
          };
          period?: {
              nanos?: number;
              seconds?: bigint;
          };
          periodCanSpend?: {
              amount?: string;
              denom?: string;
          }[];
          periodReset?: Date;
          periodSpendLimit?: {
              amount?: string;
              denom?: string;
          }[];
      }): PeriodicAllowance;
      fromProtoMsg(message: PeriodicAllowanceProtoMsg): PeriodicAllowance;
      toAmino(message: PeriodicAllowance): PeriodicAllowanceAmino;
      toAminoMsg(message: PeriodicAllowance): PeriodicAllowanceAminoMsg;
      toProto(message: PeriodicAllowance): Uint8Array;
      toProtoMsg(message: PeriodicAllowance): PeriodicAllowanceProtoMsg;
  }

  • typeUrl: string

  • decode:function

    • decode(input, length?): PeriodicAllowance

    • Parameters

      • input: Uint8Array | BinaryReader
      • Optionallength: number

      Returns PeriodicAllowance

  • encode:function

    • encode(message, writer?): BinaryWriter

    • Parameters

      • message: PeriodicAllowance
      • writer: BinaryWriter = ...

      Returns BinaryWriter

  • fromAmino:function

    • fromAmino(object): PeriodicAllowance

    • Parameters

      • object: PeriodicAllowanceAmino

      Returns PeriodicAllowance

  • fromAminoMsg:function

    • fromAminoMsg(object): PeriodicAllowance

    • Parameters

      • object: PeriodicAllowanceAminoMsg

      Returns PeriodicAllowance

  • fromPartial:function

    • fromPartial(object): PeriodicAllowance

    • Parameters

      • object: {
            $typeUrl?: "/cosmos.feegrant.v1beta1.PeriodicAllowance";
            basic?: {
                $typeUrl?: "/cosmos.feegrant.v1beta1.BasicAllowance";
                expiration?: Date;
                spendLimit?: {
                    amount?: string;
                    denom?: string;
                }[];
            };
            period?: {
                nanos?: number;
                seconds?: bigint;
            };
            periodCanSpend?: {
                amount?: string;
                denom?: string;
            }[];
            periodReset?: Date;
            periodSpendLimit?: {
                amount?: string;
                denom?: string;
            }[];
        }

        • Optional$typeUrl?: "/cosmos.feegrant.v1beta1.PeriodicAllowance"

        • Optionalbasic?: {
              $typeUrl?: "/cosmos.feegrant.v1beta1.BasicAllowance";
              expiration?: Date;
              spendLimit?: {
                  amount?: string;
                  denom?: string;
              }[];
          }

          basic specifies a struct of BasicAllowance

          • Optional$typeUrl?: "/cosmos.feegrant.v1beta1.BasicAllowance"

          • Optionalexpiration?: Date

            expiration specifies an optional time when this allowance expires

          • OptionalspendLimit?: {
                amount?: string;
                denom?: string;
            }[]

            spend_limit specifies the maximum amount of tokens that can be spent by this allowance and will be updated as tokens are spent. If it is empty, there is no spend limit and any amount of coins can be spent.

        • Optionalperiod?: {
              nanos?: number;
              seconds?: bigint;
          }

          period specifies the time duration in which period_spend_limit coins can be spent before that allowance is reset

          • Optionalnanos?: number

            Signed fractions of a second at nanosecond resolution of the span of time. Durations less than one second are represented with a 0 seconds field and a positive or negative nanos field. For durations of one second or more, a non-zero value for the nanos field must be of the same sign as the seconds field. Must be from -999,999,999 to +999,999,999 inclusive.

          • Optionalseconds?: bigint

            Signed seconds of the span of time. Must be from -315,576,000,000 to +315,576,000,000 inclusive. Note: these bounds are computed from: 60 sec/min * 60 min/hr * 24 hr/day * 365.25 days/year * 10000 years

        • OptionalperiodCanSpend?: {
              amount?: string;
              denom?: string;
          }[]

          period_can_spend is the number of coins left to be spent before the period_reset time

        • OptionalperiodReset?: Date

          period_reset is the time at which this period resets and a new one begins, it is calculated from the start time of the first transaction after the last period ended

        • OptionalperiodSpendLimit?: {
              amount?: string;
              denom?: string;
          }[]

          period_spend_limit specifies the maximum number of coins that can be spent in the period

      Returns PeriodicAllowance

  • fromProtoMsg:function

    • fromProtoMsg(message): PeriodicAllowance

    • Parameters

      • message: PeriodicAllowanceProtoMsg

      Returns PeriodicAllowance

  • toAmino:function

    • toAmino(message): PeriodicAllowanceAmino

    • Parameters

      • message: PeriodicAllowance

      Returns PeriodicAllowanceAmino

  • toAminoMsg:function

    • toAminoMsg(message): PeriodicAllowanceAminoMsg

    • Parameters

      • message: PeriodicAllowance

      Returns PeriodicAllowanceAminoMsg

  • toProto:function

    • toProto(message): Uint8Array

    • Parameters

      • message: PeriodicAllowance

      Returns Uint8Array

  • toProtoMsg:function

    • toProtoMsg(message): PeriodicAllowanceProtoMsg

    • Parameters

      • message: PeriodicAllowance

      Returns PeriodicAllowanceProtoMsg

• QueryAllowanceRequest: {
      typeUrl: string;
      decode(input: Uint8Array | BinaryReader, length?: number): QueryAllowanceRequest;
      encode(message: QueryAllowanceRequest, writer?: BinaryWriter): BinaryWriter;
      fromAmino(object: QueryAllowanceRequestAmino): QueryAllowanceRequest;
      fromAminoMsg(object: QueryAllowanceRequestAminoMsg): QueryAllowanceRequest;
      fromPartial(object: {
          grantee?: string;
          granter?: string;
      }): QueryAllowanceRequest;
      fromProtoMsg(message: QueryAllowanceRequestProtoMsg): QueryAllowanceRequest;
      toAmino(message: QueryAllowanceRequest): QueryAllowanceRequestAmino;
      toAminoMsg(message: QueryAllowanceRequest): QueryAllowanceRequestAminoMsg;
      toProto(message: QueryAllowanceRequest): Uint8Array;
      toProtoMsg(message: QueryAllowanceRequest): QueryAllowanceRequestProtoMsg;
  }

  • typeUrl: string

  • decode:function

    • decode(input, length?): QueryAllowanceRequest

    • Parameters

      • input: Uint8Array | BinaryReader
      • Optionallength: number

      Returns QueryAllowanceRequest

  • encode:function

    • encode(message, writer?): BinaryWriter

    • Parameters

      • message: QueryAllowanceRequest
      • writer: BinaryWriter = ...

      Returns BinaryWriter

  • fromAmino:function

    • fromAmino(object): QueryAllowanceRequest

    • Parameters

      • object: QueryAllowanceRequestAmino

      Returns QueryAllowanceRequest

  • fromAminoMsg:function

    • fromAminoMsg(object): QueryAllowanceRequest

    • Parameters

      • object: QueryAllowanceRequestAminoMsg

      Returns QueryAllowanceRequest

  • fromPartial:function

    • fromPartial(object): QueryAllowanceRequest

    • Parameters

      • object: {
            grantee?: string;
            granter?: string;
        }

        • Optionalgrantee?: string

          grantee is the address of the user being granted an allowance of another user's funds.

        • Optionalgranter?: string

          granter is the address of the user granting an allowance of their funds.

      Returns QueryAllowanceRequest

  • fromProtoMsg:function

    • fromProtoMsg(message): QueryAllowanceRequest

    • Parameters

      • message: QueryAllowanceRequestProtoMsg

      Returns QueryAllowanceRequest

  • toAmino:function

    • toAmino(message): QueryAllowanceRequestAmino

    • Parameters

      • message: QueryAllowanceRequest

      Returns QueryAllowanceRequestAmino

  • toAminoMsg:function

    • toAminoMsg(message): QueryAllowanceRequestAminoMsg

    • Parameters

      • message: QueryAllowanceRequest

      Returns QueryAllowanceRequestAminoMsg

  • toProto:function

    • toProto(message): Uint8Array

    • Parameters

      • message: QueryAllowanceRequest

      Returns Uint8Array

  • toProtoMsg:function

    • toProtoMsg(message): QueryAllowanceRequestProtoMsg

    • Parameters

      • message: QueryAllowanceRequest

      Returns QueryAllowanceRequestProtoMsg

• QueryAllowanceResponse: {
      typeUrl: string;
      decode(input: Uint8Array | BinaryReader, length?: number): QueryAllowanceResponse;
      encode(message: QueryAllowanceResponse, writer?: BinaryWriter): BinaryWriter;
      fromAmino(object: QueryAllowanceResponseAmino): QueryAllowanceResponse;
      fromAminoMsg(object: QueryAllowanceResponseAminoMsg): QueryAllowanceResponse;
      fromPartial(object: {
          allowance?: {
              allowance?:
                  | {
                      $typeUrl?: string;
                      typeUrl?: string;
                      value?: Uint8Array;
                  }
                  | {
                      $typeUrl?: "/cosmos.feegrant.v1beta1.BasicAllowance";
                      expiration?: Date;
                      spendLimit?: {
                          amount?: (...) | (...);
                          denom?: (...) | (...);
                      }[];
                  }
                  | {
                      $typeUrl?: "/cosmos.feegrant.v1beta1.PeriodicAllowance";
                      basic?: {
                          $typeUrl?: "/cosmos.feegrant.v1beta1.BasicAllowance";
                          expiration?: Date;
                          spendLimit?: (...)[];
                      };
                      period?: {
                          nanos?: number;
                          seconds?: bigint;
                      };
                      periodCanSpend?: {
                          amount?: (...) | (...);
                          denom?: (...) | (...);
                      }[];
                      periodReset?: Date;
                      periodSpendLimit?: {
                          amount?: (...) | (...);
                          denom?: (...) | (...);
                      }[];
                  }
                  | {
                      $typeUrl?: "/cosmos.feegrant.v1beta1.AllowedMsgAllowance";
                      allowance?: { $typeUrl?: string | undefined; typeUrl?: string | undefined; value?: Uint8Array | undefined; } | { $typeUrl?: "/cosmos.feegrant.v1beta1.BasicAllowance" | undefined; spendLimit?: { ...; }[] | undefined; expiration?: Date | undefined; } | { ...; } | { ...; } | undefined;
                      allowedMessages?: string[];
                  };
              grantee?: string;
              granter?: string;
          };
      }): QueryAllowanceResponse;
      fromProtoMsg(message: QueryAllowanceResponseProtoMsg): QueryAllowanceResponse;
      toAmino(message: QueryAllowanceResponse): QueryAllowanceResponseAmino;
      toAminoMsg(message: QueryAllowanceResponse): QueryAllowanceResponseAminoMsg;
      toProto(message: QueryAllowanceResponse): Uint8Array;
      toProtoMsg(message: QueryAllowanceResponse): QueryAllowanceResponseProtoMsg;
  }

  • typeUrl: string

  • decode:function

    • decode(input, length?): QueryAllowanceResponse

    • Parameters

      • input: Uint8Array | BinaryReader
      • Optionallength: number

      Returns QueryAllowanceResponse

  • encode:function

    • encode(message, writer?): BinaryWriter

    • Parameters

      • message: QueryAllowanceResponse
      • writer: BinaryWriter = ...

      Returns BinaryWriter

  • fromAmino:function

    • fromAmino(object): QueryAllowanceResponse

    • Parameters

      • object: QueryAllowanceResponseAmino

      Returns QueryAllowanceResponse

  • fromAminoMsg:function

    • fromAminoMsg(object): QueryAllowanceResponse

    • Parameters

      • object: QueryAllowanceResponseAminoMsg

      Returns QueryAllowanceResponse

  • fromPartial:function

    • fromPartial(object): QueryAllowanceResponse

    • Parameters

      • object: {
            allowance?: {
                allowance?:
                    | {
                        $typeUrl?: string;
                        typeUrl?: string;
                        value?: Uint8Array;
                    }
                    | {
                        $typeUrl?: "/cosmos.feegrant.v1beta1.BasicAllowance";
                        expiration?: Date;
                        spendLimit?: {
                            amount?: (...) | (...);
                            denom?: (...) | (...);
                        }[];
                    }
                    | {
                        $typeUrl?: "/cosmos.feegrant.v1beta1.PeriodicAllowance";
                        basic?: {
                            $typeUrl?: "/cosmos.feegrant.v1beta1.BasicAllowance";
                            expiration?: Date;
                            spendLimit?: (...)[];
                        };
                        period?: {
                            nanos?: number;
                            seconds?: bigint;
                        };
                        periodCanSpend?: {
                            amount?: (...) | (...);
                            denom?: (...) | (...);
                        }[];
                        periodReset?: Date;
                        periodSpendLimit?: {
                            amount?: (...) | (...);
                            denom?: (...) | (...);
                        }[];
                    }
                    | {
                        $typeUrl?: "/cosmos.feegrant.v1beta1.AllowedMsgAllowance";
                        allowance?: { $typeUrl?: string | undefined; typeUrl?: string | undefined; value?: Uint8Array | undefined; } | { $typeUrl?: "/cosmos.feegrant.v1beta1.BasicAllowance" | undefined; spendLimit?: { ...; }[] | undefined; expiration?: Date | undefined; } | { ...; } | { ...; } | undefined;
                        allowedMessages?: string[];
                    };
                grantee?: string;
                granter?: string;
            };
        }

        • Optionalallowance?: {
              allowance?:
                  | {
                      $typeUrl?: string;
                      typeUrl?: string;
                      value?: Uint8Array;
                  }
                  | {
                      $typeUrl?: "/cosmos.feegrant.v1beta1.BasicAllowance";
                      expiration?: Date;
                      spendLimit?: {
                          amount?: (...) | (...);
                          denom?: (...) | (...);
                      }[];
                  }
                  | {
                      $typeUrl?: "/cosmos.feegrant.v1beta1.PeriodicAllowance";
                      basic?: {
                          $typeUrl?: "/cosmos.feegrant.v1beta1.BasicAllowance";
                          expiration?: Date;
                          spendLimit?: (...)[];
                      };
                      period?: {
                          nanos?: number;
                          seconds?: bigint;
                      };
                      periodCanSpend?: {
                          amount?: (...) | (...);
                          denom?: (...) | (...);
                      }[];
                      periodReset?: Date;
                      periodSpendLimit?: {
                          amount?: (...) | (...);
                          denom?: (...) | (...);
                      }[];
                  }
                  | {
                      $typeUrl?: "/cosmos.feegrant.v1beta1.AllowedMsgAllowance";
                      allowance?: { $typeUrl?: string | undefined; typeUrl?: string | undefined; value?: Uint8Array | undefined; } | { $typeUrl?: "/cosmos.feegrant.v1beta1.BasicAllowance" | undefined; spendLimit?: { ...; }[] | undefined; expiration?: Date | undefined; } | { ...; } | { ...; } | undefined;
                      allowedMessages?: string[];
                  };
              grantee?: string;
              granter?: string;
          }

          allowance is a allowance granted for grantee by granter.

          • Optionalallowance?:
                | {
                    $typeUrl?: string;
                    typeUrl?: string;
                    value?: Uint8Array;
                }
                | {
                    $typeUrl?: "/cosmos.feegrant.v1beta1.BasicAllowance";
                    expiration?: Date;
                    spendLimit?: {
                        amount?: (...) | (...);
                        denom?: (...) | (...);
                    }[];
                }
                | {
                    $typeUrl?: "/cosmos.feegrant.v1beta1.PeriodicAllowance";
                    basic?: {
                        $typeUrl?: "/cosmos.feegrant.v1beta1.BasicAllowance";
                        expiration?: Date;
                        spendLimit?: (...)[];
                    };
                    period?: {
                        nanos?: number;
                        seconds?: bigint;
                    };
                    periodCanSpend?: {
                        amount?: (...) | (...);
                        denom?: (...) | (...);
                    }[];
                    periodReset?: Date;
                    periodSpendLimit?: {
                        amount?: (...) | (...);
                        denom?: (...) | (...);
                    }[];
                }
                | {
                    $typeUrl?: "/cosmos.feegrant.v1beta1.AllowedMsgAllowance";
                    allowance?: { $typeUrl?: string | undefined; typeUrl?: string | undefined; value?: Uint8Array | undefined; } | { $typeUrl?: "/cosmos.feegrant.v1beta1.BasicAllowance" | undefined; spendLimit?: { ...; }[] | undefined; expiration?: Date | undefined; } | { ...; } | { ...; } | undefined;
                    allowedMessages?: string[];
                }

            allowance can be any of basic and filtered fee allowance.

          • Optionalgrantee?: string

            grantee is the address of the user being granted an allowance of another user's funds.

          • Optionalgranter?: string

            granter is the address of the user granting an allowance of their funds.

      Returns QueryAllowanceResponse

  • fromProtoMsg:function

    • fromProtoMsg(message): QueryAllowanceResponse

    • Parameters

      • message: QueryAllowanceResponseProtoMsg

      Returns QueryAllowanceResponse

  • toAmino:function

    • toAmino(message): QueryAllowanceResponseAmino

    • Parameters

      • message: QueryAllowanceResponse

      Returns QueryAllowanceResponseAmino

  • toAminoMsg:function

    • toAminoMsg(message): QueryAllowanceResponseAminoMsg

    • Parameters

      • message: QueryAllowanceResponse

      Returns QueryAllowanceResponseAminoMsg

  • toProto:function

    • toProto(message): Uint8Array

    • Parameters

      • message: QueryAllowanceResponse

      Returns Uint8Array

  • toProtoMsg:function

    • toProtoMsg(message): QueryAllowanceResponseProtoMsg

    • Parameters

      • message: QueryAllowanceResponse

      Returns QueryAllowanceResponseProtoMsg

• QueryAllowancesByGranterRequest: {
      typeUrl: string;
      decode(input: Uint8Array | BinaryReader, length?: number): QueryAllowancesByGranterRequest;
      encode(message: QueryAllowancesByGranterRequest, writer?: BinaryWriter): BinaryWriter;
      fromAmino(object: QueryAllowancesByGranterRequestAmino): QueryAllowancesByGranterRequest;
      fromAminoMsg(object: QueryAllowancesByGranterRequestAminoMsg): QueryAllowancesByGranterRequest;
      fromPartial(object: {
          granter?: string;
          pagination?: {
              countTotal?: boolean;
              key?: Uint8Array;
              limit?: bigint;
              offset?: bigint;
              reverse?: boolean;
          };
      }): QueryAllowancesByGranterRequest;
      fromProtoMsg(message: QueryAllowancesByGranterRequestProtoMsg): QueryAllowancesByGranterRequest;
      toAmino(message: QueryAllowancesByGranterRequest): QueryAllowancesByGranterRequestAmino;
      toAminoMsg(message: QueryAllowancesByGranterRequest): QueryAllowancesByGranterRequestAminoMsg;
      toProto(message: QueryAllowancesByGranterRequest): Uint8Array;
      toProtoMsg(message: QueryAllowancesByGranterRequest): QueryAllowancesByGranterRequestProtoMsg;
  }

  • typeUrl: string

  • decode:function

    • decode(input, length?): QueryAllowancesByGranterRequest

    • Parameters

      • input: Uint8Array | BinaryReader
      • Optionallength: number

      Returns QueryAllowancesByGranterRequest

  • encode:function

    • encode(message, writer?): BinaryWriter

    • Parameters

      • message: QueryAllowancesByGranterRequest
      • writer: BinaryWriter = ...

      Returns BinaryWriter

  • fromAmino:function

    • fromAmino(object): QueryAllowancesByGranterRequest

    • Parameters

      • object: QueryAllowancesByGranterRequestAmino

      Returns QueryAllowancesByGranterRequest

  • fromAminoMsg:function

    • fromAminoMsg(object): QueryAllowancesByGranterRequest

    • Parameters

      • object: QueryAllowancesByGranterRequestAminoMsg

      Returns QueryAllowancesByGranterRequest

  • fromPartial:function

    • fromPartial(object): QueryAllowancesByGranterRequest

    • Parameters

      • object: {
            granter?: string;
            pagination?: {
                countTotal?: boolean;
                key?: Uint8Array;
                limit?: bigint;
                offset?: bigint;
                reverse?: boolean;
            };
        }

        • Optionalgranter?: string

        • Optionalpagination?: {
              countTotal?: boolean;
              key?: Uint8Array;
              limit?: bigint;
              offset?: bigint;
              reverse?: boolean;
          }

          pagination defines an pagination for the request.

          • OptionalcountTotal?: boolean

            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.

          • Optionalkey?: Uint8Array

            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.

          • Optionallimit?: bigint

            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.

          • Optionaloffset?: bigint

            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.

          • Optionalreverse?: boolean

            reverse is set to true if results are to be returned in the descending order.

            Since: cosmos-sdk 0.43

      Returns QueryAllowancesByGranterRequest

  • fromProtoMsg:function

    • fromProtoMsg(message): QueryAllowancesByGranterRequest

    • Parameters

      • message: QueryAllowancesByGranterRequestProtoMsg

      Returns QueryAllowancesByGranterRequest

  • toAmino:function

    • toAmino(message): QueryAllowancesByGranterRequestAmino

    • Parameters

      • message: QueryAllowancesByGranterRequest

      Returns QueryAllowancesByGranterRequestAmino

  • toAminoMsg:function

    • toAminoMsg(message): QueryAllowancesByGranterRequestAminoMsg

    • Parameters

      • message: QueryAllowancesByGranterRequest

      Returns QueryAllowancesByGranterRequestAminoMsg

  • toProto:function

    • toProto(message): Uint8Array

    • Parameters

      • message: QueryAllowancesByGranterRequest

      Returns Uint8Array

  • toProtoMsg:function

    • toProtoMsg(message): QueryAllowancesByGranterRequestProtoMsg

    • Parameters

      • message: QueryAllowancesByGranterRequest

      Returns QueryAllowancesByGranterRequestProtoMsg

• QueryAllowancesByGranterResponse: {
      typeUrl: string;
      decode(input: Uint8Array | BinaryReader, length?: number): QueryAllowancesByGranterResponse;
      encode(message: QueryAllowancesByGranterResponse, writer?: BinaryWriter): BinaryWriter;
      fromAmino(object: QueryAllowancesByGranterResponseAmino): QueryAllowancesByGranterResponse;
      fromAminoMsg(object: QueryAllowancesByGranterResponseAminoMsg): QueryAllowancesByGranterResponse;
      fromPartial(object: {
          allowances?: {
              allowance?:
                  | {
                      $typeUrl?: string;
                      typeUrl?: string;
                      value?: Uint8Array;
                  }
                  | {
                      $typeUrl?: "/cosmos.feegrant.v1beta1.BasicAllowance";
                      expiration?: Date;
                      spendLimit?: {
                          amount?: ...;
                          denom?: ...;
                      }[];
                  }
                  | {
                      $typeUrl?: "/cosmos.feegrant.v1beta1.PeriodicAllowance";
                      basic?: {
                          $typeUrl?: (...) | (...);
                          expiration?: (...) | (...);
                          spendLimit?: (...) | (...);
                      };
                      period?: {
                          nanos?: (...) | (...);
                          seconds?: (...) | (...);
                      };
                      periodCanSpend?: {
                          amount?: ...;
                          denom?: ...;
                      }[];
                      periodReset?: Date;
                      periodSpendLimit?: {
                          amount?: ...;
                          denom?: ...;
                      }[];
                  }
                  | {
                      $typeUrl?: "/cosmos.feegrant.v1beta1.AllowedMsgAllowance";
                      allowance?: { $typeUrl?: string | undefined; typeUrl?: string | undefined; value?: Uint8Array | undefined; } | { $typeUrl?: "/cosmos.feegrant.v1beta1.BasicAllowance" | undefined; spendLimit?: { ...; }[] | undefined; expiration?: Date | undefined; } | { ...; } | { ...; } | undefined;
                      allowedMessages?: string[];
                  };
              grantee?: string;
              granter?: string;
          }[];
          pagination?: {
              nextKey?: Uint8Array;
              total?: bigint;
          };
      }): QueryAllowancesByGranterResponse;
      fromProtoMsg(message: QueryAllowancesByGranterResponseProtoMsg): QueryAllowancesByGranterResponse;
      toAmino(message: QueryAllowancesByGranterResponse): QueryAllowancesByGranterResponseAmino;
      toAminoMsg(message: QueryAllowancesByGranterResponse): QueryAllowancesByGranterResponseAminoMsg;
      toProto(message: QueryAllowancesByGranterResponse): Uint8Array;
      toProtoMsg(message: QueryAllowancesByGranterResponse): QueryAllowancesByGranterResponseProtoMsg;
  }

  • typeUrl: string

  • decode:function

    • decode(input, length?): QueryAllowancesByGranterResponse

    • Parameters

      • input: Uint8Array | BinaryReader
      • Optionallength: number

      Returns QueryAllowancesByGranterResponse

  • encode:function

    • encode(message, writer?): BinaryWriter

    • Parameters

      • message: QueryAllowancesByGranterResponse
      • writer: BinaryWriter = ...

      Returns BinaryWriter

  • fromAmino:function

    • fromAmino(object): QueryAllowancesByGranterResponse

    • Parameters

      • object: QueryAllowancesByGranterResponseAmino

      Returns QueryAllowancesByGranterResponse

  • fromAminoMsg:function

    • fromAminoMsg(object): QueryAllowancesByGranterResponse

    • Parameters

      • object: QueryAllowancesByGranterResponseAminoMsg

      Returns QueryAllowancesByGranterResponse

  • fromPartial:function

    • fromPartial(object): QueryAllowancesByGranterResponse

    • Parameters

      • object: {
            allowances?: {
                allowance?:
                    | {
                        $typeUrl?: string;
                        typeUrl?: string;
                        value?: Uint8Array;
                    }
                    | {
                        $typeUrl?: "/cosmos.feegrant.v1beta1.BasicAllowance";
                        expiration?: Date;
                        spendLimit?: {
                            amount?: ...;
                            denom?: ...;
                        }[];
                    }
                    | {
                        $typeUrl?: "/cosmos.feegrant.v1beta1.PeriodicAllowance";
                        basic?: {
                            $typeUrl?: (...) | (...);
                            expiration?: (...) | (...);
                            spendLimit?: (...) | (...);
                        };
                        period?: {
                            nanos?: (...) | (...);
                            seconds?: (...) | (...);
                        };
                        periodCanSpend?: {
                            amount?: ...;
                            denom?: ...;
                        }[];
                        periodReset?: Date;
                        periodSpendLimit?: {
                            amount?: ...;
                            denom?: ...;
                        }[];
                    }
                    | {
                        $typeUrl?: "/cosmos.feegrant.v1beta1.AllowedMsgAllowance";
                        allowance?: { $typeUrl?: string | undefined; typeUrl?: string | undefined; value?: Uint8Array | undefined; } | { $typeUrl?: "/cosmos.feegrant.v1beta1.BasicAllowance" | undefined; spendLimit?: { ...; }[] | undefined; expiration?: Date | undefined; } | { ...; } | { ...; } | undefined;
                        allowedMessages?: string[];
                    };
                grantee?: string;
                granter?: string;
            }[];
            pagination?: {
                nextKey?: Uint8Array;
                total?: bigint;
            };
        }

        • Optionalallowances?: {
              allowance?:
                  | {
                      $typeUrl?: string;
                      typeUrl?: string;
                      value?: Uint8Array;
                  }
                  | {
                      $typeUrl?: "/cosmos.feegrant.v1beta1.BasicAllowance";
                      expiration?: Date;
                      spendLimit?: {
                          amount?: ...;
                          denom?: ...;
                      }[];
                  }
                  | {
                      $typeUrl?: "/cosmos.feegrant.v1beta1.PeriodicAllowance";
                      basic?: {
                          $typeUrl?: (...) | (...);
                          expiration?: (...) | (...);
                          spendLimit?: (...) | (...);
                      };
                      period?: {
                          nanos?: (...) | (...);
                          seconds?: (...) | (...);
                      };
                      periodCanSpend?: {
                          amount?: ...;
                          denom?: ...;
                      }[];
                      periodReset?: Date;
                      periodSpendLimit?: {
                          amount?: ...;
                          denom?: ...;
                      }[];
                  }
                  | {
                      $typeUrl?: "/cosmos.feegrant.v1beta1.AllowedMsgAllowance";
                      allowance?: { $typeUrl?: string | undefined; typeUrl?: string | undefined; value?: Uint8Array | undefined; } | { $typeUrl?: "/cosmos.feegrant.v1beta1.BasicAllowance" | undefined; spendLimit?: { ...; }[] | undefined; expiration?: Date | undefined; } | { ...; } | { ...; } | undefined;
                      allowedMessages?: string[];
                  };
              grantee?: string;
              granter?: string;
          }[]

          allowances that have been issued by the granter.

        • Optionalpagination?: {
              nextKey?: Uint8Array;
              total?: bigint;
          }

          pagination defines an pagination for the response.

          • OptionalnextKey?: Uint8Array

            next_key is the key to be passed to PageRequest.key to query the next page most efficiently

          • Optionaltotal?: bigint

            total is total number of results available if PageRequest.count_total was set, its value is undefined otherwise

      Returns QueryAllowancesByGranterResponse

  • fromProtoMsg:function

    • fromProtoMsg(message): QueryAllowancesByGranterResponse

    • Parameters

      • message: QueryAllowancesByGranterResponseProtoMsg

      Returns QueryAllowancesByGranterResponse

  • toAmino:function

    • toAmino(message): QueryAllowancesByGranterResponseAmino

    • Parameters

      • message: QueryAllowancesByGranterResponse

      Returns QueryAllowancesByGranterResponseAmino

  • toAminoMsg:function

    • toAminoMsg(message): QueryAllowancesByGranterResponseAminoMsg

    • Parameters

      • message: QueryAllowancesByGranterResponse

      Returns QueryAllowancesByGranterResponseAminoMsg

  • toProto:function

    • toProto(message): Uint8Array

    • Parameters

      • message: QueryAllowancesByGranterResponse

      Returns Uint8Array

  • toProtoMsg:function

    • toProtoMsg(message): QueryAllowancesByGranterResponseProtoMsg

    • Parameters

      • message: QueryAllowancesByGranterResponse

      Returns QueryAllowancesByGranterResponseProtoMsg

• QueryAllowancesRequest: {
      typeUrl: string;
      decode(input: Uint8Array | BinaryReader, length?: number): QueryAllowancesRequest;
      encode(message: QueryAllowancesRequest, writer?: BinaryWriter): BinaryWriter;
      fromAmino(object: QueryAllowancesRequestAmino): QueryAllowancesRequest;
      fromAminoMsg(object: QueryAllowancesRequestAminoMsg): QueryAllowancesRequest;
      fromPartial(object: {
          grantee?: string;
          pagination?: {
              countTotal?: boolean;
              key?: Uint8Array;
              limit?: bigint;
              offset?: bigint;
              reverse?: boolean;
          };
      }): QueryAllowancesRequest;
      fromProtoMsg(message: QueryAllowancesRequestProtoMsg): QueryAllowancesRequest;
      toAmino(message: QueryAllowancesRequest): QueryAllowancesRequestAmino;
      toAminoMsg(message: QueryAllowancesRequest): QueryAllowancesRequestAminoMsg;
      toProto(message: QueryAllowancesRequest): Uint8Array;
      toProtoMsg(message: QueryAllowancesRequest): QueryAllowancesRequestProtoMsg;
  }

  • typeUrl: string

  • decode:function

    • decode(input, length?): QueryAllowancesRequest

    • Parameters

      • input: Uint8Array | BinaryReader
      • Optionallength: number

      Returns QueryAllowancesRequest

  • encode:function

    • encode(message, writer?): BinaryWriter

    • Parameters

      • message: QueryAllowancesRequest
      • writer: BinaryWriter = ...

      Returns BinaryWriter

  • fromAmino:function

    • fromAmino(object): QueryAllowancesRequest

    • Parameters

      • object: QueryAllowancesRequestAmino

      Returns QueryAllowancesRequest

  • fromAminoMsg:function

    • fromAminoMsg(object): QueryAllowancesRequest

    • Parameters

      • object: QueryAllowancesRequestAminoMsg

      Returns QueryAllowancesRequest

  • fromPartial:function

    • fromPartial(object): QueryAllowancesRequest

    • Parameters

      • object: {
            grantee?: string;
            pagination?: {
                countTotal?: boolean;
                key?: Uint8Array;
                limit?: bigint;
                offset?: bigint;
                reverse?: boolean;
            };
        }

        • Optionalgrantee?: string

        • Optionalpagination?: {
              countTotal?: boolean;
              key?: Uint8Array;
              limit?: bigint;
              offset?: bigint;
              reverse?: boolean;
          }

          pagination defines an pagination for the request.

          • OptionalcountTotal?: boolean

            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.

          • Optionalkey?: Uint8Array

            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.

          • Optionallimit?: bigint

            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.

          • Optionaloffset?: bigint

            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.

          • Optionalreverse?: boolean

            reverse is set to true if results are to be returned in the descending order.

            Since: cosmos-sdk 0.43

      Returns QueryAllowancesRequest

  • fromProtoMsg:function

    • fromProtoMsg(message): QueryAllowancesRequest

    • Parameters

      • message: QueryAllowancesRequestProtoMsg

      Returns QueryAllowancesRequest

  • toAmino:function

    • toAmino(message): QueryAllowancesRequestAmino

    • Parameters

      • message: QueryAllowancesRequest

      Returns QueryAllowancesRequestAmino

  • toAminoMsg:function

    • toAminoMsg(message): QueryAllowancesRequestAminoMsg

    • Parameters

      • message: QueryAllowancesRequest

      Returns QueryAllowancesRequestAminoMsg

  • toProto:function

    • toProto(message): Uint8Array

    • Parameters

      • message: QueryAllowancesRequest

      Returns Uint8Array

  • toProtoMsg:function

    • toProtoMsg(message): QueryAllowancesRequestProtoMsg

    • Parameters

      • message: QueryAllowancesRequest

      Returns QueryAllowancesRequestProtoMsg

• QueryAllowancesResponse: {
      typeUrl: string;
      decode(input: Uint8Array | BinaryReader, length?: number): QueryAllowancesResponse;
      encode(message: QueryAllowancesResponse, writer?: BinaryWriter): BinaryWriter;
      fromAmino(object: QueryAllowancesResponseAmino): QueryAllowancesResponse;
      fromAminoMsg(object: QueryAllowancesResponseAminoMsg): QueryAllowancesResponse;
      fromPartial(object: {
          allowances?: {
              allowance?:
                  | {
                      $typeUrl?: string;
                      typeUrl?: string;
                      value?: Uint8Array;
                  }
                  | {
                      $typeUrl?: "/cosmos.feegrant.v1beta1.BasicAllowance";
                      expiration?: Date;
                      spendLimit?: {
                          amount?: ...;
                          denom?: ...;
                      }[];
                  }
                  | {
                      $typeUrl?: "/cosmos.feegrant.v1beta1.PeriodicAllowance";
                      basic?: {
                          $typeUrl?: (...) | (...);
                          expiration?: (...) | (...);
                          spendLimit?: (...) | (...);
                      };
                      period?: {
                          nanos?: (...) | (...);
                          seconds?: (...) | (...);
                      };
                      periodCanSpend?: {
                          amount?: ...;
                          denom?: ...;
                      }[];
                      periodReset?: Date;
                      periodSpendLimit?: {
                          amount?: ...;
                          denom?: ...;
                      }[];
                  }
                  | {
                      $typeUrl?: "/cosmos.feegrant.v1beta1.AllowedMsgAllowance";
                      allowance?: { $typeUrl?: string | undefined; typeUrl?: string | undefined; value?: Uint8Array | undefined; } | { $typeUrl?: "/cosmos.feegrant.v1beta1.BasicAllowance" | undefined; spendLimit?: { ...; }[] | undefined; expiration?: Date | undefined; } | { ...; } | { ...; } | undefined;
                      allowedMessages?: string[];
                  };
              grantee?: string;
              granter?: string;
          }[];
          pagination?: {
              nextKey?: Uint8Array;
              total?: bigint;
          };
      }): QueryAllowancesResponse;
      fromProtoMsg(message: QueryAllowancesResponseProtoMsg): QueryAllowancesResponse;
      toAmino(message: QueryAllowancesResponse): QueryAllowancesResponseAmino;
      toAminoMsg(message: QueryAllowancesResponse): QueryAllowancesResponseAminoMsg;
      toProto(message: QueryAllowancesResponse): Uint8Array;
      toProtoMsg(message: QueryAllowancesResponse): QueryAllowancesResponseProtoMsg;
  }

  • typeUrl: string

  • decode:function

    • decode(input, length?): QueryAllowancesResponse

    • Parameters

      • input: Uint8Array | BinaryReader
      • Optionallength: number

      Returns QueryAllowancesResponse

  • encode:function

    • encode(message, writer?): BinaryWriter

    • Parameters

      • message: QueryAllowancesResponse
      • writer: BinaryWriter = ...

      Returns BinaryWriter

  • fromAmino:function

    • fromAmino(object): QueryAllowancesResponse

    • Parameters

      • object: QueryAllowancesResponseAmino

      Returns QueryAllowancesResponse

  • fromAminoMsg:function

    • fromAminoMsg(object): QueryAllowancesResponse

    • Parameters

      • object: QueryAllowancesResponseAminoMsg

      Returns QueryAllowancesResponse

  • fromPartial:function

    • fromPartial(object): QueryAllowancesResponse

    • Parameters

      • object: {
            allowances?: {
                allowance?:
                    | {
                        $typeUrl?: string;
                        typeUrl?: string;
                        value?: Uint8Array;
                    }
                    | {
                        $typeUrl?: "/cosmos.feegrant.v1beta1.BasicAllowance";
                        expiration?: Date;
                        spendLimit?: {
                            amount?: ...;
                            denom?: ...;
                        }[];
                    }
                    | {
                        $typeUrl?: "/cosmos.feegrant.v1beta1.PeriodicAllowance";
                        basic?: {
                            $typeUrl?: (...) | (...);
                            expiration?: (...) | (...);
                            spendLimit?: (...) | (...);
                        };
                        period?: {
                            nanos?: (...) | (...);
                            seconds?: (...) | (...);
                        };
                        periodCanSpend?: {
                            amount?: ...;
                            denom?: ...;
                        }[];
                        periodReset?: Date;
                        periodSpendLimit?: {
                            amount?: ...;
                            denom?: ...;
                        }[];
                    }
                    | {
                        $typeUrl?: "/cosmos.feegrant.v1beta1.AllowedMsgAllowance";
                        allowance?: { $typeUrl?: string | undefined; typeUrl?: string | undefined; value?: Uint8Array | undefined; } | { $typeUrl?: "/cosmos.feegrant.v1beta1.BasicAllowance" | undefined; spendLimit?: { ...; }[] | undefined; expiration?: Date | undefined; } | { ...; } | { ...; } | undefined;
                        allowedMessages?: string[];
                    };
                grantee?: string;
                granter?: string;
            }[];
            pagination?: {
                nextKey?: Uint8Array;
                total?: bigint;
            };
        }

        • Optionalallowances?: {
              allowance?:
                  | {
                      $typeUrl?: string;
                      typeUrl?: string;
                      value?: Uint8Array;
                  }
                  | {
                      $typeUrl?: "/cosmos.feegrant.v1beta1.BasicAllowance";
                      expiration?: Date;
                      spendLimit?: {
                          amount?: ...;
                          denom?: ...;
                      }[];
                  }
                  | {
                      $typeUrl?: "/cosmos.feegrant.v1beta1.PeriodicAllowance";
                      basic?: {
                          $typeUrl?: (...) | (...);
                          expiration?: (...) | (...);
                          spendLimit?: (...) | (...);
                      };
                      period?: {
                          nanos?: (...) | (...);
                          seconds?: (...) | (...);
                      };
                      periodCanSpend?: {
                          amount?: ...;
                          denom?: ...;
                      }[];
                      periodReset?: Date;
                      periodSpendLimit?: {
                          amount?: ...;
                          denom?: ...;
                      }[];
                  }
                  | {
                      $typeUrl?: "/cosmos.feegrant.v1beta1.AllowedMsgAllowance";
                      allowance?: { $typeUrl?: string | undefined; typeUrl?: string | undefined; value?: Uint8Array | undefined; } | { $typeUrl?: "/cosmos.feegrant.v1beta1.BasicAllowance" | undefined; spendLimit?: { ...; }[] | undefined; expiration?: Date | undefined; } | { ...; } | { ...; } | undefined;
                      allowedMessages?: string[];
                  };
              grantee?: string;
              granter?: string;
          }[]

          allowances are allowance's granted for grantee by granter.

        • Optionalpagination?: {
              nextKey?: Uint8Array;
              total?: bigint;
          }

          pagination defines an pagination for the response.

          • OptionalnextKey?: Uint8Array

            next_key is the key to be passed to PageRequest.key to query the next page most efficiently

          • Optionaltotal?: bigint

            total is total number of results available if PageRequest.count_total was set, its value is undefined otherwise

      Returns QueryAllowancesResponse

  • fromProtoMsg:function

    • fromProtoMsg(message): QueryAllowancesResponse

    • Parameters

      • message: QueryAllowancesResponseProtoMsg

      Returns QueryAllowancesResponse

  • toAmino:function

    • toAmino(message): QueryAllowancesResponseAmino

    • Parameters

      • message: QueryAllowancesResponse

      Returns QueryAllowancesResponseAmino

  • toAminoMsg:function

    • toAminoMsg(message): QueryAllowancesResponseAminoMsg

    • Parameters

      • message: QueryAllowancesResponse

      Returns QueryAllowancesResponseAminoMsg

  • toProto:function

    • toProto(message): Uint8Array

    • Parameters

      • message: QueryAllowancesResponse

      Returns Uint8Array

  • toProtoMsg:function

    • toProtoMsg(message): QueryAllowancesResponseProtoMsg

    • Parameters

      • message: QueryAllowancesResponse

      Returns QueryAllowancesResponseProtoMsg

• createRpcQueryExtension: ((base: QueryClient) => {
      allowance(request: QueryAllowanceRequest): Promise<QueryAllowanceResponse>;
      allowances(request: QueryAllowancesRequest): Promise<QueryAllowancesResponse>;
      allowancesByGranter(request: QueryAllowancesByGranterRequest): Promise<QueryAllowancesByGranterResponse>;
  })

  • • (base): {
          allowance(request: QueryAllowanceRequest): Promise<QueryAllowanceResponse>;
          allowances(request: QueryAllowancesRequest): Promise<QueryAllowancesResponse>;
          allowancesByGranter(request: QueryAllowancesByGranterRequest): Promise<QueryAllowancesByGranterResponse>;
      }

    • Parameters

      • base: QueryClient

      Returns {
          allowance(request: QueryAllowanceRequest): Promise<QueryAllowanceResponse>;
          allowances(request: QueryAllowancesRequest): Promise<QueryAllowancesResponse>;
          allowancesByGranter(request: QueryAllowancesByGranterRequest): Promise<QueryAllowancesByGranterResponse>;
      }

      • allowance:function

        • allowance(request): Promise<QueryAllowanceResponse>

        • Parameters

          • request: QueryAllowanceRequest

          Returns Promise<QueryAllowanceResponse>

      • allowances:function

        • allowances(request): Promise<QueryAllowancesResponse>

        • Parameters

          • request: QueryAllowancesRequest

          Returns Promise<QueryAllowancesResponse>

      • allowancesByGranter:function

        • allowancesByGranter(request): Promise<QueryAllowancesByGranterResponse>

        • Parameters

          • request: QueryAllowancesByGranterRequest

          Returns Promise<QueryAllowancesByGranterResponse>

• load: ((protoRegistry: Registry) => void)

  • • (protoRegistry): void

    • Parameters

      • protoRegistry: Registry

      Returns void

• registry: readonly [string, TelescopeGeneratedType<any, any, any>][]