@mysten/sui 1.28.2 → 1.29.1

package/src/graphql/queries/getAllBalances.graphql

@@ -0,0 +1,20 @@
+# Copyright (c) Mysten Labs, Inc.
+# SPDX-License-Identifier: Apache-2.0
+
+query getAllBalances($owner: SuiAddress!, $limit: Int, $cursor: String) {
+	address(address: $owner) {
+		balances(first: $limit, after: $cursor) {
+			pageInfo {
+				hasNextPage
+				endCursor
+			}
+			nodes {
+				coinType {
+					repr
+				}
+				coinObjectCount
+				totalBalance
+			}
+		}
+	}
+}

package/src/graphql/queries/getBalance.graphql

@@ -0,0 +1,14 @@
+# Copyright (c) Mysten Labs, Inc.
+# SPDX-License-Identifier: Apache-2.0
+
+query getBalance($owner: SuiAddress!, $type: String = "0x2::sui::SUI") {
+	address(address: $owner) {
+		balance(type: $type) {
+			coinType {
+				repr
+			}
+			coinObjectCount
+			totalBalance
+		}
+	}
+}

package/src/graphql/queries/getCoins.graphql

@@ -0,0 +1,29 @@
+# Copyright (c) Mysten Labs, Inc.
+# SPDX-License-Identifier: Apache-2.0
+
+query getCoins($owner: SuiAddress!, $first: Int, $cursor: String, $type: String = "0x2::sui::SUI") {
+	address(address: $owner) {
+		address
+		coins(first: $first, after: $cursor, type: $type) {
+			pageInfo {
+				hasNextPage
+				endCursor
+			}
+			nodes {
+				coinBalance
+				owner {
+					...OBJECT_OWNER_FIELDS
+				}
+				contents {
+					bcs
+					type {
+						repr
+					}
+				}
+				address
+				version
+				digest
+			}
+		}
+	}
+}

package/src/graphql/queries/getDynamicFields.graphql

@@ -0,0 +1,36 @@
+# Copyright (c) Mysten Labs, Inc.
+# SPDX-License-Identifier: Apache-2.0
+
+query getDynamicFields($parentId: SuiAddress!, $first: Int, $cursor: String) {
+	owner(address: $parentId) {
+		dynamicFields(first: $first, after: $cursor) {
+			pageInfo {
+				hasNextPage
+				endCursor
+			}
+			nodes {
+				name {
+					bcs
+					type {
+						repr
+					}
+				}
+				value {
+					__typename
+					... on MoveValue {
+						type {
+							repr
+						}
+					}
+					... on MoveObject {
+						contents {
+							type {
+								repr
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+}

package/src/graphql/queries/getReferenceGasPrice.graphql

@@ -0,0 +1,8 @@
+# Copyright (c) Mysten Labs, Inc.
+# SPDX-License-Identifier: Apache-2.0
+
+query getReferenceGasPrice {
+	epoch {
+		referenceGasPrice
+	}
+}

package/src/graphql/queries/objects.graphql

@@ -0,0 +1,89 @@
+# Copyright (c) Mysten Labs, Inc.
+# SPDX-License-Identifier: Apache-2.0
+
+query getOwnedObjects($owner: SuiAddress!, $limit: Int, $cursor: String, $filter: ObjectFilter) {
+	address(address: $owner) {
+		objects(first: $limit, after: $cursor, filter: $filter) {
+			pageInfo {
+				hasNextPage
+				endCursor
+			}
+			nodes {
+				...MOVE_OBJECT_FIELDS
+			}
+		}
+	}
+}
+
+query multiGetObjects($objectIds: [SuiAddress!]!, $limit: Int, $cursor: String) {
+	objects(first: $limit, after: $cursor, filter: { objectIds: $objectIds }) {
+		pageInfo {
+			hasNextPage
+			endCursor
+		}
+		nodes {
+			...OBJECT_FIELDS
+		}
+	}
+}
+
+fragment OBJECT_FIELDS on Object {
+	address
+	digest
+	version
+	asMoveObject {
+		contents {
+			bcs
+			type {
+				repr
+			}
+		}
+	}
+	owner {
+		...OBJECT_OWNER_FIELDS
+	}
+}
+
+fragment MOVE_OBJECT_FIELDS on MoveObject {
+	address
+	digest
+	version
+	contents {
+		bcs
+		type {
+			repr
+		}
+	}
+	owner {
+		...OBJECT_OWNER_FIELDS
+	}
+}
+
+fragment OBJECT_OWNER_FIELDS on ObjectOwner {
+	__typename
+	... on AddressOwner {
+		owner {
+			asObject {
+				address
+			}
+			asAddress {
+				address
+			}
+		}
+	}
+	... on Parent {
+		parent {
+			address
+		}
+	}
+	... on Shared {
+		initialSharedVersion
+	}
+	... on ConsensusV2 {
+		authenticator {
+			... on Address {
+				address
+			}
+		}
+	}
+}

package/src/graphql/queries/transactions.graphql

@@ -0,0 +1,80 @@
+# Copyright (c) Mysten Labs, Inc.
+# SPDX-License-Identifier: Apache-2.0
+
+query dryRunTransactionBlock($txBytes: String!) {
+	dryRunTransactionBlock(txBytes: $txBytes) {
+		error
+		transaction {
+			...TRANSACTION_FIELDS
+		}
+	}
+}
+
+mutation executeTransactionBlock($txBytes: String!, $signatures: [String!]!) {
+	executeTransactionBlock(txBytes: $txBytes, signatures: $signatures) {
+		errors
+		effects {
+			transactionBlock {
+				...TRANSACTION_FIELDS
+			}
+		}
+	}
+}
+
+query getTransactionBlock($digest: String!) {
+	transactionBlock(digest: $digest) {
+		...TRANSACTION_FIELDS
+	}
+}
+
+fragment TRANSACTION_FIELDS on TransactionBlock {
+	digest
+	bcs
+	signatures
+	effects {
+		bcs
+		unchangedSharedObjects {
+			nodes {
+				__typename
+				... on SharedObjectRead {
+					object {
+						asMoveObject {
+							address
+							contents {
+								type {
+									repr
+								}
+							}
+						}
+					}
+				}
+			}
+		}
+		objectChanges {
+			nodes {
+				address
+				inputState {
+					version
+					asMoveObject {
+						address
+						contents {
+							type {
+								repr
+							}
+						}
+					}
+				}
+				outputState {
+					asMoveObject {
+						address
+						contents {
+							type {
+								repr
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+}

package/src/graphql/queries/verifyZkLoginSignature.graphql

@@ -0,0 +1,16 @@
+query verifyZkLoginSignature(
+	$bytes: Base64!
+	$signature: Base64!
+	$intentScope: ZkLoginIntentScope!
+	$author: SuiAddress!
+) {
+	verifyZkloginSignature(
+		bytes: $bytes
+		signature: $signature
+		intentScope: $intentScope
+		author: $author
+	) {
+		success
+		errors
+	}
+}

package/src/multisig/publickey.ts

@@ -14,10 +14,10 @@ import {
 } from '../cryptography/signature-scheme.js';
 import type { SignatureFlag, SignatureScheme } from '../cryptography/signature-scheme.js';
 import { parseSerializedSignature } from '../cryptography/signature.js';
-import type { SuiGraphQLClient } from '../graphql/client.js';
 import { normalizeSuiAddress } from '../utils/sui-types.js';
 // eslint-disable-next-line import/no-cycle
 import { publicKeyFromRawBytes } from '../verify/index.js';
+import type { ZkLoginCompatibleClient } from '../zklogin/publickey.js';
 import { toZkLoginPublicIdentifier } from '../zklogin/publickey.js';
 import { MultiSigSigner } from './signer.js';
 
@@ -76,7 +76,7 @@ export class MultiSigPublicKey extends PublicKey {
 		 *  MultiSig public key as buffer or base-64 encoded string
 		 */
 		value: string | Uint8Array | MultiSigPublicKeyStruct,
-		options: { client?: SuiGraphQLClient } = {},
+		options: { client?: ZkLoginCompatibleClient } = {},
 	) {
 		super();
 
@@ -315,7 +315,7 @@ export class MultiSigPublicKey extends PublicKey {
  */
 export function parsePartialSignatures(
 	multisig: MultiSigStruct,
-	options: { client?: SuiGraphQLClient } = {},
+	options: { client?: ZkLoginCompatibleClient } = {},
 ): ParsedPartialMultiSigSignature[] {
 	const res: ParsedPartialMultiSigSignature[] = new Array(multisig.sigs.length);
 	for (let i = 0; i < multisig.sigs.length; i++) {

package/src/transactions/Commands.ts

@@ -8,11 +8,12 @@ import { parse } from 'valibot';
 import { normalizeSuiObjectId } from '../utils/sui-types.js';
 import { Argument } from './data/internal.js';
 import type { CallArg, Command } from './data/internal.js';
-import type { Transaction } from './Transaction.js';
+import type { AsyncTransactionThunk, Transaction } from './Transaction.js';
 
 export type TransactionArgument =
 	| InferInput<typeof Argument>
-	| ((tx: Transaction) => InferInput<typeof Argument>);
+	| ((tx: Transaction) => InferInput<typeof Argument>)
+	| AsyncTransactionThunk;
 export type TransactionInput = CallArg;
 
 // Keep in sync with constants in

package/src/transactions/Transaction.ts

@@ -29,11 +29,20 @@ import { getIdFromCallArg } from './utils.js';
 
 export type TransactionObjectArgument =
 	| Exclude<InferInput<typeof Argument>, { Input: unknown; type?: 'pure' }>
-	| ((tx: Transaction) => Exclude<InferInput<typeof Argument>, { Input: unknown; type?: 'pure' }>);
+	| ((tx: Transaction) => Exclude<InferInput<typeof Argument>, { Input: unknown; type?: 'pure' }>)
+	| AsyncTransactionThunk<TransactionResultArgument>;
 
 export type TransactionResult = Extract<Argument, { Result: unknown }> &
 	Extract<Argument, { NestedResult: unknown }>[];
 
+export type TransactionResultArgument =
+	| Extract<Argument, { Result: unknown }>
+	| readonly Extract<Argument, { NestedResult: unknown }>[];
+
+export type AsyncTransactionThunk<
+	T extends TransactionResultArgument | void = TransactionResultArgument | void,
+> = (tx: Transaction) => Promise<T | void>;
+
 function createTransactionResult(index: number, length = Infinity): TransactionResult {
 	const baseResult = { $kind: 'Result' as const, Result: index };
 
@@ -128,6 +137,9 @@ function getGlobalPluginRegistry() {
 	}
 }
 
+type InputSection = (CallArg | InputSection)[];
+type CommandSection = (Command | CommandSection)[];
+
 /**
  * Transaction Builder
  */
@@ -135,6 +147,11 @@ export class Transaction {
 	#serializationPlugins: TransactionPlugin[];
 	#buildPlugins: TransactionPlugin[];
 	#intentResolvers = new Map<string, TransactionPlugin>();
+	#inputSection: InputSection = [];
+	#commandSection: CommandSection = [];
+	#availableResults: Set<number> = new Set();
+	#pendingPromises = new Set<Promise<unknown>>();
+	#added = new Map<(...args: any[]) => unknown, unknown>();
 
 	/**
 	 * Converts from a serialize transaction kind (built with `build({ onlyTransactionKind: true })`) to a `Transaction` class.
@@ -147,6 +164,9 @@ export class Transaction {
 			typeof serialized === 'string' ? fromBase64(serialized) : serialized,
 		);
 
+		tx.#inputSection = tx.#data.inputs;
+		tx.#commandSection = tx.#data.commands;
+
 		return tx;
 	}
 
@@ -169,6 +189,9 @@ export class Transaction {
 			newTransaction.#data = TransactionDataBuilder.restore(JSON.parse(transaction));
 		}
 
+		newTransaction.#inputSection = newTransaction.#data.inputs;
+		newTransaction.#commandSection = newTransaction.#data.commands;
+
 		return newTransaction;
 	}
 
@@ -281,7 +304,7 @@ export class Transaction {
 			enumerable: false,
 			value: createPure<Argument>((value): Argument => {
 				if (isSerializedBcs(value)) {
-					return this.#data.addInput('pure', {
+					return this.#addInput('pure', {
 						$kind: 'Pure',
 						Pure: {
 							bytes: value.toBase64(),
@@ -290,7 +313,7 @@ export class Transaction {
 				}
 
 				// TODO: we can also do some deduplication here
-				return this.#data.addInput(
+				return this.#addInput(
 					'pure',
 					is(NormalizedCallArg, value)
 						? parse(NormalizedCallArg, value)
@@ -324,7 +347,7 @@ export class Transaction {
 	> = createObjectMethods(
 		(value: TransactionObjectInput): { $kind: 'Input'; Input: number; type?: 'object' } => {
 			if (typeof value === 'function') {
-				return this.object(value(this));
+				return this.object(this.add(value as (tx: Transaction) => TransactionObjectArgument));
 			}
 
 			if (typeof value === 'object' && is(Argument, value)) {
@@ -347,7 +370,7 @@ export class Transaction {
 
 			return inserted
 				? { $kind: 'Input', Input: this.#data.inputs.indexOf(inserted), type: 'object' }
-				: this.#data.addInput(
+				: this.#addInput(
 						'object',
 						typeof value === 'string'
 							? {
@@ -383,15 +406,106 @@ export class Transaction {
 		return this.object(Inputs.SharedObjectRef(...args));
 	}
 
+	#fork() {
+		const fork = new Transaction();
+
+		fork.#data = this.#data;
+		fork.#serializationPlugins = this.#serializationPlugins;
+		fork.#buildPlugins = this.#buildPlugins;
+		fork.#intentResolvers = this.#intentResolvers;
+		fork.#pendingPromises = this.#pendingPromises;
+		fork.#availableResults = new Set(this.#availableResults);
+		fork.#added = this.#added;
+		this.#inputSection.push(fork.#inputSection);
+		this.#commandSection.push(fork.#commandSection);
+
+		return fork;
+	}
+
 	/** Add a transaction to the transaction */
-	add<T = TransactionResult>(command: Command | ((tx: Transaction) => T)): T {
+
+	add<T extends Command>(command: T): TransactionResult;
+	add<T extends void | TransactionResultArgument | TransactionArgument | Command>(
+		thunk: (tx: Transaction) => T,
+	): T;
+	add<T extends TransactionResultArgument | void>(
+		asyncTransactionThunk: AsyncTransactionThunk<T>,
+	): T;
+	add(command: Command | AsyncTransactionThunk | ((tx: Transaction) => unknown)): unknown {
 		if (typeof command === 'function') {
-			return command(this);
+			if (this.#added.has(command)) {
+				return this.#added.get(command);
+			}
+
+			const fork = this.#fork();
+			const result = command(fork);
+
+			if (!(result && typeof result === 'object' && 'then' in result)) {
+				this.#availableResults = fork.#availableResults;
+				this.#added.set(command, result);
+				return result;
+			}
+
+			const placeholder = this.#addCommand({
+				$kind: '$Intent',
+				$Intent: {
+					name: 'AsyncTransactionThunk',
+					inputs: {},
+					data: {
+						result: null as TransactionResult | null,
+					},
+				},
+			});
+
+			this.#pendingPromises.add(
+				Promise.resolve(result as Promise<TransactionResult>).then((result) => {
+					placeholder.$Intent.data.result = result;
+				}),
+			);
+			const txResult = createTransactionResult(this.#data.commands.length - 1);
+			this.#added.set(command, txResult);
+			return txResult;
+		} else {
+			this.#addCommand(command);
 		}
 
-		const index = this.#data.commands.push(command);
+		return createTransactionResult(this.#data.commands.length - 1);
+	}
+
+	#addCommand<T extends Command>(command: T) {
+		const resultIndex = this.#data.commands.length;
+		this.#commandSection.push(command);
+		this.#availableResults.add(resultIndex);
+		this.#data.commands.push(command);
+
+		this.#data.mapCommandArguments(resultIndex, (arg) => {
+			if (arg.$kind === 'Result' && !this.#availableResults.has(arg.Result)) {
+				throw new Error(
+					`Result { Result: ${arg.Result} } is not available to use the current transaction`,
+				);
+			}
 
-		return createTransactionResult(index - 1) as T;
+			if (arg.$kind === 'NestedResult' && !this.#availableResults.has(arg.NestedResult[0])) {
+				throw new Error(
+					`Result { NestedResult: [${arg.NestedResult[0]}, ${arg.NestedResult[1]}] } is not available to use the current transaction`,
+				);
+			}
+
+			if (arg.$kind === 'Input' && arg.Input >= this.#data.inputs.length) {
+				throw new Error(
+					`Input { Input: ${arg.Input} } references an input that does not exist in the current transaction`,
+				);
+			}
+
+			return arg;
+		});
+
+		return command;
+	}
+
+	#addInput<T extends 'pure' | 'object'>(type: T, input: CallArg) {
+		this.#inputSection.push(input);
+		return this.#data.addInput(type, input);
 	}
 
 	#normalizeTransactionArgument(arg: TransactionArgument | SerializedBcs<any>) {
@@ -404,7 +518,13 @@ export class Transaction {
 
 	#resolveArgument(arg: TransactionArgument): Argument {
 		if (typeof arg === 'function') {
-			return parse(Argument, arg(this));
+			const resolved = this.add(arg as never);
+
+			if (typeof resolved === 'function') {
+				return this.#resolveArgument(resolved);
+			}
+
+			return parse(Argument, resolved);
 		}
 
 		return parse(Argument, arg);
@@ -423,8 +543,8 @@ export class Transaction {
 					: this.#normalizeTransactionArgument(amount),
 			),
 		);
-		const index = this.#data.commands.push(command);
-		return createTransactionResult(index - 1, amounts.length) as Extract<
+		this.#addCommand(command);
+		return createTransactionResult(this.#data.commands.length - 1, amounts.length) as Extract<
 			Argument,
 			{ Result: unknown }
 		> & {
@@ -611,9 +731,92 @@ export class Transaction {
 		};
 
 		await createNext(0)();
+
+		this.#inputSection = this.#data.inputs;
+		this.#commandSection = this.#data.commands;
+	}
+
+	async #waitForPendingTasks() {
+		while (this.#pendingPromises.size > 0) {
+			const newPromise = Promise.all(this.#pendingPromises);
+			this.#pendingPromises.clear();
+			this.#pendingPromises.add(newPromise);
+			await newPromise;
+			this.#pendingPromises.delete(newPromise);
+		}
+	}
+
+	#sortCommandsAndInputs() {
+		const unorderedCommands = this.#data.commands;
+		const unorderedInputs = this.#data.inputs;
+
+		const orderedCommands = (this.#commandSection as Command[]).flat(Infinity);
+		const orderedInputs = (this.#inputSection as CallArg[]).flat(Infinity);
+
+		if (orderedCommands.length !== unorderedCommands.length) {
+			throw new Error('Unexpected number of commands found in transaction data');
+		}
+
+		if (orderedInputs.length !== unorderedInputs.length) {
+			throw new Error('Unexpected number of inputs found in transaction data');
+		}
+
+		const filteredCommands = orderedCommands.filter(
+			(cmd) => cmd.$Intent?.name !== 'AsyncTransactionThunk',
+		);
+
+		this.#data.commands = filteredCommands;
+		this.#data.inputs = orderedInputs;
+		this.#commandSection = filteredCommands;
+		this.#inputSection = orderedInputs;
+
+		function getOriginalIndex(index: number): number {
+			const command = unorderedCommands[index];
+			if (command.$Intent?.name === 'AsyncTransactionThunk') {
+				const result = command.$Intent.data.result as TransactionResult | null;
+
+				if (result == null) {
+					throw new Error('AsyncTransactionThunk has not been resolved');
+				}
+
+				return getOriginalIndex(result.Result);
+			}
+
+			const updated = filteredCommands.indexOf(command);
+
+			if (updated === -1) {
+				throw new Error('Unable to find original index for command');
+			}
+
+			return updated;
+		}
+
+		this.#data.mapArguments((arg) => {
+			if (arg.$kind === 'Input') {
+				const updated = orderedInputs.indexOf(unorderedInputs[arg.Input]);
+
+				if (updated === -1) {
+					throw new Error('Input has not been resolved');
+				}
+
+				return { ...arg, Input: updated };
+			} else if (arg.$kind === 'Result') {
+				const updated = getOriginalIndex(arg.Result);
+
+				return { ...arg, Result: updated };
+			} else if (arg.$kind === 'NestedResult') {
+				const updated = getOriginalIndex(arg.NestedResult[0]);
+
+				return { ...arg, NestedResult: [updated, arg.NestedResult[1]] };
+			}
+
+			return arg;
+		});
 	}
 
 	async prepareForSerialization(options: SerializeTransactionOptions) {
+		await this.#waitForPendingTasks();
+		this.#sortCommandsAndInputs();
 		const intents = new Set<string>();
 		for (const command of this.#data.commands) {
 			if (command.$Intent) {