@burnt-labs/xion-types 0.0.1-test.1762962136

package/types/cosmos/bank/v1beta1/genesis.ts

@@ -0,0 +1,316 @@
+//@ts-nocheck
+import { Params, ParamsAmino, ParamsSDKType, Metadata, MetadataAmino, MetadataSDKType, SendEnabled, SendEnabledAmino, SendEnabledSDKType } from "./bank";
+import { Coin, CoinAmino, CoinSDKType } from "../../base/v1beta1/coin";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+/** GenesisState defines the bank module's genesis state. */
+export interface GenesisState {
+  /** params defines all the parameters of the module. */
+  params: Params;
+  /** balances is an array containing the balances of all the accounts. */
+  balances: Balance[];
+  /**
+   * supply represents the total supply. If it is left empty, then supply will be calculated based on the provided
+   * balances. Otherwise, it will be used to validate that the sum of the balances equals this amount.
+   */
+  supply: Coin[];
+  /** denom_metadata defines the metadata of the different coins. */
+  denomMetadata: Metadata[];
+  /** send_enabled defines the denoms where send is enabled or disabled. */
+  sendEnabled: SendEnabled[];
+}
+export interface GenesisStateProtoMsg {
+  typeUrl: "/cosmos.bank.v1beta1.GenesisState";
+  value: Uint8Array;
+}
+/**
+ * GenesisState defines the bank module's genesis state.
+ * @name GenesisStateAmino
+ * @package cosmos.bank.v1beta1
+ * @see proto type: cosmos.bank.v1beta1.GenesisState
+ */
+export interface GenesisStateAmino {
+  /**
+   * params defines all the parameters of the module.
+   */
+  params: ParamsAmino;
+  /**
+   * balances is an array containing the balances of all the accounts.
+   */
+  balances: BalanceAmino[];
+  /**
+   * supply represents the total supply. If it is left empty, then supply will be calculated based on the provided
+   * balances. Otherwise, it will be used to validate that the sum of the balances equals this amount.
+   */
+  supply: CoinAmino[];
+  /**
+   * denom_metadata defines the metadata of the different coins.
+   */
+  denom_metadata: MetadataAmino[];
+  /**
+   * send_enabled defines the denoms where send is enabled or disabled.
+   */
+  send_enabled: SendEnabledAmino[];
+}
+export interface GenesisStateAminoMsg {
+  type: "cosmos-sdk/GenesisState";
+  value: GenesisStateAmino;
+}
+/** GenesisState defines the bank module's genesis state. */
+export interface GenesisStateSDKType {
+  params: ParamsSDKType;
+  balances: BalanceSDKType[];
+  supply: CoinSDKType[];
+  denom_metadata: MetadataSDKType[];
+  send_enabled: SendEnabledSDKType[];
+}
+/**
+ * Balance defines an account address and balance pair used in the bank module's
+ * genesis state.
+ */
+export interface Balance {
+  /** address is the address of the balance holder. */
+  address: string;
+  /** coins defines the different coins this balance holds. */
+  coins: Coin[];
+}
+export interface BalanceProtoMsg {
+  typeUrl: "/cosmos.bank.v1beta1.Balance";
+  value: Uint8Array;
+}
+/**
+ * Balance defines an account address and balance pair used in the bank module's
+ * genesis state.
+ * @name BalanceAmino
+ * @package cosmos.bank.v1beta1
+ * @see proto type: cosmos.bank.v1beta1.Balance
+ */
+export interface BalanceAmino {
+  /**
+   * address is the address of the balance holder.
+   */
+  address?: string;
+  /**
+   * coins defines the different coins this balance holds.
+   */
+  coins: CoinAmino[];
+}
+export interface BalanceAminoMsg {
+  type: "cosmos-sdk/Balance";
+  value: BalanceAmino;
+}
+/**
+ * Balance defines an account address and balance pair used in the bank module's
+ * genesis state.
+ */
+export interface BalanceSDKType {
+  address: string;
+  coins: CoinSDKType[];
+}
+function createBaseGenesisState(): GenesisState {
+  return {
+    params: Params.fromPartial({}),
+    balances: [],
+    supply: [],
+    denomMetadata: [],
+    sendEnabled: []
+  };
+}
+export const GenesisState = {
+  typeUrl: "/cosmos.bank.v1beta1.GenesisState",
+  encode(message: GenesisState, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.params !== undefined) {
+      Params.encode(message.params, writer.uint32(10).fork()).ldelim();
+    }
+    for (const v of message.balances) {
+      Balance.encode(v!, writer.uint32(18).fork()).ldelim();
+    }
+    for (const v of message.supply) {
+      Coin.encode(v!, writer.uint32(26).fork()).ldelim();
+    }
+    for (const v of message.denomMetadata) {
+      Metadata.encode(v!, writer.uint32(34).fork()).ldelim();
+    }
+    for (const v of message.sendEnabled) {
+      SendEnabled.encode(v!, writer.uint32(42).fork()).ldelim();
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): GenesisState {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseGenesisState();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.params = Params.decode(reader, reader.uint32());
+          break;
+        case 2:
+          message.balances.push(Balance.decode(reader, reader.uint32()));
+          break;
+        case 3:
+          message.supply.push(Coin.decode(reader, reader.uint32()));
+          break;
+        case 4:
+          message.denomMetadata.push(Metadata.decode(reader, reader.uint32()));
+          break;
+        case 5:
+          message.sendEnabled.push(SendEnabled.decode(reader, reader.uint32()));
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<GenesisState>): GenesisState {
+    const message = createBaseGenesisState();
+    message.params = object.params !== undefined && object.params !== null ? Params.fromPartial(object.params) : undefined;
+    message.balances = object.balances?.map(e => Balance.fromPartial(e)) || [];
+    message.supply = object.supply?.map(e => Coin.fromPartial(e)) || [];
+    message.denomMetadata = object.denomMetadata?.map(e => Metadata.fromPartial(e)) || [];
+    message.sendEnabled = object.sendEnabled?.map(e => SendEnabled.fromPartial(e)) || [];
+    return message;
+  },
+  fromAmino(object: GenesisStateAmino): GenesisState {
+    const message = createBaseGenesisState();
+    if (object.params !== undefined && object.params !== null) {
+      message.params = Params.fromAmino(object.params);
+    }
+    message.balances = object.balances?.map(e => Balance.fromAmino(e)) || [];
+    message.supply = object.supply?.map(e => Coin.fromAmino(e)) || [];
+    message.denomMetadata = object.denom_metadata?.map(e => Metadata.fromAmino(e)) || [];
+    message.sendEnabled = object.send_enabled?.map(e => SendEnabled.fromAmino(e)) || [];
+    return message;
+  },
+  toAmino(message: GenesisState): GenesisStateAmino {
+    const obj: any = {};
+    obj.params = message.params ? Params.toAmino(message.params) : Params.toAmino(Params.fromPartial({}));
+    if (message.balances) {
+      obj.balances = message.balances.map(e => e ? Balance.toAmino(e) : undefined);
+    } else {
+      obj.balances = message.balances;
+    }
+    if (message.supply) {
+      obj.supply = message.supply.map(e => e ? Coin.toAmino(e) : undefined);
+    } else {
+      obj.supply = message.supply;
+    }
+    if (message.denomMetadata) {
+      obj.denom_metadata = message.denomMetadata.map(e => e ? Metadata.toAmino(e) : undefined);
+    } else {
+      obj.denom_metadata = message.denomMetadata;
+    }
+    if (message.sendEnabled) {
+      obj.send_enabled = message.sendEnabled.map(e => e ? SendEnabled.toAmino(e) : undefined);
+    } else {
+      obj.send_enabled = message.sendEnabled;
+    }
+    return obj;
+  },
+  fromAminoMsg(object: GenesisStateAminoMsg): GenesisState {
+    return GenesisState.fromAmino(object.value);
+  },
+  toAminoMsg(message: GenesisState): GenesisStateAminoMsg {
+    return {
+      type: "cosmos-sdk/GenesisState",
+      value: GenesisState.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: GenesisStateProtoMsg): GenesisState {
+    return GenesisState.decode(message.value);
+  },
+  toProto(message: GenesisState): Uint8Array {
+    return GenesisState.encode(message).finish();
+  },
+  toProtoMsg(message: GenesisState): GenesisStateProtoMsg {
+    return {
+      typeUrl: "/cosmos.bank.v1beta1.GenesisState",
+      value: GenesisState.encode(message).finish()
+    };
+  }
+};
+function createBaseBalance(): Balance {
+  return {
+    address: "",
+    coins: []
+  };
+}
+export const Balance = {
+  typeUrl: "/cosmos.bank.v1beta1.Balance",
+  encode(message: Balance, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter {
+    if (message.address !== "") {
+      writer.uint32(10).string(message.address);
+    }
+    for (const v of message.coins) {
+      Coin.encode(v!, writer.uint32(18).fork()).ldelim();
+    }
+    return writer;
+  },
+  decode(input: BinaryReader | Uint8Array, length?: number): Balance {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseBalance();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.address = reader.string();
+          break;
+        case 2:
+          message.coins.push(Coin.decode(reader, reader.uint32()));
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+  fromPartial(object: Partial<Balance>): Balance {
+    const message = createBaseBalance();
+    message.address = object.address ?? "";
+    message.coins = object.coins?.map(e => Coin.fromPartial(e)) || [];
+    return message;
+  },
+  fromAmino(object: BalanceAmino): Balance {
+    const message = createBaseBalance();
+    if (object.address !== undefined && object.address !== null) {
+      message.address = object.address;
+    }
+    message.coins = object.coins?.map(e => Coin.fromAmino(e)) || [];
+    return message;
+  },
+  toAmino(message: Balance): BalanceAmino {
+    const obj: any = {};
+    obj.address = message.address === "" ? undefined : message.address;
+    if (message.coins) {
+      obj.coins = message.coins.map(e => e ? Coin.toAmino(e) : undefined);
+    } else {
+      obj.coins = message.coins;
+    }
+    return obj;
+  },
+  fromAminoMsg(object: BalanceAminoMsg): Balance {
+    return Balance.fromAmino(object.value);
+  },
+  toAminoMsg(message: Balance): BalanceAminoMsg {
+    return {
+      type: "cosmos-sdk/Balance",
+      value: Balance.toAmino(message)
+    };
+  },
+  fromProtoMsg(message: BalanceProtoMsg): Balance {
+    return Balance.decode(message.value);
+  },
+  toProto(message: Balance): Uint8Array {
+    return Balance.encode(message).finish();
+  },
+  toProtoMsg(message: Balance): BalanceProtoMsg {
+    return {
+      typeUrl: "/cosmos.bank.v1beta1.Balance",
+      value: Balance.encode(message).finish()
+    };
+  }
+};

package/types/cosmos/bank/v1beta1/query.lcd.ts

@@ -0,0 +1,207 @@
+//@ts-nocheck
+import { setPaginationParams } from "../../../helpers";
+import { LCDClient } from "@cosmology/lcd";
+import { QueryBalanceRequest, QueryBalanceResponseSDKType, QueryAllBalancesRequest, QueryAllBalancesResponseSDKType, QuerySpendableBalancesRequest, QuerySpendableBalancesResponseSDKType, QuerySpendableBalanceByDenomRequest, QuerySpendableBalanceByDenomResponseSDKType, QueryTotalSupplyRequest, QueryTotalSupplyResponseSDKType, QuerySupplyOfRequest, QuerySupplyOfResponseSDKType, QueryParamsRequest, QueryParamsResponseSDKType, QueryDenomsMetadataRequest, QueryDenomsMetadataResponseSDKType, QueryDenomMetadataRequest, QueryDenomMetadataResponseSDKType, QueryDenomMetadataByQueryStringRequest, QueryDenomMetadataByQueryStringResponseSDKType, QueryDenomOwnersRequest, QueryDenomOwnersResponseSDKType, QueryDenomOwnersByQueryRequest, QueryDenomOwnersByQueryResponseSDKType, QuerySendEnabledRequest, QuerySendEnabledResponseSDKType } from "./query";
+export class LCDQueryClient {
+  req: LCDClient;
+  constructor({
+    requestClient
+  }: {
+    requestClient: LCDClient;
+  }) {
+    this.req = requestClient;
+    this.balance = this.balance.bind(this);
+    this.allBalances = this.allBalances.bind(this);
+    this.spendableBalances = this.spendableBalances.bind(this);
+    this.spendableBalanceByDenom = this.spendableBalanceByDenom.bind(this);
+    this.totalSupply = this.totalSupply.bind(this);
+    this.supplyOf = this.supplyOf.bind(this);
+    this.params = this.params.bind(this);
+    this.denomsMetadata = this.denomsMetadata.bind(this);
+    this.denomMetadata = this.denomMetadata.bind(this);
+    this.denomMetadataByQueryString = this.denomMetadataByQueryString.bind(this);
+    this.denomOwners = this.denomOwners.bind(this);
+    this.denomOwnersByQuery = this.denomOwnersByQuery.bind(this);
+    this.sendEnabled = this.sendEnabled.bind(this);
+  }
+  /* Balance queries the balance of a single coin for a single account. */
+  async balance(params: QueryBalanceRequest): Promise<QueryBalanceResponseSDKType> {
+    const options: any = {
+      params: {}
+    };
+    if (typeof params?.denom !== "undefined") {
+      options.params.denom = params.denom;
+    }
+    const endpoint = `cosmos/bank/v1beta1/balances/${params.address}/by_denom`;
+    return await this.req.get<QueryBalanceResponseSDKType>(endpoint, options);
+  }
+  /* AllBalances queries the balance of all coins for a single account.
+  
+   When called from another module, this query might consume a high amount of
+   gas if the pagination field is incorrectly set. */
+  async allBalances(params: QueryAllBalancesRequest): Promise<QueryAllBalancesResponseSDKType> {
+    const options: any = {
+      params: {}
+    };
+    if (typeof params?.pagination !== "undefined") {
+      setPaginationParams(options, params.pagination);
+    }
+    if (typeof params?.resolveDenom !== "undefined") {
+      options.params.resolve_denom = params.resolveDenom;
+    }
+    const endpoint = `cosmos/bank/v1beta1/balances/${params.address}`;
+    return await this.req.get<QueryAllBalancesResponseSDKType>(endpoint, options);
+  }
+  /* SpendableBalances queries the spendable balance of all coins for a single
+   account.
+  
+   When called from another module, this query might consume a high amount of
+   gas if the pagination field is incorrectly set. */
+  async spendableBalances(params: QuerySpendableBalancesRequest): Promise<QuerySpendableBalancesResponseSDKType> {
+    const options: any = {
+      params: {}
+    };
+    if (typeof params?.pagination !== "undefined") {
+      setPaginationParams(options, params.pagination);
+    }
+    const endpoint = `cosmos/bank/v1beta1/spendable_balances/${params.address}`;
+    return await this.req.get<QuerySpendableBalancesResponseSDKType>(endpoint, options);
+  }
+  /* SpendableBalanceByDenom queries the spendable balance of a single denom for
+   a single account.
+  
+   When called from another module, this query might consume a high amount of
+   gas if the pagination field is incorrectly set. */
+  async spendableBalanceByDenom(params: QuerySpendableBalanceByDenomRequest): Promise<QuerySpendableBalanceByDenomResponseSDKType> {
+    const options: any = {
+      params: {}
+    };
+    if (typeof params?.denom !== "undefined") {
+      options.params.denom = params.denom;
+    }
+    const endpoint = `cosmos/bank/v1beta1/spendable_balances/${params.address}/by_denom`;
+    return await this.req.get<QuerySpendableBalanceByDenomResponseSDKType>(endpoint, options);
+  }
+  /* TotalSupply queries the total supply of all coins.
+  
+   When called from another module, this query might consume a high amount of
+   gas if the pagination field is incorrectly set. */
+  async totalSupply(params: QueryTotalSupplyRequest = {
+    pagination: undefined
+  }): Promise<QueryTotalSupplyResponseSDKType> {
+    const options: any = {
+      params: {}
+    };
+    if (typeof params?.pagination !== "undefined") {
+      setPaginationParams(options, params.pagination);
+    }
+    const endpoint = `cosmos/bank/v1beta1/supply`;
+    return await this.req.get<QueryTotalSupplyResponseSDKType>(endpoint, options);
+  }
+  /* SupplyOf queries the supply of a single coin.
+  
+   When called from another module, this query might consume a high amount of
+   gas if the pagination field is incorrectly set. */
+  async supplyOf(params: QuerySupplyOfRequest): Promise<QuerySupplyOfResponseSDKType> {
+    const options: any = {
+      params: {}
+    };
+    if (typeof params?.denom !== "undefined") {
+      options.params.denom = params.denom;
+    }
+    const endpoint = `cosmos/bank/v1beta1/supply/by_denom`;
+    return await this.req.get<QuerySupplyOfResponseSDKType>(endpoint, options);
+  }
+  /* Params queries the parameters of x/bank module. */
+  async params(_params: QueryParamsRequest = {}): Promise<QueryParamsResponseSDKType> {
+    const endpoint = `cosmos/bank/v1beta1/params`;
+    return await this.req.get<QueryParamsResponseSDKType>(endpoint);
+  }
+  /* DenomsMetadata queries the client metadata for all registered coin
+   denominations. */
+  async denomsMetadata(params: QueryDenomsMetadataRequest = {
+    pagination: undefined
+  }): Promise<QueryDenomsMetadataResponseSDKType> {
+    const options: any = {
+      params: {}
+    };
+    if (typeof params?.pagination !== "undefined") {
+      setPaginationParams(options, params.pagination);
+    }
+    const endpoint = `cosmos/bank/v1beta1/denoms_metadata`;
+    return await this.req.get<QueryDenomsMetadataResponseSDKType>(endpoint, options);
+  }
+  /* DenomMetadata queries the client metadata of a given coin denomination. */
+  async denomMetadata(params: QueryDenomMetadataRequest): Promise<QueryDenomMetadataResponseSDKType> {
+    const options: any = {
+      params: {}
+    };
+    if (typeof params?.denom !== "undefined") {
+      options.params.denom = params.denom;
+    }
+    const endpoint = `cosmos/bank/v1beta1/denoms_metadata/${params.denom}`;
+    return await this.req.get<QueryDenomMetadataResponseSDKType>(endpoint, options);
+  }
+  /* DenomMetadataByQueryString queries the client metadata of a given coin denomination. */
+  async denomMetadataByQueryString(params: QueryDenomMetadataByQueryStringRequest): Promise<QueryDenomMetadataByQueryStringResponseSDKType> {
+    const options: any = {
+      params: {}
+    };
+    if (typeof params?.denom !== "undefined") {
+      options.params.denom = params.denom;
+    }
+    const endpoint = `cosmos/bank/v1beta1/denoms_metadata_by_query_string`;
+    return await this.req.get<QueryDenomMetadataByQueryStringResponseSDKType>(endpoint, options);
+  }
+  /* DenomOwners queries for all account addresses that own a particular token
+   denomination.
+  
+   When called from another module, this query might consume a high amount of
+   gas if the pagination field is incorrectly set. */
+  async denomOwners(params: QueryDenomOwnersRequest): Promise<QueryDenomOwnersResponseSDKType> {
+    const options: any = {
+      params: {}
+    };
+    if (typeof params?.denom !== "undefined") {
+      options.params.denom = params.denom;
+    }
+    if (typeof params?.pagination !== "undefined") {
+      setPaginationParams(options, params.pagination);
+    }
+    const endpoint = `cosmos/bank/v1beta1/denom_owners/${params.denom}`;
+    return await this.req.get<QueryDenomOwnersResponseSDKType>(endpoint, options);
+  }
+  /* DenomOwnersByQuery queries for all account addresses that own a particular token
+   denomination. */
+  async denomOwnersByQuery(params: QueryDenomOwnersByQueryRequest): Promise<QueryDenomOwnersByQueryResponseSDKType> {
+    const options: any = {
+      params: {}
+    };
+    if (typeof params?.denom !== "undefined") {
+      options.params.denom = params.denom;
+    }
+    if (typeof params?.pagination !== "undefined") {
+      setPaginationParams(options, params.pagination);
+    }
+    const endpoint = `cosmos/bank/v1beta1/denom_owners_by_query`;
+    return await this.req.get<QueryDenomOwnersByQueryResponseSDKType>(endpoint, options);
+  }
+  /* SendEnabled queries for SendEnabled entries.
+  
+   This query only returns denominations that have specific SendEnabled settings.
+   Any denomination that does not have a specific setting will use the default
+   params.default_send_enabled, and will not be returned by this query. */
+  async sendEnabled(params: QuerySendEnabledRequest): Promise<QuerySendEnabledResponseSDKType> {
+    const options: any = {
+      params: {}
+    };
+    if (typeof params?.denoms !== "undefined") {
+      options.params.denoms = params.denoms;
+    }
+    if (typeof params?.pagination !== "undefined") {
+      setPaginationParams(options, params.pagination);
+    }
+    const endpoint = `cosmos/bank/v1beta1/send_enabled`;
+    return await this.req.get<QuerySendEnabledResponseSDKType>(endpoint, options);
+  }
+}