Dynamic Gas

The DynamicGas class provides methods for allowing any non-SUI coin to be used to pay for gas on any given Transaction on the Sui network.

Initialization

const afSdk = await Aftermath.create({ network: "MAINNET" });

const dynamicGas = afSdk.DynamicGas();

Methods

getUseDynamicGasForTx()

This method accepts any completed transaction, which it will modify and return as a sponsored transaction, paying for the sender's gas in SUI, and accepting the payment for this sponsored gas from the sender in the form of the provided gasCoinType. It calls POST /api/dynamic-gas and returns the sponsored transaction bytes and sponsor signature.

const { txBytes, sponsoredSignature } = await dynamicGas.getUseDynamicGasForTx({
	tx,
	walletAddress: "0x<user_address>",
	gasCoinType: "0xdba34672e30cb065b1f93e3ab55318768fd6fef66c15942c9f7cb846e2f900e7::usdc::USDC",
});

The user must sign the returned sponsored transaction, not the original transaction. Submit the user's signature and sponsoredSignature together, in that order.

Supported gas coins

Dynamic Gas accepts a range of gasCoinType values, including multiple stablecoins and Sui ecosystem tokens. Native USDC, 0xdba34672e30cb065b1f93e3ab55318768fd6fef66c15942c9f7cb846e2f900e7::usdc::USDC, is a safe default for a new integration.

getUseDynamicGasForTx is the only method on DynamicGas. Neither the SDK nor the API offers a way to discover eligible gas coins, so the accepted set cannot be queried at runtime — send a gasCoinType you have confirmed and handle a rejection. Router.getSupportedCoins() is not that list: it returns the coins tradable through the router, which is a different set.

Types

/**
 * Represents the response from the dynamic gas service, typically returning
 * updated transaction bytes and possibly a sponsored signature if the
 * transaction gas is being partially or fully sponsored.
 */
export interface ApiDynamicGasResponse {
	/**
	 * The modified transaction bytes that incorporate a gas coin or sponsor information.
	 */
	txBytes: SerializedTransaction;
	/**
	 * A signature used to sponsor or verify the updated transaction, if applicable.
	 */
	sponsoredSignature: string;
}

/**
 * Represents the body payload sent to the dynamic gas service,
 * which includes the serialized transaction and any user-provided
 * gas configuration (e.g., coin type).
 */
export interface ApiDynamicGasBody {
	/**
	 * The serialized transaction block in base64 or similar format.
	 */
	serializedTx: SerializedTransaction;
	/**
	 * The address of the user for whom the dynamic gas is being set.
	 */
	walletAddress: SuiAddress;
	/**
	 * The coin type to be used for gas payment (e.g., "0x2::sui::SUI").
	 */
	gasCoinType: CoinType;
}

Basic Types

/**
 * Represents a serialized transaction in a base64 or similar format.
 */
export type SerializedTransaction = string;

/**
 * Represents a Sui wallet address (e.g., "0x<address>").
 */
export type SuiAddress = string;

/**
 * A string that uniquely identifies a coin type in the Sui network
 * (e.g., "0x2::sui::SUI").
 */
export type CoinType = string;

Example Usage

import { Aftermath } from "aftermath-ts-sdk";
import { Ed25519Keypair } from "@mysten/sui/keypairs/ed25519";
import { SuiGrpcClient } from "@mysten/sui/grpc";
import { Transaction } from "@mysten/sui/transactions";

const afSdk = await Aftermath.create({ network: "MAINNET" });
const dynamicGas = afSdk.DynamicGas();
const grpcClient = new SuiGrpcClient({
	network: "mainnet",
	baseUrl: "https://fullnode.mainnet.sui.io:443",
});

const signer = Ed25519Keypair.fromSecretKey("suiprivkey1...");
const walletAddress = signer.toSuiAddress();

// Create some transaction
const tx = new Transaction();

// Add some move calls to transaction
// ...

// Use USDC to pay for gas instead of SUI
const { txBytes, sponsoredSignature } = await dynamicGas.getUseDynamicGasForTx({
	tx,
	walletAddress,
	gasCoinType: "0xdba34672e30cb065b1f93e3ab55318768fd6fef66c15942c9f7cb846e2f900e7::usdc::USDC",
});

// Reconstruct and build the sponsored transaction returned by Dynamic Gas
const sponsoredTx = Transaction.from(txBytes);
const sponsoredTxBytes = await sponsoredTx.build({ client: grpcClient });

// The sender signs the sponsored transaction bytes
const { signature: userSignature } =
	await signer.signTransaction(sponsoredTxBytes);

// Execute with the sender signature first and sponsor signature second
const result = await grpcClient.executeTransaction({
	transaction: sponsoredTxBytes,
	signatures: [userSignature, sponsoredSignature],
	include: {
		effects: true,
		events: true,
		balanceChanges: true,
		objectTypes: true,
	},
});

if (result.FailedTransaction) {
	throw new Error(
		`Transaction failed: ${result.FailedTransaction.status.error ?? "Unknown error"}`,
	);
}

console.log("Transaction digest:", result.Transaction.digest);

In browser applications, use the connected wallet or dApp Kit to sign sponsoredTx. Execute the wallet-returned transaction bytes with the same signature ordering: [userSignature, sponsoredSignature].