@mysten/wallet-standard 0.11.5 → 0.12.0

package/src/features/suiSignTransactionBlock.ts

@@ -1,13 +1,15 @@
 // Copyright (c) Mysten Labs, Inc.
 // SPDX-License-Identifier: Apache-2.0
 
-import type { TransactionBlock } from '@mysten/sui.js/transactions';
+import type { Transaction } from '@mysten/sui/transactions';
 import type { IdentifierString, WalletAccount } from '@wallet-standard/core';
 
 /** The latest API version of the signTransactionBlock API. */
 export type SuiSignTransactionBlockVersion = '1.0.0';
 
 /**
+ * @deprecated Use `sui:signTransaction` instead.
+ *
  * A Wallet Standard feature for signing a transaction, and returning the
  * serialized transaction and transaction signature.
  */
@@ -16,17 +18,19 @@ export type SuiSignTransactionBlockFeature = {
 	'sui:signTransactionBlock': {
 		/** Version of the feature API. */
 		version: SuiSignTransactionBlockVersion;
+		/** @deprecated Use `sui:signTransaction` instead. */
 		signTransactionBlock: SuiSignTransactionBlockMethod;
 	};
 };
 
+/** @deprecated Use `sui:signTransaction` instead. */
 export type SuiSignTransactionBlockMethod = (
 	input: SuiSignTransactionBlockInput,
 ) => Promise<SuiSignTransactionBlockOutput>;
 
 /** Input for signing transactions. */
 export interface SuiSignTransactionBlockInput {
-	transactionBlock: TransactionBlock;
+	transactionBlock: Transaction;
 	account: WalletAccount;
 	chain: IdentifierString;
 }
@@ -35,6 +39,8 @@ export interface SuiSignTransactionBlockInput {
 export interface SuiSignTransactionBlockOutput extends SignedTransactionBlock {}
 
 export interface SignedTransactionBlock {
+	/** Transaction as base64 encoded bcs. */
 	transactionBlockBytes: string;
+	/** Base64 encoded signature */
 	signature: string;
 }

package/src/index.ts

@@ -3,7 +3,8 @@
 
 export * from '@wallet-standard/core';
 
-export type { Wallet } from './wallet.js';
+export { type Wallet, signAndExecuteTransaction, signTransaction } from './wallet.js';
 export * from './features/index.js';
 export * from './detect.js';
 export * from './chains.js';
+export * from './types.js';

package/src/types.ts

@@ -0,0 +1,170 @@
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+/** Contains data related to the gas payment for a Transaction */
+export interface GasData {
+	/** The budget set for this transaction */
+	budget: string | number | null;
+	/** The gas price used for this transaction */
+	price: string | number | null;
+	/** The owner of the gas coins used to fund the transactions, this is either the sender or the gas sponsor */
+	owner: string | null;
+	/** The list of SUI coins to fund the transaction */
+	payment: { objectId: string; version: string; digest: string }[] | null;
+}
+
+/**
+ * Represent the serialized state of a partially built Transaction
+ * This format is designed to support transactions that have not been fully build
+ * allowing most properties to be omitted or set to null.  It also supports
+ * unresolved object references, unresolved pure values, and Transaction Intents.
+ */
+export interface SerializedTransactionDataV2 {
+	version: 2;
+	/** The sender of the transaction */
+	sender: string | null | undefined;
+	/** The expiration of the transaction */
+	expiration: { Epoch: number } | { None: true } | null | undefined;
+	/** The gas data */
+	gasData: GasData;
+	/** The inputs to the transaction */
+	inputs: CallArg[];
+	/** The commands to execute */
+	commands: Command[];
+}
+
+/**
+ * Represents an input to a Transaction, either as a fully resolved Object or Pure input
+ * or as an unresolved partial reference which needs to be resolved before the transaction
+ * can be serialized to bcs and executed.
+ */
+export type CallArg =
+	| {
+			Object: ObjectArg;
+	  }
+	| {
+			Pure: PureArg;
+	  }
+	| {
+			UnresolvedPure: UnresolvedPureArg;
+	  }
+	| {
+			UnresolvedObject: UnresolvedObjectArg;
+	  };
+
+export type ObjectArg =
+	| {
+			ImmOrOwnedObject: {
+				objectId: string;
+				version: string | number;
+				digest: string;
+			};
+	  }
+	| {
+			SharedObject: {
+				objectId: string;
+				initialSharedVersion: string;
+				mutable: boolean;
+			};
+	  }
+	| {
+			Receiving: {
+				objectId: string;
+				version: string | number;
+				digest: string;
+			};
+	  };
+
+export interface PureArg {
+	bytes: string;
+}
+
+/**
+ * Represents an un-serialized pure value.
+ * The correct bcs schema will need to be determined before this value can be serialized to bcs */
+export interface UnresolvedPureArg {
+	value: unknown;
+}
+
+/**
+ * Represents an unresolved object reference.  This allows objects to be referenced by only their ID.
+ * version and digest details may also be added to unresolved object references.
+ * To fully resolve a reference, the correct ObjectArg type needs to be determined based on the type of object,
+ * and how it used in the transaction (eg, is it used mutably if it's shared, and is it a receiving object if it's not shared)
+ */
+export interface UnresolvedObjectArg {
+	objectId: string;
+	version?: string | null | undefined;
+	digest?: string | null | undefined;
+	initialSharedVersion?: string | null | undefined;
+}
+
+export type Argument =
+	| {
+			GasCoin: true;
+	  }
+	| {
+			Input: number;
+	  }
+	| {
+			Result: number;
+	  }
+	| {
+			NestedResult: [number, number];
+	  };
+
+export type Command =
+	| {
+			MoveCall: {
+				package: string;
+				module: string;
+				function: string;
+				typeArguments: string[];
+				arguments: Argument[];
+			};
+	  }
+	| {
+			TransferObjects: {
+				objects: Argument[];
+				address: Argument;
+			};
+	  }
+	| {
+			SplitCoins: {
+				coin: Argument;
+				amounts: Argument[];
+			};
+	  }
+	| {
+			MergeCoins: {
+				destination: Argument;
+				sources: Argument[];
+			};
+	  }
+	| {
+			Publish: {
+				modules: string[];
+				dependencies: string[];
+			};
+	  }
+	| {
+			MakeMoveVec: {
+				type: string | null;
+				elements: Argument[];
+			};
+	  }
+	| {
+			Upgrade: {
+				modules: string[];
+				dependencies: string[];
+				package: string;
+				ticket: Argument;
+			};
+	  }
+	| {
+			$Intent: {
+				name: string;
+				inputs: Record<string, Argument | Argument[]>;
+				data: Record<string, unknown>;
+			};
+	  };

package/src/wallet.ts

@@ -1,6 +1,17 @@
 // Copyright (c) Mysten Labs, Inc.
 // SPDX-License-Identifier: Apache-2.0
 
+import { bcs } from '@mysten/sui/bcs';
+import { Transaction } from '@mysten/sui/transactions';
+import { fromB64, toB64 } from '@mysten/sui/utils';
+import type { WalletWithFeatures } from '@wallet-standard/core';
+
+import type {
+	SuiSignAndExecuteTransactionInput,
+	SuiSignTransactionInput,
+	SuiWalletFeatures,
+} from './features/index.js';
+
 declare module '@wallet-standard/core' {
 	export interface Wallet {
 		/**
@@ -10,6 +21,78 @@ declare module '@wallet-standard/core' {
 		 */
 		readonly id?: string;
 	}
+
+	export interface StandardConnectOutput {
+		supportedIntents?: string[];
+	}
 }
 
 export type { Wallet } from '@wallet-standard/core';
+
+export async function signAndExecuteTransaction(
+	wallet: WalletWithFeatures<Partial<SuiWalletFeatures>>,
+	input: SuiSignAndExecuteTransactionInput,
+) {
+	if (wallet.features['sui:signAndExecuteTransaction']) {
+		return wallet.features['sui:signAndExecuteTransaction'].signAndExecuteTransaction(input);
+	}
+
+	if (!wallet.features['sui:signAndExecuteTransactionBlock']) {
+		throw new Error(
+			`Provided wallet (${wallet.name}) does not support the signAndExecuteTransaction feature.`,
+		);
+	}
+
+	const { signAndExecuteTransactionBlock } = wallet.features['sui:signAndExecuteTransactionBlock'];
+
+	const transactionBlock = Transaction.from(await input.transaction.toJSON());
+	const { digest, rawEffects, rawTransaction } = await signAndExecuteTransactionBlock({
+		...input,
+		transactionBlock,
+		options: {
+			showRawEffects: true,
+			showRawInput: true,
+		},
+	});
+
+	const [
+		{
+			txSignatures: [signature],
+			intentMessage: { value: bcsTransaction },
+		},
+	] = bcs.SenderSignedData.parse(fromB64(rawTransaction!));
+
+	const bytes = bcs.TransactionData.serialize(bcsTransaction).toBase64();
+
+	return {
+		digest,
+		signature,
+		bytes,
+		effects: toB64(new Uint8Array(rawEffects!)),
+	};
+}
+
+export async function signTransaction(
+	wallet: WalletWithFeatures<Partial<SuiWalletFeatures>>,
+	input: SuiSignTransactionInput,
+) {
+	if (wallet.features['sui:signTransaction']) {
+		return wallet.features['sui:signTransaction'].signTransaction(input);
+	}
+
+	if (!wallet.features['sui:signTransactionBlock']) {
+		throw new Error(
+			`Provided wallet (${wallet.name}) does not support the signTransaction feature.`,
+		);
+	}
+
+	const { signTransactionBlock } = wallet.features['sui:signTransactionBlock'];
+
+	const transaction = Transaction.from(await input.transaction.toJSON());
+	const { transactionBlockBytes, signature } = await signTransactionBlock({
+		...input,
+		transactionBlock: transaction,
+	});
+
+	return { bytes: transactionBlockBytes, signature };
+}