or run

npx @tessl/cli init
Log in

Version

Tile

Overview

Evals

Files

docs

amino-types.mdclient.mdindex.mdmessages.mdquery-extensions.mdutilities.md
tile.json

amino-types.mddocs/

Amino Type System

Legacy amino acid encoding system for backward compatibility with older Cosmos SDK chains and wallets. Provides converters between protobuf messages and amino JSON format.

Capabilities

AminoTypes Core

Main class for converting between protobuf and amino formats.

/**
 * Registry for amino message type converters
 */
class AminoTypes {
  constructor(types: AminoConverters);
  
  /** Convert protobuf EncodeObject to amino format */
  toAmino({ typeUrl, value }: EncodeObject): AminoMsg;
  
  /** Convert amino message to protobuf EncodeObject */
  fromAmino({ type, value }: AminoMsg): EncodeObject;
}

interface AminoConverter {
  /** Amino type string identifier */
  readonly aminoType: string;
  
  /** Convert protobuf value to amino format */
  readonly toAmino: (value: any) => any;
  
  /** Convert amino value to protobuf format */
  readonly fromAmino: (value: any) => any;
}

/** Map of type URLs to amino converters */
type AminoConverters = Record<string, AminoConverter>;

/** Base amino message format */
interface AminoMsg {
  /** Amino type identifier */
  readonly type: string;
  
  /** Message value */
  readonly value: any;
}

Usage Examples:

import { AminoTypes, createDefaultAminoConverters } from "@cosmjs/stargate";

// Create amino types with default converters
const aminoTypes = new AminoTypes(createDefaultAminoConverters());

// Convert protobuf to amino
const protoMsg = {
  typeUrl: "/cosmos.bank.v1beta1.MsgSend",
  value: {
    fromAddress: "cosmos1sender...",
    toAddress: "cosmos1recipient...",
    amount: [{ denom: "uatom", amount: "1000000" }],
  },
};

const aminoMsg = aminoTypes.toAmino(protoMsg);
// Result: { type: "cosmos-sdk/MsgSend", value: { ... } }

// Convert amino back to protobuf
const backToProto = aminoTypes.fromAmino(aminoMsg);

Default Amino Converters

Function to create default amino converters for all supported modules.

/** Creates default amino converters for all supported Cosmos SDK modules */
function createDefaultAminoConverters(): AminoConverters;

Bank Amino Messages

Amino message types and converters for bank module operations.

/** Send tokens amino message */
interface AminoMsgSend extends AminoMsg {
  readonly type: "cosmos-sdk/MsgSend";
  readonly value: {
    readonly from_address: string;
    readonly to_address: string;
    readonly amount: readonly Coin[];
  };
}

/** Multi-send tokens amino message */
interface AminoMsgMultiSend extends AminoMsg {
  readonly type: "cosmos-sdk/MsgMultiSend";
  readonly value: {
    readonly inputs: readonly Input[];
    readonly outputs: readonly Output[];
  };
}

/** Type guard for amino MsgSend */
function isAminoMsgSend(msg: AminoMsg): msg is AminoMsgSend;

/** Type guard for amino MsgMultiSend */
function isAminoMsgMultiSend(msg: AminoMsg): msg is AminoMsgMultiSend;

/** Create bank amino converters */
function createBankAminoConverters(): AminoConverters;

Usage Examples:

import { createBankAminoConverters, isAminoMsgSend } from "@cosmjs/stargate";

const bankConverters = createBankAminoConverters();

// Check amino message type
if (isAminoMsgSend(someAminoMsg)) {
  console.log(someAminoMsg.value.from_address);
  console.log(someAminoMsg.value.amount);
}

Staking Amino Messages

Amino message types for staking operations.

/** Delegate tokens amino message */
interface AminoMsgDelegate extends AminoMsg {
  readonly type: "cosmos-sdk/MsgDelegate";
  readonly value: {
    readonly delegator_address: string;
    readonly validator_address: string;
    readonly amount: Coin;
  };
}

/** Undelegate tokens amino message */
interface AminoMsgUndelegate extends AminoMsg {
  readonly type: "cosmos-sdk/MsgUndelegate";
  readonly value: {
    readonly delegator_address: string;
    readonly validator_address: string;
    readonly amount: Coin;
  };
}

/** Begin redelegate amino message */
interface AminoMsgBeginRedelegate extends AminoMsg {
  readonly type: "cosmos-sdk/MsgBeginRedelegate";
  readonly value: {
    readonly delegator_address: string;
    readonly validator_src_address: string;
    readonly validator_dst_address: string;
    readonly amount: Coin;
  };
}

/** Create validator amino message */
interface AminoMsgCreateValidator extends AminoMsg {
  readonly type: "cosmos-sdk/MsgCreateValidator";
  readonly value: {
    readonly description: {
      readonly moniker: string;
      readonly identity: string;
      readonly website: string;
      readonly security_contact: string;
      readonly details: string;
    };
    readonly commission: {
      readonly rate: string;
      readonly max_rate: string;
      readonly max_change_rate: string;
    };
    readonly min_self_delegation: string;
    readonly delegator_address: string;
    readonly validator_address: string;
    readonly pubkey: any;
    readonly value: Coin;
  };
}

/** Edit validator amino message */
interface AminoMsgEditValidator extends AminoMsg {
  readonly type: "cosmos-sdk/MsgEditValidator";
  readonly value: {
    readonly description: {
      readonly moniker: string;
      readonly identity: string;
      readonly website: string;
      readonly security_contact: string;
      readonly details: string;
    };
    readonly validator_address: string;
    readonly commission_rate: string;
    readonly min_self_delegation: string;
  };
}

/** Type guards for staking amino messages */
function isAminoMsgDelegate(msg: AminoMsg): msg is AminoMsgDelegate;
function isAminoMsgUndelegate(msg: AminoMsg): msg is AminoMsgUndelegate;
function isAminoMsgBeginRedelegate(msg: AminoMsg): msg is AminoMsgBeginRedelegate;
function isAminoMsgCreateValidator(msg: AminoMsg): msg is AminoMsgCreateValidator;
function isAminoMsgEditValidator(msg: AminoMsg): msg is AminoMsgEditValidator;

/** Create staking amino converters */
function createStakingAminoConverters(): AminoConverters;

Distribution Amino Messages

Amino message types for distribution operations.

/** Withdraw delegator rewards amino message */
interface AminoMsgWithdrawDelegatorReward extends AminoMsg {
  readonly type: "cosmos-sdk/MsgWithdrawDelegatorReward";
  readonly value: {
    readonly delegator_address: string;
    readonly validator_address: string;
  };
}

/** Withdraw validator commission amino message */
interface AminoMsgWithdrawValidatorCommission extends AminoMsg {
  readonly type: "cosmos-sdk/MsgWithdrawValidatorCommission";
  readonly value: {
    readonly validator_address: string;
  };
}

/** Set withdraw address amino message */
interface AminoMsgSetWithdrawAddress extends AminoMsg {
  readonly type: "cosmos-sdk/MsgModifyWithdrawAddress";
  readonly value: {
    readonly delegator_address: string;
    readonly withdraw_address: string;
  };
}

/** Fund community pool amino message */
interface AminoMsgFundCommunityPool extends AminoMsg {
  readonly type: "cosmos-sdk/MsgFundCommunityPool";
  readonly value: {
    readonly depositor: string;
    readonly amount: readonly Coin[];
  };
}

/** Type guards for distribution amino messages */
function isAminoMsgWithdrawDelegatorReward(msg: AminoMsg): msg is AminoMsgWithdrawDelegatorReward;
function isAminoMsgWithdrawValidatorCommission(msg: AminoMsg): msg is AminoMsgWithdrawValidatorCommission;
function isAminoMsgSetWithdrawAddress(msg: AminoMsg): msg is AminoMsgSetWithdrawAddress;
function isAminoMsgFundCommunityPool(msg: AminoMsg): msg is AminoMsgFundCommunityPool;

/** Create distribution amino converters */
function createDistributionAminoConverters(): AminoConverters;

Gov Amino Messages

Amino message types for governance operations.

/** Submit proposal amino message */
interface AminoMsgSubmitProposal extends AminoMsg {
  readonly type: "cosmos-sdk/MsgSubmitProposal";
  readonly value: {
    readonly content: any;
    readonly initial_deposit: readonly Coin[];
    readonly proposer: string;
  };
}

/** Vote amino message */
interface AminoMsgVote extends AminoMsg {
  readonly type: "cosmos-sdk/MsgVote";
  readonly value: {
    readonly proposal_id: string;
    readonly voter: string;
    readonly option: number;
  };
}

/** Weighted vote amino message */
interface AminoMsgVoteWeighted extends AminoMsg {
  readonly type: "cosmos-sdk/MsgVoteWeighted";
  readonly value: {
    readonly proposal_id: string;
    readonly voter: string;
    readonly options: readonly {
      readonly option: number;
      readonly weight: string;
    }[];
  };
}

/** Deposit amino message */
interface AminoMsgDeposit extends AminoMsg {
  readonly type: "cosmos-sdk/MsgDeposit";
  readonly value: {
    readonly proposal_id: string;
    readonly depositor: string;
    readonly amount: readonly Coin[];
  };
}

/** Type guards for gov amino messages */
function isAminoMsgSubmitProposal(msg: AminoMsg): msg is AminoMsgSubmitProposal;
function isAminoMsgVote(msg: AminoMsg): msg is AminoMsgVote;
function isAminoMsgVoteWeighted(msg: AminoMsg): msg is AminoMsgVoteWeighted;
function isAminoMsgDeposit(msg: AminoMsg): msg is AminoMsgDeposit;

/** Create gov amino converters */
function createGovAminoConverters(): AminoConverters;

IBC Amino Messages

Amino message types for IBC operations.

/** IBC transfer amino message */
interface AminoMsgTransfer extends AminoMsg {
  readonly type: "cosmos-sdk/MsgTransfer";
  readonly value: {
    readonly source_port: string;
    readonly source_channel: string;
    readonly token: Coin;
    readonly sender: string;
    readonly receiver: string;
    readonly timeout_height: {
      readonly revision_number?: string;
      readonly revision_height?: string;
    };
    readonly timeout_timestamp?: string;
  };
}

/** Type guard for IBC transfer amino message */
function isAminoMsgTransfer(msg: AminoMsg): msg is AminoMsgTransfer;

/** Create IBC amino converters */
function createIbcAminoConverters(): AminoConverters;

Additional Amino Message Types

/** Create vesting account amino message */
interface AminoMsgCreateVestingAccount extends AminoMsg {
  readonly type: "cosmos-sdk/MsgCreateVestingAccount";
  readonly value: {
    readonly from_address: string;
    readonly to_address: string;
    readonly amount: readonly Coin[];
    readonly end_time: string;
    readonly delayed: boolean;
  };
}

/** Unjail validator amino message */
interface AminoMsgUnjail extends AminoMsg {
  readonly type: "cosmos-sdk/MsgUnjail";
  readonly value: {
    readonly validator_addr: string;
  };
}

/** Submit evidence amino message */
interface AminoMsgSubmitEvidence extends AminoMsg {
  readonly type: "cosmos-sdk/MsgSubmitEvidence";
  readonly value: {
    readonly submitter: string;
    readonly evidence: any;
  };
}

/** Verify invariant amino message */
interface AminoMsgVerifyInvariant extends AminoMsg {
  readonly type: "cosmos-sdk/MsgVerifyInvariant";  
  readonly value: {
    readonly sender: string;
    readonly invariant_module_name: string;
    readonly invariant_route: string;
  };
}

/** Type guards for additional amino messages */
function isAminoMsgCreateVestingAccount(msg: AminoMsg): msg is AminoMsgCreateVestingAccount;
function isAminoMsgUnjail(msg: AminoMsg): msg is AminoMsgUnjail;
function isAminoMsgSubmitEvidence(msg: AminoMsg): msg is AminoMsgSubmitEvidence;
function isAminoMsgVerifyInvariant(msg: AminoMsg): msg is AminoMsgVerifyInvariant;

Module Amino Converter Functions

Functions to create amino converters for each supported module.

/** Create authz amino converters */
function createAuthzAminoConverters(): AminoConverters;

/** Create crisis amino converters */
function createCrysisAminoConverters(): AminoConverters;

/** Create evidence amino converters */
function createEvidenceAminoConverters(): AminoConverters;

/** Create feegrant amino converters */
function createFeegrantAminoConverters(): AminoConverters;

/** Create group amino converters */
function createGroupAminoConverters(): AminoConverters;

/** Create slashing amino converters */
function createSlashingAminoConverters(): AminoConverters;

/** Create vesting amino converters */
function createVestingAminoConverters(): AminoConverters;

Complete Usage Example

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

// Create wallet and client with amino support
const wallet = await DirectSecp256k1HdWallet.fromMnemonic(mnemonic);
const aminoTypes = new AminoTypes(createDefaultAminoConverters());

const client = await SigningStargateClient.connectWithSigner(
  "https://rpc.cosmos.network:443",
  wallet,
  { 
    aminoTypes, // Enable amino encoding
    gasPrice: GasPrice.fromString("0.025uatom")
  }
);

// Client will now use amino encoding when needed
const result = await client.sendTokens(
  senderAddress,
  recipientAddress,
  amount,
  "auto"
);

Custom Amino Converters

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

// Create custom amino converter
const customConverter = {
  "/custom.MsgCustom": {
    aminoType: "custom/MsgCustom",
    toAmino: (value: any) => ({
      custom_field: value.customField,
      // Transform protobuf to amino format
    }),
    fromAmino: (value: any) => ({
      customField: value.custom_field,
      // Transform amino to protobuf format
    }),
  },
};

// Combine with default converters
const allConverters = {
  ...createDefaultAminoConverters(),
  ...customConverter,
};

const aminoTypes = new AminoTypes(allConverters);