@cosmjs/stargate

import { 
  StargateClient, 
  SigningStargateClient,
  QueryClient,
  calculateFee,
  GasPrice,
  coin,
  coins,
  parseCoins,
  makeCosmoshubPath 
} from "@cosmjs/stargate";

const { 
  StargateClient, 
  SigningStargateClient,
  QueryClient,
  calculateFee,
  GasPrice 
} = require("@cosmjs/stargate");

import { StargateClient } from "@cosmjs/stargate";

// Connect to a Cosmos SDK chain
const client = await StargateClient.connect("https://rpc.cosmos.network:443");

// Query account balance
const balance = await client.getBalance("cosmos1abc...", "uatom");
console.log(balance); // { denom: "uatom", amount: "1000000" }

// Get transaction
const tx = await client.getTx("ABC123...");

import { SigningStargateClient, GasPrice } from "@cosmjs/stargate";
import { DirectSecp256k1HdWallet } from "@cosmjs/proto-signing";

// Create wallet from mnemonic
const wallet = await DirectSecp256k1HdWallet.fromMnemonic(mnemonic);

// Connect with signer
const client = await SigningStargateClient.connectWithSigner(
  "https://rpc.cosmos.network:443",
  wallet,
  { gasPrice: GasPrice.fromString("0.025uatom") }
);

// Send tokens
const result = await client.sendTokens(
  "cosmos1sender...",
  "cosmos1recipient...",
  [{ denom: "uatom", amount: "1000000" }],
  "auto",
  "Transfer memo"
);

class StargateClient {
  static async connect(endpoint: string | HttpEndpoint, options?: StargateClientOptions): Promise<StargateClient>;
  async getBalance(address: string, searchDenom: string): Promise<Coin>;
  async broadcastTx(tx: Uint8Array, timeoutMs?: number, pollIntervalMs?: number): Promise<DeliverTxResponse>;
}

class SigningStargateClient extends StargateClient {
  static async connectWithSigner(endpoint: string | HttpEndpoint, signer: OfflineSigner, options?: SigningStargateClientOptions): Promise<SigningStargateClient>;
  async sendTokens(senderAddress: string, recipientAddress: string, amount: readonly Coin[], fee: StdFee | "auto" | number, memo?: string): Promise<DeliverTxResponse>;
  async signAndBroadcast(signerAddress: string, messages: readonly EncodeObject[], fee: StdFee | "auto" | number, memo?: string): Promise<DeliverTxResponse>;
}

class QueryClient {
  static withExtensions<T extends Record<string, any>[]>(
    cometClient: CometClient,
    ...extensionSetups: QueryExtensionSetup<T>[]
  ): QueryClient & UnionToIntersection<T[number]>;
}

interface BankExtension {
  readonly bank: {
    readonly balance: (address: string, denom: string) => Promise<Coin>;
    readonly allBalances: (address: string) => Promise<Coin[]>;
  };
}

interface StakingExtension {
  readonly staking: {
    readonly validator: (validatorAddress: string) => Promise<QueryValidatorResponse>;
    readonly validators: (status: BondStatusString, paginationKey?: Uint8Array) => Promise<QueryValidatorsResponse>;
  };
}

interface MsgSendEncodeObject extends EncodeObject {
  readonly typeUrl: "/cosmos.bank.v1beta1.MsgSend";
  readonly value: Partial<MsgSend>;
}

interface MsgDelegateEncodeObject extends EncodeObject {
  readonly typeUrl: "/cosmos.staking.v1beta1.MsgDelegate";
  readonly value: Partial<MsgDelegate>;
}

function isMsgSendEncodeObject(encodeObject: EncodeObject): encodeObject is MsgSendEncodeObject;

class AminoTypes {
  constructor(types: AminoConverters);
  toAmino({ typeUrl, value }: EncodeObject): AminoMsg;
  fromAmino({ type, value }: AminoMsg): EncodeObject;
}

interface AminoConverter {
  readonly aminoType: string;
  readonly toAmino: (value: any) => any;
  readonly fromAmino: (value: any) => any;
}

function createDefaultAminoConverters(): AminoConverters;

class GasPrice {
  constructor(amount: Decimal, denom: string);
  static fromString(gasPrice: string): GasPrice;
}

function calculateFee(gasLimit: number, gasPrice: GasPrice | string): StdFee;

class TimeoutError extends Error {
  public readonly txId: string;
}

function isDeliverTxSuccess(result: DeliverTxResponse): boolean;
function assertIsDeliverTxSuccess(result: DeliverTxResponse): void;

interface Coin {
  readonly denom: string;
  readonly amount: string;
}

interface StdFee {
  readonly amount: readonly Coin[];
  readonly gas: string;
}

interface DeliverTxResponse {
  readonly height: number;
  readonly code: number;
  readonly transactionHash: string;
  readonly events: readonly Event[];
  readonly gasUsed: bigint;
  readonly gasWanted: bigint;
}

interface Account {
  readonly address: string;
  readonly pubkey: Pubkey | null;
  readonly accountNumber: number;
  readonly sequence: number;
}

interface Event {
  readonly type: string;
  readonly attributes: readonly Attribute[];
}

interface Attribute {
  readonly key: string;
  readonly value: string;
}

type HttpEndpoint = string | {
  readonly url: string;
  readonly headers?: Record<string, string>;
};

interface SearchPair {
  readonly key: string;
  readonly value: string | number | bigint;
}

type SearchTxQuery = string | readonly SearchPair[];

function isSearchTxQueryArray(query: SearchTxQuery): query is readonly SearchPair[];

function coin(amount: string, denom: string): Coin;
function coins(amount: string, denom: string): Coin[];
function makeCosmoshubPath(a: number): HdPath;
function parseCoins(input: string): Coin[];

type HdPath = readonly number[];