@mysten/sui 2.29.0 → 2.30.0

package/dist/zklogin/bcs.d.mts

@@ -1,31 +1,31 @@
-import * as _mysten_bcs1378 from "@mysten/bcs";
+import * as _mysten_bcs1238 from "@mysten/bcs";
 import { InferBcsInput } from "@mysten/bcs";
 
 //#region src/zklogin/bcs.d.ts
-declare const zkLoginSignature: _mysten_bcs1378.BcsStruct<{
-  inputs: _mysten_bcs1378.BcsStruct<{
-    proofPoints: _mysten_bcs1378.BcsStruct<{
-      a: _mysten_bcs1378.BcsType<string[], Iterable<string> & {
+declare const zkLoginSignature: _mysten_bcs1238.BcsStruct<{
+  inputs: _mysten_bcs1238.BcsStruct<{
+    proofPoints: _mysten_bcs1238.BcsStruct<{
+      a: _mysten_bcs1238.BcsType<string[], Iterable<string> & {
         length: number;
       }, string>;
-      b: _mysten_bcs1378.BcsType<string[][], Iterable<Iterable<string> & {
+      b: _mysten_bcs1238.BcsType<string[][], Iterable<Iterable<string> & {
         length: number;
       }> & {
         length: number;
       }, string>;
-      c: _mysten_bcs1378.BcsType<string[], Iterable<string> & {
+      c: _mysten_bcs1238.BcsType<string[], Iterable<string> & {
         length: number;
       }, string>;
     }, string>;
-    issBase64Details: _mysten_bcs1378.BcsStruct<{
-      value: _mysten_bcs1378.BcsType<string, string, "string">;
-      indexMod4: _mysten_bcs1378.BcsType<number, number, "u8">;
+    issBase64Details: _mysten_bcs1238.BcsStruct<{
+      value: _mysten_bcs1238.BcsType<string, string, "string">;
+      indexMod4: _mysten_bcs1238.BcsType<number, number, "u8">;
     }, string>;
-    headerBase64: _mysten_bcs1378.BcsType<string, string, "string">;
-    addressSeed: _mysten_bcs1378.BcsType<string, string, "string">;
+    headerBase64: _mysten_bcs1238.BcsType<string, string, "string">;
+    addressSeed: _mysten_bcs1238.BcsType<string, string, "string">;
   }, string>;
-  maxEpoch: _mysten_bcs1378.BcsType<string, string | number | bigint, "u64">;
-  userSignature: _mysten_bcs1378.BcsType<Uint8Array<ArrayBufferLike>, Iterable<number>, "vector<u8>">;
+  maxEpoch: _mysten_bcs1238.BcsType<string, string | number | bigint, "u64">;
+  userSignature: _mysten_bcs1238.BcsType<Uint8Array<ArrayBufferLike>, Iterable<number>, "vector<u8>">;
 }, string>;
 type ZkLoginSignature = InferBcsInput<typeof zkLoginSignature>;
 type ZkLoginSignatureInputs = ZkLoginSignature['inputs'];

package/docs/migrations/sui-2.0/json-rpc-migration.md

@@ -95,7 +95,7 @@ use the same replacement under `client.core`.
 | `getBalance`                 | `getBalance`                                                          |
 | `getCoinMetadata`            | `getCoinMetadata`                                                     |
 | `getDynamicFields`           | `listDynamicFields`                                                   |
-| `getDynamicFieldObject`      | `getDynamicField` or `client.core.getDynamicObjectField`              |
+| `getDynamicFieldObject`      | `getDynamicField` or `getDynamicObjectField`, depending on field kind |
 | `getTransactionBlock`        | `getTransaction`                                                      |
 | `multiGetTransactionBlocks`  | Multiple `getTransaction` calls                                       |
 | `executeTransactionBlock`    | `executeTransaction`                                                  |
@@ -109,6 +109,55 @@ use the same replacement under `client.core`.
 | `resolveNameServiceAddress`  | `resolveNameServiceAddress` (returns `{ address }`)                   |
 | `resolveNameServiceNames`    | No direct equivalent for listing every name assigned to an address    |
 
+The JSON-RPC `getDynamicFieldObject` method returned an object for both field kinds. For a regular
+dynamic field, it returned the `0x2::dynamic_field::Field<Name, Value>` object. For a dynamic object
+field, it derived the wrapper field, extracted its child ID, and returned the referenced child
+object instead of the wrapper.
+
+The replacement APIs expose these operations separately. `getDynamicField` returns a normalized
+field entry and its BCS-encoded value. `getDynamicObjectField` derives the wrapper, extracts the
+child ID, and loads the referenced object. If the field kind is not known in advance, call
+`listDynamicFields` and check whether its `$kind` is `DynamicField` or `DynamicObject`. SDKs can
+call the same methods through `client.core`.
+
+```typescript
+const page = await client.listDynamicFields({ parentId });
+
+for (const field of page.dynamicFields) {
+	if (field.$kind === 'DynamicObject') {
+		const { object } = await client.getDynamicObjectField({
+			parentId,
+			name: field.name,
+			include: { content: true },
+		});
+
+		console.log(object.objectId, object.content);
+	} else {
+		const { dynamicField } = await client.getDynamicField({
+			parentId,
+			name: field.name,
+		});
+
+		console.log(dynamicField.value.type, dynamicField.value.bcs);
+	}
+}
+```
+
+The dynamic object field wrapper remains accessible through `getDynamicField`. Wrap the name type
+explicitly and pass the original name BCS bytes:
+
+```typescript
+const { dynamicField } = await client.getDynamicField({
+	parentId,
+	name: {
+		type: `0x2::dynamic_object_field::Wrapper<${fieldName.type}>`,
+		bcs: fieldName.bcs,
+	},
+});
+
+console.log(dynamicField.fieldId, dynamicField.childId);
+```
+
 `getMoveFunction` exposes normalized parameter signatures, but it does not reproduce the legacy
 `Pure`, `Object`, and object-access classifications from `getMoveFunctionArgTypes`. Likewise,
 `defaultNameServiceName` and raw gRPC `nameService.reverseLookupName` return only the configured

package/docs/transactions/basics.md

@@ -126,14 +126,13 @@ incorrect target strings. See the [codegen documentation](/codegen) for setup in
 
 ### Return values
 
-Commands return results that you can use as input to subsequent commands. For example, `splitCoins`
-returns the new coins it creates:
+Helpers and commands return results that you can use as input to subsequent commands. For example,
+`tx.coin()` creates a coin with the requested balance:
 
 ```typescript
 const tx = new Transaction();
 
-// splitCoins returns one result per amount
-const [coin] = tx.splitCoins(tx.gas, [1_000_000]);
+const coin = tx.coin({ balance: 1_000_000 });
 
 // Use that result as input to another command
 tx.transferObjects([coin], '0xRecipientAddress');
@@ -256,21 +255,27 @@ libraries.
 
 ## Serializing transactions
 
-Serialize a transaction to JSON for storage, transmission, or later reconstruction:
+`build()` produces BCS bytes for signing. With a client it resolves object versions, gas, and
+intents like `tx.coin()` first. If everything is already set, no client is needed (see
+[Building Offline](./offline)):
 
 ```typescript
-// Serialize to JSON — with a client, resolves any unresolved data first
-const json = await tx.toJSON({ client: grpcClient });
-
-// Serialize without a client — intents like tx.coin() are preserved as-is
-const json = await tx.toJSON();
+const bytes = await tx.build({ client: grpcClient });
 
-// Reconstruct from JSON
-const tx = Transaction.from(json);
+// Only the inputs and commands, without sender or gas data
+const kindBytes = await tx.build({ client: grpcClient, onlyTransactionKind: true });
 ```
 
-This is useful for passing transactions between a frontend and backend, or for storing pre-built
-transactions.
+`toJSON()` produces an editable representation for storage or for passing between a frontend and
+backend. It resolves intents like `tx.coin()` but leaves sender and gas data as they are:
+
+```typescript
+const json = await tx.toJSON({ client: grpcClient });
+const restored = Transaction.from(json);
+
+// Or keep tx.coin() intents for the receiver to resolve
+const jsonWithIntents = await tx.toJSON({ supportedIntents: ['CoinWithBalance'] });
+```
 
 ## Executing transactions
 

package/docs/transactions/offline.md

@@ -2,69 +2,132 @@
 
 > Build transactions without a network connection
 
-Normally the SDK resolves object versions, estimates gas, and fills in other details by querying the
-network. For offline building of backend services, air-gapped signing, or pre-built transactions,
-you must provide this information yourself. See also the Sui documentation on
+Normally `build()` queries the network to resolve object versions, resolve intents like `tx.coin()`,
+fetch the gas price, estimate the gas budget, pick gas coins, and set an expiration when gas is paid
+from address balance. To build without a client, provide that information yourself. See also the Sui
+documentation on
 [offline signing](https://docs.sui.io/guides/developer/transactions/transaction-auth/offline-signing)
 for the protocol-level details.
 
-## Transactions without owned object inputs
+## Building only the transaction kind
 
-When your transaction only uses shared objects, party objects, and/or address balance withdrawals,
-there are no owned object versions to look up. Use `tx.withdrawal()` directly instead of `tx.coin()`
-or `coinWithBalance` because they require a client to resolve coin objects at build time.
+If the next step only needs the inputs and commands (for example, a sponsor or a backend that fills
+in gas), build with `onlyTransactionKind`. Sender, gas data, and expiration are left out:
 
 ```typescript
 
 const tx = new Transaction();
-
-// Use tx.withdrawal() + coin::redeem_funds to withdraw from address balance.
-// No coin object lookups needed — fully offline.
-const [coin] = tx.moveCall({
-	target: '0x2::coin::redeem_funds',
-	typeArguments: ['0x2::sui::SUI'],
-	arguments: [tx.withdrawal({ amount: 1_000_000_000 })],
+tx.moveCall({
+	target: '0xPackage::module::function',
+	arguments: [tx.pure.u64(100)],
 });
-tx.transferObjects([coin], '0xRecipientAddress');
 
-// Shared/party objects only need objectId + initialSharedVersion (both stable)
+const kindBytes = await tx.build({ onlyTransactionKind: true });
+```
+
+Inputs and intents still need to be resolved. Use full object references, `tx.withdrawal()`, or
+[`assumeSufficientAddressBalances`](#coin-and-balance-intents) so nothing needs a lookup.
+
+## Building full transaction bytes
+
+A full offline build needs the sender and all gas data:
+
+| Method            | Description                                                     |
+| ----------------- | --------------------------------------------------------------- |
+| `setSender()`     | The address executing the transaction                           |
+| `setGasPrice()`   | Reference gas price (query `getReferenceGasPrice()` beforehand) |
+| `setGasBudget()`  | Maximum gas to spend (in MIST). Estimating it requires a client |
+| `setGasPayment()` | Coin object references, or `[]` to pay gas from address balance |
+| `setGasOwner()`   | Only for sponsored transactions. Defaults to the sender         |
+
+### Paying gas from address balance
+
+With `setGasPayment([])`, gas is paid from the gas owner's SUI address balance. Nothing ties the
+transaction to a specific object version, so it also needs a `ValidDuring` expiration for replay
+protection:
+
+```typescript
+
+// Look these up before going offline
+const referenceGasPrice = 1000n;
+const currentEpoch = 100;
+const chainIdentifier = 'Base58ChainIdentifier'; // from getChainIdentifier()
+
+const tx = new Transaction();
+
+// FundsWithdrawal inputs contain the amount and type, so no object lookup is needed
 tx.moveCall({
-	target: '0xPackage::module::function',
-	arguments: [
-		tx.sharedObjectRef({
-			objectId: '0xSharedObjectId',
-			initialSharedVersion: '1',
-			mutable: true,
-		}),
-	],
+	target: '0x2::balance::send_funds',
+	typeArguments: ['0x2::sui::SUI'],
+	arguments: [tx.withdrawal({ amount: 1_000_000_000 }), tx.pure.address('0xRecipientAddress')],
 });
 
-// Required configuration for all offline builds
 tx.setSender('0xSenderAddress');
-tx.setGasPrice(1000); // query getReferenceGasPrice() beforehand, or use a known value
+tx.setGasPrice(referenceGasPrice);
 tx.setGasBudget(50_000_000);
-tx.setGasPayment([]); // empty array = pay gas from address balance
+tx.setGasPayment([]);
 
-// Expiration is required when there are no owned objects for gas or inputs
 tx.setExpiration({
 	ValidDuring: {
-		minEpoch: 100, // current epoch
-		maxEpoch: 101, // current epoch + 1
+		minEpoch: currentEpoch,
+		maxEpoch: currentEpoch + 1,
 		minTimestamp: null,
 		maxTimestamp: null,
-		chain: 'mainnet', // or 'testnet', 'devnet'
-		nonce: 0,
+		chain: chainIdentifier,
+		// Must be unique for each transaction in the validity window, including across restarts
+		nonce: await nonceStore.next(),
 	},
 });
 
-// Build without a client
 const bytes = await tx.build();
 ```
 
-This enables fully stateless construction. You only need the sender address, reference gas price,
-epoch, and chain identifier.
+Two otherwise-identical transactions with the same nonce have the same digest, and the second one is
+rejected as a duplicate. Use a counter that survives restarts, not a hard-coded value.
+
+The address balance needs to cover the gas budget on top of any withdrawals. Don't add the budget to
+the withdrawal amount.
+
+`{ Epoch: n }` expiration does not provide replay protection. Use `ValidDuring`.
 
-## Party objects
+### Paying gas with coin objects
+
+Gas coins need an exact version and digest. Other SUI can still come from address balance:
+
+```typescript
+
+const tx = new Transaction();
+tx.moveCall({
+	target: '0x2::balance::send_funds',
+	typeArguments: ['0x2::sui::SUI'],
+	arguments: [
+		tx.balance({ balance: 1_000_000, useGasCoin: false }),
+		tx.pure.address('0xRecipientAddress'),
+	],
+});
+
+tx.setSender('0xSenderAddress');
+tx.setGasPrice(1000);
+tx.setGasBudget(50_000_000);
+tx.setGasPayment([{ objectId: '0xGasCoinId', version: '3', digest: 'Base58GasCoinDigest' }]);
+
+// assumeSufficientAddressBalances resolves tx.balance() without a client (see below)
+const bytes = await tx.build({ assumeSufficientAddressBalances: true });
+```
+
+## Object inputs
+
+### Shared and party objects
+
+Shared objects only need `objectId` and `initialSharedVersion`, both of which are stable:
+
+```typescript
+tx.sharedObjectRef({
+	objectId: '0xSharedObjectId',
+	initialSharedVersion: '1',
+	mutable: true,
+});
+```
 
 Party objects are address-owned but consensus-versioned, with per-address permissions. They are
 referenced the same way as shared objects:
@@ -83,12 +146,11 @@ Key properties for offline building:
   becomes a party object
 - **Enable pipelining**: Submit multiple transactions on the same party object without waiting for
   each one to finalize
-- **Cannot be used for gas**: Use address balance for gas payment (`setGasPayment([])`)
+- **Cannot be used for gas**: Pay gas from address balance or with a SUI coin object
 
-## Transactions with owned object inputs
+### Owned and immutable objects
 
-When your transaction uses owned or immutable objects, you must provide the exact version and digest
-for each one:
+Owned and immutable objects need the exact version and digest:
 
 ```typescript
 
@@ -122,71 +184,58 @@ tx.moveCall({
 		}),
 	],
 });
-
-// Gas payment with specific coin objects
-tx.setGasPayment([{ objectId: '0xGasCoinId', version: '3', digest: 'jkl012...' }]);
-
-tx.setSender('0xSenderAddress');
-tx.setGasPrice(1000);
-tx.setGasBudget(50_000_000);
-
-const bytes = await tx.build();
 ```
 
-## Required configuration for all offline builds
+## Coin and balance intents
 
-Every offline-built transaction must have the following:
+`tx.coin()` and `tx.balance()` normally look up the sender's address balance and coin objects. Pass
+`assumeSufficientAddressBalances` to skip the lookups and withdraw from address balance instead:
 
-| Method            | Description                                                     |
-| ----------------- | --------------------------------------------------------------- |
-| `setSender()`     | The address executing the transaction                           |
-| `setGasPrice()`   | Reference gas price (query `getReferenceGasPrice()` beforehand) |
-| `setGasBudget()`  | Maximum gas to spend (in MIST)                                  |
-| `setGasPayment()` | Coin object references, or `[]` for address balance             |
+```typescript
 
-### Expiration
+const tx = new Transaction();
+tx.moveCall({
+	target: '0x2::balance::send_funds',
+	typeArguments: ['0xPackage::module::TOKEN'],
+	arguments: [
+		tx.balance({ type: '0xPackage::module::TOKEN', balance: 1_000_000 }),
+		tx.pure.address('0xRecipientAddress'),
+	],
+});
 
-Set an expiration when your transaction uses no owned objects for gas or inputs. This applies when
-you use address balances for gas (`setGasPayment([])`) with only shared and party object inputs:
+// The sender is still required, since the withdrawal comes from its address balance
+tx.setSender('0xSenderAddress');
 
-```typescript
-tx.setExpiration({
-	ValidDuring: {
-		minEpoch: 100, // current epoch
-		maxEpoch: 101, // typically current epoch + 1
-		minTimestamp: null,
-		maxTimestamp: null,
-		chain: 'mainnet',
-		nonce: 0, // increment for multiple transactions in the same epoch
-	},
+const kindBytes = await tx.build({
+	onlyTransactionKind: true,
+	assumeSufficientAddressBalances: true,
 });
 ```
 
-You can also use epoch-based expiration:
+> **Warning:** Nothing is checked. The transaction builds, then fails at execution if the address balance doesn't
+> cover it.
 
-```typescript
-tx.setExpiration({ Epoch: 100 });
-```
+SUI intents withdraw from address balance too, whether or not the transaction also uses `tx.gas`.
+This matches an online build when the address balance is sufficient. Mixing default and
+`useGasCoin: false` SUI intents in one transaction is still an error.
 
-> **Note:** When building with a client, the SDK sets expiration automatically. You only need the manual
-> configuration above for fully offline builds.
+On a full build, the option also sets an unset gas payment to `[]`, but only when nothing else needs
+a client, the transaction doesn't use `tx.gas`, and a `ValidDuring` or `Validity` expiration is
+already set. Sender, gas price, and gas budget still need to be provided. Once set, the empty
+payment is part of the transaction, the same as calling `setGasPayment([])`.
 
 ## Serialization
 
-### Building to bytes
+`toJSON()` resolves async thunks and intents but does not fill in gas or object versions. Pass
+`supportedIntents` to keep an intent for another system to resolve:
 
 ```typescript
-// Build to BCS bytes (Uint8Array) — fully offline, all data must be provided
-const bytes = await tx.build();
-
-// Build with a client — only makes network requests when there is unresolved data to look up
-const bytes = await tx.build({ client: grpcClient });
-```
+// Intents are resolved, so tx.coin() needs a client or assumeSufficientAddressBalances
+const json = await tx.toJSON({ assumeSufficientAddressBalances: true });
+const restored = Transaction.from(json);
 
-### Converting bytes back to a Transaction
-
-```typescript
-const tx = Transaction.from(bytes);
+// Or keep tx.coin() intents for the receiver to resolve
+const jsonWithIntents = await tx.toJSON({ supportedIntents: ['CoinWithBalance'] });
 ```
 
-This works with BCS byte arrays, base64-encoded strings, and JSON strings (from `toJSON()`).
+`Transaction.from()` accepts JSON strings, BCS bytes, and base64-encoded BCS.

package/package.json

@@ -3,7 +3,7 @@
   "author": "Mysten Labs <build@mystenlabs.com>",
   "description": "Sui TypeScript API",
   "homepage": "https://sdk.mystenlabs.com",
-  "version": "2.29.0",
+  "version": "2.30.0",
   "license": "Apache-2.0",
   "sideEffects": false,
   "files": [
@@ -151,7 +151,7 @@
     "typescript": "^7.0.2",
     "vite": "^8.2.1",
     "vite-tsconfig-paths": "^6.0.4",
-    "vitest": "^4.1.10",
+    "vitest": "^4.1.11",
     "wait-on": "^9.1.0"
   },
   "dependencies": {

package/src/client/core-resolver.ts

@@ -17,6 +17,7 @@ import { getPureBcsSchema, isTxContext } from '../transactions/serializer.js';
 import type { TransactionDataBuilder } from '../transactions/TransactionData.js';
 import { chunk } from '@mysten/utils';
 import type { BuildTransactionOptions } from '../transactions/index.js';
+import { transactionUsesGasCoin } from '../transactions/resolution-utils.js';
 
 // The maximum objects that can be fetched at once using multiGetObjects.
 const MAX_OBJECTS_PER_FETCH = 50;
@@ -54,19 +55,13 @@ export async function coreClientResolveTransactionPlugin(
 	next: () => Promise<void>,
 ) {
 	const client = getClient(options);
-
 	const needsGasPrice = !options.onlyTransactionKind && !transactionData.gasData.price;
 	const needsPayment = !options.onlyTransactionKind && !transactionData.gasData.payment;
 	const gasPayer = transactionData.gasData.owner ?? transactionData.sender;
 
-	let usesGasCoin = false;
+	const usesGasCoin = transactionUsesGasCoin(transactionData);
 	let withdrawals = 0n;
 
-	transactionData.mapArguments((arg) => {
-		if (arg.$kind === 'GasCoin') usesGasCoin = true;
-		return arg;
-	});
-
 	const normalizedGasPayer = gasPayer ? normalizeSuiAddress(gasPayer) : null;
 	for (const input of transactionData.inputs) {
 		if (input.$kind !== 'FundsWithdrawal' || !normalizedGasPayer) continue;

package/src/transactions/Transaction.ts

@@ -37,7 +37,6 @@ import {
 	coinWithBalance,
 	createBalance,
 } from './intents/CoinWithBalance.js';
-import type { ClientWithCoreApi } from '../client/core.js';
 
 export type TransactionObjectArgument =
 	| Exclude<InferInput<typeof ArgumentSchema>, { Input: unknown; type?: 'pure' }>
@@ -802,9 +801,7 @@ export class Transaction {
 
 	/** Derive transaction digest */
 	async getDigest(
-		options: {
-			client?: ClientWithCoreApi;
-		} = {},
+		options: Pick<BuildTransactionOptions, 'client' | 'assumeSufficientAddressBalances'> = {},
 	): Promise<string> {
 		await this.prepareForSerialization(options);
 		await this.#prepareBuild(options);

package/src/transactions/intents/CoinWithBalance.ts

@@ -178,37 +178,44 @@ export async function resolveCoinBalance(
 	const coinsByType = new Map<string, SuiClientTypes.Coin[]>();
 	const addressBalanceByType = new Map<string, bigint>();
 	const client = buildOptions.client;
+	const assumeSufficientAddressBalances = buildOptions.assumeSufficientAddressBalances;
 
-	if (!client) {
+	if (!client && !assumeSufficientAddressBalances) {
 		throw new Error(
 			'Client must be provided to build or serialize transactions with CoinWithBalance intents',
 		);
 	}
 
-	await Promise.all([
-		...[...coinTypes].map(async (coinType) => {
-			const { coins, addressBalance } = await getCoinsAndBalanceOfType({
-				coinType,
-				balance: totalByType.get(coinType)!,
-				client,
-				owner: transactionData.sender!,
-				usedIds,
-			});
-
-			coinsByType.set(coinType, coins);
-			addressBalanceByType.set(coinType, addressBalance);
-		}),
-		totalByType.has('gas')
-			? await client.core
-					.getBalance({
-						owner: transactionData.sender!,
-						coinType: SUI_TYPE,
-					})
-					.then(({ balance }) => {
-						addressBalanceByType.set('gas', BigInt(balance.addressBalance));
-					})
-			: null,
-	]);
+	if (assumeSufficientAddressBalances) {
+		for (const [coinType, balance] of totalByType) {
+			addressBalanceByType.set(coinType, balance);
+		}
+	} else {
+		await Promise.all([
+			...[...coinTypes].map(async (coinType) => {
+				const { coins, addressBalance } = await getCoinsAndBalanceOfType({
+					coinType,
+					balance: totalByType.get(coinType)!,
+					client: client!,
+					owner: transactionData.sender!,
+					usedIds,
+				});
+
+				coinsByType.set(coinType, coins);
+				addressBalanceByType.set(coinType, addressBalance);
+			}),
+			totalByType.has('gas')
+				? await client!.core
+						.getBalance({
+							owner: transactionData.sender!,
+							coinType: SUI_TYPE,
+						})
+						.then(({ balance }) => {
+							addressBalanceByType.set('gas', BigInt(balance.addressBalance));
+						})
+				: null,
+		]);
+	}
 
 	const exactBalanceByType = new Map<string, boolean>();
 	const usedAddressBalance = new Set<string>();

package/src/transactions/resolution-utils.ts

@@ -0,0 +1,18 @@
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+import type { TransactionDataBuilder } from './TransactionData.js';
+
+export function transactionUsesGasCoin(transactionData: TransactionDataBuilder) {
+	let usesGasCoin = false;
+
+	transactionData.mapArguments((arg) => {
+		if (arg.$kind === 'GasCoin') {
+			usesGasCoin = true;
+		}
+
+		return arg;
+	});
+
+	return usesGasCoin;
+}