@mysten/sui 1.29.1 → 1.30.1

package/package.json

@@ -3,7 +3,7 @@
   "author": "Mysten Labs <build@mystenlabs.com>",
   "description": "Sui TypeScript API(Work in Progress)",
   "homepage": "https://sdk.mystenlabs.com",
-  "version": "1.29.1",
+  "version": "1.30.1",
   "license": "Apache-2.0",
   "sideEffects": false,
   "files": [

package/src/cryptography/keypair.ts

@@ -11,12 +11,16 @@ import type { PublicKey } from './publickey.js';
 import { SIGNATURE_FLAG_TO_SCHEME, SIGNATURE_SCHEME_TO_FLAG } from './signature-scheme.js';
 import type { SignatureScheme } from './signature-scheme.js';
 import { toSerializedSignature } from './signature.js';
+import type { Transaction } from '../transactions/Transaction.js';
+import type { ClientWithCoreApi, Experimental_SuiClientTypes } from '../experimental/index.js';
 
 export const PRIVATE_KEY_SIZE = 32;
 export const LEGACY_PRIVATE_KEY_SIZE = 64;
 export const SUI_PRIVATE_KEY_PREFIX = 'suiprivkey';
 
 export type ParsedKeypair = {
+	scheme: SignatureScheme;
+	/** @deprecated use `scheme` instead */
 	schema: SignatureScheme;
 	secretKey: Uint8Array;
 };
@@ -26,6 +30,11 @@ export interface SignatureWithBytes {
 	signature: string;
 }
 
+export interface SignAndExecuteOptions {
+	transaction: Transaction;
+	client: ClientWithCoreApi;
+}
+
 /**
  * TODO: Document
  */
@@ -71,6 +80,20 @@ export abstract class Signer {
 		};
 	}
 
+	async signAndExecuteTransaction({
+		transaction,
+		client,
+	}: SignAndExecuteOptions): Promise<Experimental_SuiClientTypes.TransactionResponse> {
+		const bytes = await transaction.build({ client });
+		const { signature } = await this.signTransaction(bytes);
+		const response = await client.core.executeTransaction({
+			transaction: bytes,
+			signatures: [signature],
+		});
+
+		return response.transaction;
+	}
+
 	toSuiAddress(): string {
 		return this.getPublicKey().toSuiAddress();
 	}
@@ -107,7 +130,9 @@ export function decodeSuiPrivateKey(value: string): ParsedKeypair {
 	const secretKey = extendedSecretKey.slice(1);
 	const signatureScheme =
 		SIGNATURE_FLAG_TO_SCHEME[extendedSecretKey[0] as keyof typeof SIGNATURE_FLAG_TO_SCHEME];
+
 	return {
+		scheme: signatureScheme,
 		schema: signatureScheme,
 		secretKey: secretKey,
 	};

package/src/experimental/core.ts

@@ -2,10 +2,15 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { TypeTagSerializer } from '../bcs/type-tag-serializer.js';
+import type { TransactionPlugin } from '../transactions/index.js';
 import { deriveDynamicFieldID } from '../utils/dynamic-fields.js';
 import { normalizeStructTag, parseStructTag, SUI_ADDRESS_LENGTH } from '../utils/sui-types.js';
 import { Experimental_BaseClient } from './client.js';
-import type { Experimental_SuiClientTypes } from './types.js';
+import type { ClientWithExtensions, Experimental_SuiClientTypes } from './types.js';
+
+export type ClientWithCoreApi = ClientWithExtensions<{
+	core: Experimental_CoreClient;
+}>;
 
 export abstract class Experimental_CoreClient
 	extends Experimental_BaseClient
@@ -66,6 +71,8 @@ export abstract class Experimental_CoreClient
 		options: Experimental_SuiClientTypes.GetDynamicFieldsOptions,
 	): Promise<Experimental_SuiClientTypes.GetDynamicFieldsResponse>;
 
+	abstract resolveTransactionPlugin(): TransactionPlugin;
+
 	async getDynamicField(
 		options: Experimental_SuiClientTypes.GetDynamicFieldOptions,
 	): Promise<Experimental_SuiClientTypes.GetDynamicFieldResponse> {

package/src/experimental/index.ts

@@ -2,12 +2,14 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { Experimental_BaseClient } from './client.js';
+import type { ClientWithCoreApi } from './core.js';
 import { Experimental_CoreClient } from './core.js';
 import type {
 	ClientWithExtensions,
 	Experimental_SuiClientTypes,
 	SuiClientRegistration,
 } from './types.js';
+export { parseTransactionBcs, parseTransactionEffectsBcs } from './transports/utils.js';
 
 export {
 	Experimental_BaseClient,
@@ -15,6 +17,7 @@ export {
 	type ClientWithExtensions,
 	type Experimental_SuiClientTypes,
 	type SuiClientRegistration,
+	type ClientWithCoreApi,
 };
 
 export { ClientCache, type ClientCacheOptions } from './cache.js';

package/src/experimental/transports/graphql.ts

@@ -27,7 +27,7 @@ import { ObjectError } from '../errors.js';
 import { fromBase64, toBase64 } from '@mysten/utils';
 import { normalizeStructTag, normalizeSuiAddress } from '../../utils/sui-types.js';
 import { deriveDynamicFieldID } from '../../utils/dynamic-fields.js';
-import { parseTransactionEffects } from './utils.js';
+import { parseTransactionBcs, parseTransactionEffectsBcs } from './utils.js';
 
 export class GraphQLTransport extends Experimental_CoreClient {
 	#graphqlClient: SuiGraphQLClient;
@@ -339,6 +339,10 @@ export class GraphQLTransport extends Experimental_CoreClient {
 			errors: result.errors,
 		};
 	}
+
+	resolveTransactionPlugin(): never {
+		throw new Error('GraphQL client does not support transaction resolution yet');
+	}
 }
 export type GraphQLResponseErrors = Array<{
 	message: string;
@@ -411,11 +415,10 @@ function parseTransaction(
 
 	return {
 		digest: transaction.digest!,
-		effects: parseTransactionEffects({
-			effects: new Uint8Array(transaction.effects?.bcs!),
-			objectTypes,
-		}),
-		bcs: transaction.bcs!,
+		effects: parseTransactionEffectsBcs(new Uint8Array(transaction.effects?.bcs!)),
+		epoch: transaction.effects?.epoch?.epochId ?? null,
+		objectTypes: Promise.resolve(objectTypes),
+		transaction: parseTransactionBcs(transaction.bcs!),
 		signatures: transaction.signatures!,
 	};
 }

package/src/{transactions → experimental/transports}/json-rpc-resolver.ts

@@ -3,16 +3,19 @@
 
 import { parse } from 'valibot';
 
-import type { BcsType } from '../bcs/index.js';
-import { bcs } from '../bcs/index.js';
-import type { SuiClient } from '../client/client.js';
-import { normalizeSuiAddress, normalizeSuiObjectId, SUI_TYPE_ARG } from '../utils/index.js';
-import { ObjectRef } from './data/internal.js';
-import type { Argument, CallArg, Command, OpenMoveTypeSignature } from './data/internal.js';
-import { Inputs } from './Inputs.js';
-import { getPureBcsSchema, isTxContext, normalizedTypeToMoveTypeSignature } from './serializer.js';
-import type { TransactionDataBuilder } from './TransactionData.js';
+import { normalizeSuiAddress, normalizeSuiObjectId, SUI_TYPE_ARG } from '../../utils/index.js';
+import { ObjectRef } from '../../transactions/data/internal.js';
+import type { CallArg, Command, OpenMoveTypeSignature } from '../../transactions/data/internal.js';
+import { Inputs } from '../../transactions/Inputs.js';
+import {
+	getPureBcsSchema,
+	isTxContext,
+	normalizedTypeToMoveTypeSignature,
+} from '../../transactions/serializer.js';
+import type { TransactionDataBuilder } from '../../transactions/TransactionData.js';
 import { chunk } from '@mysten/utils';
+import type { SuiClient } from '../../client/index.js';
+import type { BuildTransactionOptions } from '../../transactions/index.js';
 
 // The maximum objects that can be fetched at once using multiGetObjects.
 const MAX_OBJECTS_PER_FETCH = 50;
@@ -21,56 +24,37 @@ const MAX_OBJECTS_PER_FETCH = 50;
 const GAS_SAFE_OVERHEAD = 1000n;
 const MAX_GAS = 50_000_000_000;
 
-export interface BuildTransactionOptions {
-	client?: SuiClient;
-	onlyTransactionKind?: boolean;
-}
+export function resolveTransactionPlugin(client: SuiClient) {
+	return async function resolveTransactionData(
+		transactionData: TransactionDataBuilder,
+		options: BuildTransactionOptions,
+		next: () => Promise<void>,
+	) {
+		await normalizeInputs(transactionData, client);
+		await resolveObjectReferences(transactionData, client);
+
+		if (!options.onlyTransactionKind) {
+			await setGasPrice(transactionData, client);
+			await setGasBudget(transactionData, client);
+			await setGasPayment(transactionData, client);
+		}
 
-export interface SerializeTransactionOptions extends BuildTransactionOptions {
-	supportedIntents?: string[];
+		return await next();
+	};
 }
 
-export type TransactionPlugin = (
-	transactionData: TransactionDataBuilder,
-	options: BuildTransactionOptions,
-	next: () => Promise<void>,
-) => Promise<void>;
-
-export async function resolveTransactionData(
-	transactionData: TransactionDataBuilder,
-	options: BuildTransactionOptions,
-	next: () => Promise<void>,
-) {
-	await normalizeInputs(transactionData, options);
-	await resolveObjectReferences(transactionData, options);
-
-	if (!options.onlyTransactionKind) {
-		await setGasPrice(transactionData, options);
-		await setGasBudget(transactionData, options);
-		await setGasPayment(transactionData, options);
-	}
-	await validate(transactionData);
-	return await next();
-}
-
-async function setGasPrice(
-	transactionData: TransactionDataBuilder,
-	options: BuildTransactionOptions,
-) {
+async function setGasPrice(transactionData: TransactionDataBuilder, client: SuiClient) {
 	if (!transactionData.gasConfig.price) {
-		transactionData.gasConfig.price = String(await getClient(options).getReferenceGasPrice());
+		transactionData.gasConfig.price = String(await client.getReferenceGasPrice());
 	}
 }
 
-async function setGasBudget(
-	transactionData: TransactionDataBuilder,
-	options: BuildTransactionOptions,
-) {
+async function setGasBudget(transactionData: TransactionDataBuilder, client: SuiClient) {
 	if (transactionData.gasConfig.budget) {
 		return;
 	}
 
-	const dryRunResult = await getClient(options).dryRunTransactionBlock({
+	const dryRunResult = await client.dryRunTransactionBlock({
 		transactionBlock: transactionData.build({
 			overrides: {
 				gasData: {
@@ -104,12 +88,9 @@ async function setGasBudget(
 }
 
 // The current default is just picking _all_ coins we can which may not be ideal.
-async function setGasPayment(
-	transactionData: TransactionDataBuilder,
-	options: BuildTransactionOptions,
-) {
+async function setGasPayment(transactionData: TransactionDataBuilder, client: SuiClient) {
 	if (!transactionData.gasConfig.payment) {
-		const coins = await getClient(options).getCoins({
+		const coins = await client.getCoins({
 			owner: transactionData.gasConfig.owner || transactionData.sender!,
 			coinType: SUI_TYPE_ARG,
 		});
@@ -141,10 +122,7 @@ async function setGasPayment(
 	}
 }
 
-async function resolveObjectReferences(
-	transactionData: TransactionDataBuilder,
-	options: BuildTransactionOptions,
-) {
+async function resolveObjectReferences(transactionData: TransactionDataBuilder, client: SuiClient) {
 	// Keep track of the object references that will need to be resolved at the end of the transaction.
 	// We keep the input by-reference to avoid needing to re-resolve it:
 	const objectsToResolve = transactionData.inputs.filter((input) => {
@@ -164,7 +142,7 @@ async function resolveObjectReferences(
 	const resolved = (
 		await Promise.all(
 			objectChunks.map((chunk) =>
-				getClient(options).multiGetObjects({
+				client.multiGetObjects({
 					ids: chunk,
 					options: { showOwner: true },
 				}),
@@ -246,10 +224,7 @@ async function resolveObjectReferences(
 	}
 }
 
-async function normalizeInputs(
-	transactionData: TransactionDataBuilder,
-	options: BuildTransactionOptions,
-) {
+async function normalizeInputs(transactionData: TransactionDataBuilder, client: SuiClient) {
 	const { inputs, commands } = transactionData;
 	const moveCallsToResolve: Extract<Command, { MoveCall: unknown }>['MoveCall'][] = [];
 	const moveFunctionsToResolve = new Set<string>();
@@ -282,24 +257,10 @@ async function normalizeInputs(
 				moveCallsToResolve.push(command.MoveCall);
 			}
 		}
-
-		// Special handling for values that where previously encoded using the wellKnownEncoding pattern.
-		// This should only happen when transaction data was hydrated from an old version of the SDK
-		switch (command.$kind) {
-			case 'SplitCoins':
-				command.SplitCoins.amounts.forEach((amount) => {
-					normalizeRawArgument(amount, bcs.U64, transactionData);
-				});
-				break;
-			case 'TransferObjects':
-				normalizeRawArgument(command.TransferObjects.address, bcs.Address, transactionData);
-				break;
-		}
 	});
 
 	const moveFunctionParameters = new Map<string, OpenMoveTypeSignature[]>();
 	if (moveFunctionsToResolve.size > 0) {
-		const client = getClient(options);
 		await Promise.all(
 			[...moveFunctionsToResolve].map(async (functionName) => {
 				const [packageId, moduleId, functionId] = functionName.split('::');
@@ -400,35 +361,6 @@ async function normalizeInputs(
 	});
 }
 
-function validate(transactionData: TransactionDataBuilder) {
-	transactionData.inputs.forEach((input, index) => {
-		if (input.$kind !== 'Object' && input.$kind !== 'Pure') {
-			throw new Error(
-				`Input at index ${index} has not been resolved.  Expected a Pure or Object input, but found ${JSON.stringify(
-					input,
-				)}`,
-			);
-		}
-	});
-}
-
-function normalizeRawArgument(
-	arg: Argument,
-	schema: BcsType<any>,
-	transactionData: TransactionDataBuilder,
-) {
-	if (arg.$kind !== 'Input') {
-		return;
-	}
-	const input = transactionData.inputs[arg.Input];
-
-	if (input.$kind !== 'UnresolvedPure') {
-		return;
-	}
-
-	transactionData.inputs[arg.Input] = Inputs.Pure(schema.serialize(input.UnresolvedPure.value));
-}
-
 function isUsedAsMutable(transactionData: TransactionDataBuilder, index: number) {
 	let usedAsMutable = false;
 
@@ -470,13 +402,3 @@ function isReceivingType(type: OpenMoveTypeSignature): boolean {
 		type.body.datatype.type === 'Receiving'
 	);
 }
-
-export function getClient(options: BuildTransactionOptions): SuiClient {
-	if (!options.client) {
-		throw new Error(
-			`No sui client passed to Transaction#build, but transaction data was not sufficient to build offline.`,
-		);
-	}
-
-	return options.client;
-}

package/src/experimental/transports/jsonRPC.ts

@@ -14,11 +14,12 @@ import type {
 } from '../../client/index.js';
 import { batch } from '../../transactions/plugins/utils.js';
 import { Transaction } from '../../transactions/Transaction.js';
-import { normalizeStructTag } from '../../utils/sui-types.js';
 import { Experimental_CoreClient } from '../core.js';
 import { ObjectError } from '../errors.js';
 import type { Experimental_SuiClientTypes } from '../types.js';
-import { parseTransactionEffects } from './utils.js';
+import { parseTransactionBcs, parseTransactionEffectsBcs } from './utils.js';
+import { resolveTransactionPlugin } from './json-rpc-resolver.js';
+import { TransactionDataBuilder } from '../../transactions/TransactionData.js';
 
 export class JSONRpcTransport extends Experimental_CoreClient {
 	#jsonRpcClient: SuiClient;
@@ -185,15 +186,19 @@ export class JSONRpcTransport extends Experimental_CoreClient {
 			signal: options.signal,
 		});
 
+		const { effects, objectTypes } = parseTransactionEffectsJson({
+			effects: result.effects,
+			objectChanges: result.objectChanges,
+		});
+
 		return {
 			transaction: {
 				digest: await tx.getDigest(),
-				effects: parseTransactionEffectsJson({
-					effects: result.effects,
-					objectChanges: result.objectChanges,
-				}),
+				epoch: null,
+				effects,
+				objectTypes: Promise.resolve(objectTypes),
 				signatures: [],
-				bcs: options.transaction,
+				transaction: parseTransactionBcs(options.transaction),
 			},
 		};
 	}
@@ -242,6 +247,10 @@ export class JSONRpcTransport extends Experimental_CoreClient {
 			errors: result.errors,
 		};
 	}
+
+	resolveTransactionPlugin() {
+		return resolveTransactionPlugin(this.#jsonRpcClient);
+	}
 }
 
 function parseObject(object: SuiObjectData): Experimental_SuiClientTypes.ObjectResponse {
@@ -315,13 +324,26 @@ function parseTransaction(
 		}
 	});
 
+	const bytes = bcs.TransactionData.serialize(parsedTx.intentMessage.value).toBytes();
+
+	const data = TransactionDataBuilder.restore({
+		version: 2,
+		sender: parsedTx.intentMessage.value.V1.sender,
+		expiration: parsedTx.intentMessage.value.V1.expiration,
+		gasData: parsedTx.intentMessage.value.V1.gasData,
+		inputs: parsedTx.intentMessage.value.V1.kind.ProgrammableTransaction!.inputs,
+		commands: parsedTx.intentMessage.value.V1.kind.ProgrammableTransaction!.commands,
+	});
+
 	return {
 		digest: transaction.digest,
-		effects: parseTransactionEffects({
-			effects: new Uint8Array(transaction.rawEffects!),
-			objectTypes,
-		}),
-		bcs: bcs.TransactionData.serialize(parsedTx.intentMessage.value).toBytes(),
+		epoch: transaction.effects?.executedEpoch ?? null,
+		effects: parseTransactionEffectsBcs(new Uint8Array(transaction.rawEffects!)),
+		objectTypes: Promise.resolve(objectTypes),
+		transaction: {
+			...data,
+			bcs: bytes,
+		},
 		signatures: parsedTx.txSignatures,
 	};
 }
@@ -329,16 +351,18 @@ function parseTransaction(
 function parseTransactionEffectsJson({
 	bytes,
 	effects,
-	epoch,
 	objectChanges,
 }: {
 	bytes?: Uint8Array;
 	effects: TransactionEffects;
-	epoch?: string | null;
 	objectChanges: SuiObjectChange[] | null;
-}): Experimental_SuiClientTypes.TransactionEffects {
+}): {
+	effects: Experimental_SuiClientTypes.TransactionEffects;
+	objectTypes: Record<string, string>;
+} {
 	const changedObjects: Experimental_SuiClientTypes.ChangedObject[] = [];
 	const unchangedSharedObjects: Experimental_SuiClientTypes.UnchangedSharedObject[] = [];
+	const objectTypes: Record<string, string> = {};
 
 	objectChanges?.forEach((change) => {
 		switch (change.type) {
@@ -354,7 +378,6 @@ function parseTransactionEffectsJson({
 					outputDigest: change.digest,
 					outputOwner: null,
 					idOperation: 'Created',
-					objectType: null,
 				});
 				break;
 			case 'transferred':
@@ -372,8 +395,8 @@ function parseTransactionEffectsJson({
 					outputDigest: change.digest,
 					outputOwner: parseOwner(change.recipient),
 					idOperation: 'None',
-					objectType: change.objectType,
 				});
+				objectTypes[change.objectId] = change.objectType;
 				break;
 			case 'mutated':
 				changedObjects.push({
@@ -387,8 +410,8 @@ function parseTransactionEffectsJson({
 					outputDigest: change.digest,
 					outputOwner: parseOwner(change.owner),
 					idOperation: 'None',
-					objectType: change.objectType,
 				});
+				objectTypes[change.objectId] = change.objectType;
 				break;
 			case 'deleted':
 				changedObjects.push({
@@ -402,8 +425,8 @@ function parseTransactionEffectsJson({
 					outputDigest: null,
 					outputOwner: null,
 					idOperation: 'Deleted',
-					objectType: change.objectType,
 				});
+				objectTypes[change.objectId] = change.objectType;
 				break;
 			case 'wrapped':
 				changedObjects.push({
@@ -424,8 +447,8 @@ function parseTransactionEffectsJson({
 						ObjectOwner: change.sender,
 					},
 					idOperation: 'None',
-					objectType: change.objectType,
 				});
+				objectTypes[change.objectId] = change.objectType;
 				break;
 			case 'created':
 				changedObjects.push({
@@ -439,42 +462,43 @@ function parseTransactionEffectsJson({
 					outputDigest: change.digest,
 					outputOwner: parseOwner(change.owner),
 					idOperation: 'Created',
-					objectType: change.objectType,
 				});
+				objectTypes[change.objectId] = change.objectType;
 				break;
 		}
 	});
 
 	return {
-		bcs: bytes ?? null,
-		digest: effects.transactionDigest,
-		version: 2,
-		status:
-			effects.status.status === 'success'
-				? { success: true, error: null }
-				: { success: false, error: effects.status.error! },
-		epoch: epoch ?? null,
-		gasUsed: effects.gasUsed,
-		transactionDigest: effects.transactionDigest,
-		gasObject: {
-			id: effects.gasObject?.reference.objectId,
-			inputState: 'Exists',
-			inputVersion: null,
-			inputDigest: null,
-			inputOwner: null,
-			outputState: 'ObjectWrite',
-			outputVersion: effects.gasObject.reference.version,
-			outputDigest: effects.gasObject.reference.digest,
-			outputOwner: parseOwner(effects.gasObject.owner),
-			idOperation: 'None',
-			objectType: normalizeStructTag('0x2::coin::Coin<0x2::sui::SUI>'),
+		objectTypes,
+		effects: {
+			bcs: bytes ?? null,
+			digest: effects.transactionDigest,
+			version: 2,
+			status:
+				effects.status.status === 'success'
+					? { success: true, error: null }
+					: { success: false, error: effects.status.error! },
+			gasUsed: effects.gasUsed,
+			transactionDigest: effects.transactionDigest,
+			gasObject: {
+				id: effects.gasObject?.reference.objectId,
+				inputState: 'Exists',
+				inputVersion: null,
+				inputDigest: null,
+				inputOwner: null,
+				outputState: 'ObjectWrite',
+				outputVersion: effects.gasObject.reference.version,
+				outputDigest: effects.gasObject.reference.digest,
+				outputOwner: parseOwner(effects.gasObject.owner),
+				idOperation: 'None',
+			},
+			eventsDigest: effects.eventsDigest ?? null,
+			dependencies: effects.dependencies ?? [],
+			lamportVersion: effects.gasObject.reference.version,
+			changedObjects,
+			unchangedSharedObjects,
+			auxiliaryDataDigest: null,
 		},
-		eventsDigest: effects.eventsDigest ?? null,
-		dependencies: effects.dependencies ?? [],
-		lamportVersion: effects.gasObject.reference.version,
-		changedObjects,
-		unchangedSharedObjects,
-		auxiliaryDataDigest: null,
 	};
 }