Transaction Queries

You can look up transactions by hash, search by events, decode raw transaction bytes, and simulate gas usage — all without broadcasting anything on-chain.

Lookup by Hash

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

const client = await StargateClient.connect("https://rpc.my-chain.network");

const tx = await client.getTx("A1B2C3D4...");
if (tx) {
  console.info(tx.height);
  console.info(tx.code); // 0 = success
  console.info(tx.events);
  console.info(tx.gasUsed);
}

Search by Events

// Raw Tendermint query string
const stringResults = await client.searchTx("message.sender='cosmos1...'");

// Or use the structured SearchPair[] form (see below)
const structuredResults = await client.searchTx([
  { key: "message.sender", value: "cosmos1..." },
  { key: "message.action", value: "/cosmos.bank.v1beta1.MsgSend" },
]);

Event queries use Tendermint’s query syntax. Multiple conditions are combined with AND.

Structured Query Syntax

searchTx accepts either a raw query string or a structured SearchPair[]. Structured queries are safer — string values are automatically quoted and numeric values are left unquoted (required by Tendermint):

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

const query: SearchPair[] = [
  { key: "transfer.sender", value: "cosmos1..." },
  { key: "tx.height", value: 12345 },
];

const txs = await client.searchTx(query);

Decoding Raw Transaction Bytes

IndexedTx.tx contains the raw transaction bytes. Use decodeTxRaw to inspect the messages, memo, fee, and signer info:

import { decodeTxRaw } from "@cosmjs/proto-signing";

const result = await client.getTx("A1B2C3D4...");
if (result) {
  const decoded = decodeTxRaw(result.tx);

  console.info(decoded.body.messages);
  console.info(decoded.body.memo);
  console.info(decoded.authInfo.fee);
  console.info(decoded.signatures);
}

Working with IndexedTx Fields

The IndexedTx response provides several useful fields beyond the raw bytes:

const result = await client.getTx("A1B2C3D4...");
if (result) {
  console.info(result.height);
  console.info(result.txIndex);
  console.info(result.code);          // 0 = success
  console.info(result.gasUsed);       // bigint
  console.info(result.gasWanted);     // bigint
  console.info(result.events);        // Event[]
  console.info(result.msgResponses);  // { typeUrl, value }[] (Cosmos SDK 0.46+)
}

rawLog is deprecated and empty on Cosmos SDK 0.50+. Use events instead.

Parsing Transaction Events

Transaction results include events emitted by Cosmos SDK modules. You can extract specific attributes from these events.

From DeliverTxResponse

After broadcasting with a SigningStargateClient, use events directly from the response:

import { SigningStargateClient, GasPrice, assertIsDeliverTxSuccess } from "@cosmjs/stargate";

const signingClient = await SigningStargateClient.connectWithSigner(
  "https://rpc.my-chain.network",
  wallet,
  { gasPrice: GasPrice.fromString("0.025uatom") },
);

const result = await signingClient.signAndBroadcast(sender, messages, "auto");
assertIsDeliverTxSuccess(result);

for (const event of result.events) {
  if (event.type === "transfer") {
    for (const attr of event.attributes) {
      console.info(`${attr.key} = ${attr.value}`);
    }
  }
}

From IndexedTx

Events from searched transactions follow the same structure:

const tx = await client.getTx("A1B2C3D4...");
if (tx) {
  const transferEvents = tx.events.filter((e) => e.type === "transfer");
  for (const event of transferEvents) {
    const recipient = event.attributes.find((a) => a.key === "recipient");
    const amount = event.attributes.find((a) => a.key === "amount");
    console.info(`${recipient?.value} received ${amount?.value}`);
  }
}

Extracting Contract Addresses (CosmWasm)

After uploading or instantiating a CosmWasm contract, the contract address is in the events. Use the same filtering pattern to extract it (broadcast through SigningCosmWasmClient):

import { SigningCosmWasmClient } from "@cosmjs/cosmwasm";
import { GasPrice } from "@cosmjs/stargate";

const wasmClient = await SigningCosmWasmClient.connectWithSigner(
  "https://rpc.my-chain.network",
  wallet,
  { gasPrice: GasPrice.fromString("0.025uosmo") },
);

const result = await wasmClient.signAndBroadcast(sender, [instantiateMsg], "auto");

const instantiateEvent = result.events.find((e) => e.type === "instantiate");
const contractAddress = instantiateEvent?.attributes.find(
  (a) => a.key === "_contract_address",
);
console.info(contractAddress?.value);

SigningCosmWasmClient.instantiate returns the contract address directly in its result, so you typically don’t need to parse events manually for instantiation.

Using parseRawLog (Legacy)

For chains running Cosmos SDK < 0.50, you can parse the rawLog field through the logs namespace:

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

const parsed = logs.parseRawLog(result.rawLog);
const attr = logs.findAttribute(parsed, "transfer", "amount");

rawLog is empty on Cosmos SDK 0.50+. Prefer working with events directly.

Using the Tx Extension

The tx extension provides a lower-level getTx and a simulate method for gas estimation:

import { QueryClient, setupTxExtension } from "@cosmjs/stargate";
import { connectComet } from "@cosmjs/tendermint-rpc";

const cometClient = await connectComet("https://rpc.my-chain.network");
const queryClient = QueryClient.withExtensions(cometClient, setupTxExtension);

const txResponse = await queryClient.tx.getTx("A1B2C3D4...");
console.info(txResponse.tx);
console.info(txResponse.txResponse);

Gas Simulation

Signing clients can simulate a transaction against the chain to estimate gas usage before broadcasting. Nothing is committed on-chain.

import { SigningStargateClient, GasPrice, calculateFee } from "@cosmjs/stargate";

const client = await SigningStargateClient.connectWithSigner(
  "https://rpc.my-chain.network",
  wallet,
  { gasPrice: GasPrice.fromString("0.025uatom") },
);

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

const gasEstimate = await client.simulate("cosmos1sender...", messages, "memo");
console.info(gasEstimate); // e.g. 85432

const fee = calculateFee(Math.round(gasEstimate * 1.3), GasPrice.fromString("0.025uatom"));
console.info(fee); // { amount: [...], gas: "111062" }

When you use "auto" as the fee in signAndBroadcast, the client calls simulate internally and applies a 1.4x multiplier to the result.

CosmJS

Concepts

Guides

API Reference

Lookup by Hash

Search by Events

Structured Query Syntax

Decoding Raw Transaction Bytes

Working with IndexedTx Fields

Parsing Transaction Events

From DeliverTxResponse

From IndexedTx

Extracting Contract Addresses (CosmWasm)

Using parseRawLog (Legacy)

Using the Tx Extension

Gas Simulation

Next Steps

Error Handling

Blocks & Chain Info

​Lookup by Hash

​Search by Events

​Structured Query Syntax

​Decoding Raw Transaction Bytes

​Working with IndexedTx Fields

​Parsing Transaction Events

​From DeliverTxResponse

​From IndexedTx

​Extracting Contract Addresses (CosmWasm)

​Using parseRawLog (Legacy)

​Using the Tx Extension

​Gas Simulation

​Next Steps

Error Handling

Blocks & Chain Info

Lookup by Hash

Search by Events

Structured Query Syntax

Decoding Raw Transaction Bytes

Working with IndexedTx Fields

Parsing Transaction Events

From DeliverTxResponse

From IndexedTx

Extracting Contract Addresses (CosmWasm)

Using parseRawLog (Legacy)

Using the Tx Extension

Gas Simulation

Next Steps