@haneullabs/wallet-standard 0.1.0

package/src/features/haneulSignMessage.ts

@@ -0,0 +1,54 @@
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+import type { WalletAccount } from '@wallet-standard/core';
+
+/**
+ * Name of the feature.
+ * @deprecated Wallets can still implement this method for compatibility, but this has been replaced by the `sui:signPersonalMessage` feature
+ **/
+export const HaneulSignMessage = 'sui:signMessage';
+
+/**
+ * The latest API version of the signMessage API.
+ * @deprecated Wallets can still implement this method for compatibility, but this has been replaced by the `sui:signPersonalMessage` feature
+ */
+export type HaneulSignMessageVersion = '1.0.0';
+
+/**
+ * A Wallet Standard feature for signing a personal message, and returning the
+ * message bytes that were signed, and message signature.
+ *
+ * @deprecated Wallets can still implement this method for compatibility, but this has been replaced by the `sui:signPersonalMessage` feature
+ */
+export type HaneulSignMessageFeature = {
+	/** Namespace for the feature. */
+	[HaneulSignMessage]: {
+		/** Version of the feature API. */
+		version: HaneulSignMessageVersion;
+		signMessage: HaneulSignMessageMethod;
+	};
+};
+
+/** @deprecated Wallets can still implement this method for compatibility, but this has been replaced by the `sui:signPersonalMessage` feature */
+export type HaneulSignMessageMethod = (input: HaneulSignMessageInput) => Promise<HaneulSignMessageOutput>;
+
+/**
+ * Input for signing messages.
+ * @deprecated Wallets can still implement this method for compatibility, but this has been replaced by the `sui:signPersonalMessage` feature
+ */
+export interface HaneulSignMessageInput {
+	message: Uint8Array;
+	account: WalletAccount;
+}
+
+/**
+ * Output of signing messages.
+ * @deprecated Wallets can still implement this method for compatibility, but this has been replaced by the `sui:signPersonalMessage` feature
+ */
+export interface HaneulSignMessageOutput {
+	/** Base64 message bytes. */
+	messageBytes: string;
+	/** Base64 encoded signature */
+	signature: string;
+}

package/src/features/haneulSignPersonalMessage.ts

@@ -0,0 +1,44 @@
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+import type { IdentifierString, WalletAccount } from '@wallet-standard/core';
+
+/** Name of the feature. */
+export const HaneulSignPersonalMessage = 'sui:signPersonalMessage';
+
+/** The latest API version of the signPersonalMessage API. */
+export type HaneulSignPersonalMessageVersion = '1.1.0';
+
+/**
+ * A Wallet Standard feature for signing a personal message, and returning the
+ * message bytes that were signed, and message signature.
+ */
+export type HaneulSignPersonalMessageFeature = {
+	/** Namespace for the feature. */
+	[HaneulSignPersonalMessage]: {
+		/** Version of the feature API. */
+		version: HaneulSignPersonalMessageVersion;
+		signPersonalMessage: HaneulSignPersonalMessageMethod;
+	};
+};
+
+export type HaneulSignPersonalMessageMethod = (
+	input: HaneulSignPersonalMessageInput,
+) => Promise<HaneulSignPersonalMessageOutput>;
+
+/** Input for signing personal messages. */
+export interface HaneulSignPersonalMessageInput {
+	message: Uint8Array;
+	account: WalletAccount;
+	chain?: IdentifierString;
+}
+
+/** Output of signing personal messages. */
+export interface HaneulSignPersonalMessageOutput extends SignedPersonalMessage {}
+
+export interface SignedPersonalMessage {
+	/** Base64 encoded message bytes */
+	bytes: string;
+	/** Base64 encoded signature */
+	signature: string;
+}

package/src/features/haneulSignTransaction.ts

@@ -0,0 +1,44 @@
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+import type { IdentifierString, WalletAccount } from '@wallet-standard/core';
+
+/** Name of the feature. */
+export const HaneulSignTransaction = 'sui:signTransaction';
+
+/** The latest API version of the signTransaction API. */
+export type HaneulSignTransactionVersion = '2.0.0';
+
+/**
+ * A Wallet Standard feature for signing a transaction, and returning the
+ * serialized transaction and transaction signature.
+ */
+export type HaneulSignTransactionFeature = {
+	/** Namespace for the feature. */
+	[HaneulSignTransaction]: {
+		/** Version of the feature API. */
+		version: HaneulSignTransactionVersion;
+		signTransaction: HaneulSignTransactionMethod;
+	};
+};
+
+export type HaneulSignTransactionMethod = (
+	input: HaneulSignTransactionInput,
+) => Promise<SignedTransaction>;
+
+/** Input for signing transactions. */
+export interface HaneulSignTransactionInput {
+	transaction: { toJSON: () => Promise<string> };
+	account: WalletAccount;
+	chain: IdentifierString;
+	signal?: AbortSignal;
+}
+
+/** Output of signing transactions. */
+
+export interface SignedTransaction {
+	/** Transaction as base64 encoded bcs. */
+	bytes: string;
+	/** Base64 encoded signature */
+	signature: string;
+}

package/src/features/haneulSignTransactionBlock.ts

@@ -0,0 +1,49 @@
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+import type { Transaction } from '@haneullabs/haneul/transactions';
+import type { IdentifierString, WalletAccount } from '@wallet-standard/core';
+
+/** Name of the feature. */
+export const HaneulSignTransactionBlock = 'sui:signTransactionBlock';
+
+/** The latest API version of the signTransactionBlock API. */
+export type HaneulSignTransactionBlockVersion = '1.0.0';
+
+/**
+ * @deprecated Use `sui:signTransaction` instead.
+ *
+ * A Wallet Standard feature for signing a transaction, and returning the
+ * serialized transaction and transaction signature.
+ */
+export type HaneulSignTransactionBlockFeature = {
+	/** Namespace for the feature. */
+	[HaneulSignTransactionBlock]: {
+		/** Version of the feature API. */
+		version: HaneulSignTransactionBlockVersion;
+		/** @deprecated Use `sui:signTransaction` instead. */
+		signTransactionBlock: HaneulSignTransactionBlockMethod;
+	};
+};
+
+/** @deprecated Use `sui:signTransaction` instead. */
+export type HaneulSignTransactionBlockMethod = (
+	input: HaneulSignTransactionBlockInput,
+) => Promise<HaneulSignTransactionBlockOutput>;
+
+/** Input for signing transactions. */
+export interface HaneulSignTransactionBlockInput {
+	transactionBlock: Transaction;
+	account: WalletAccount;
+	chain: IdentifierString;
+}
+
+/** Output of signing transactions. */
+export interface HaneulSignTransactionBlockOutput extends SignedTransactionBlock {}
+
+export interface SignedTransactionBlock {
+	/** Transaction as base64 encoded bcs. */
+	transactionBlockBytes: string;
+	/** Base64 encoded signature */
+	signature: string;
+}

package/src/features/index.ts

@@ -0,0 +1,61 @@
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+import type {
+	IdentifierRecord,
+	StandardConnectFeature,
+	StandardDisconnectFeature,
+	StandardEventsFeature,
+	WalletWithFeatures,
+} from '@wallet-standard/core';
+
+import type { HaneulReportTransactionEffectsFeature } from './haneulReportTransactionEffects.js';
+import type { HaneulSignAndExecuteTransactionFeature } from './haneulSignAndExecuteTransaction.js';
+import type { HaneulSignAndExecuteTransactionBlockFeature } from './haneulSignAndExecuteTransactionBlock.js';
+import type { HaneulSignMessageFeature } from './haneulSignMessage.js';
+import type { HaneulSignPersonalMessageFeature } from './haneulSignPersonalMessage.js';
+import type { HaneulSignTransactionFeature } from './haneulSignTransaction.js';
+import type { HaneulSignTransactionBlockFeature } from './haneulSignTransactionBlock.js';
+import type { HaneulGetCapabilitiesFeature } from './haneulGetCapabilities.js';
+
+/**
+ * Wallet Standard features that are unique to Haneul, and that all Haneul wallets are expected to implement.
+ */
+export type HaneulFeatures = Partial<HaneulSignTransactionBlockFeature> &
+	Partial<HaneulSignAndExecuteTransactionBlockFeature> &
+	HaneulSignPersonalMessageFeature &
+	HaneulSignAndExecuteTransactionFeature &
+	HaneulSignTransactionFeature &
+	// This deprecated feature should be removed once wallets update to the new method:
+	Partial<HaneulSignMessageFeature> &
+	Partial<HaneulReportTransactionEffectsFeature> &
+	Partial<HaneulGetCapabilitiesFeature>;
+
+export type HaneulWalletFeatures = StandardConnectFeature &
+	StandardEventsFeature &
+	HaneulFeatures &
+	// Disconnect is an optional feature:
+	Partial<StandardDisconnectFeature>;
+
+export type WalletWithHaneulFeatures = WalletWithFeatures<HaneulWalletFeatures>;
+
+/**
+ * Represents a wallet with the absolute minimum feature set required to function in the Haneul ecosystem.
+ */
+export type WalletWithRequiredFeatures = WalletWithFeatures<
+	MinimallyRequiredFeatures &
+		Partial<HaneulFeatures> &
+		Partial<StandardDisconnectFeature> &
+		IdentifierRecord<unknown>
+>;
+
+export type MinimallyRequiredFeatures = StandardConnectFeature & StandardEventsFeature;
+
+export * from './haneulSignMessage.js';
+export * from './haneulSignTransactionBlock.js';
+export * from './haneulSignTransaction.js';
+export * from './haneulSignAndExecuteTransactionBlock.js';
+export * from './haneulSignAndExecuteTransaction.js';
+export * from './haneulSignPersonalMessage.js';
+export * from './haneulReportTransactionEffects.js';
+export * from './haneulGetCapabilities.js';

package/src/index.ts

@@ -0,0 +1,10 @@
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+export * from '@wallet-standard/core';
+
+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,175 @@
+// 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[];
+	/** Extra metadata for implementation specific use-cases */
+	extensions?: { [key: string]: unknown };
+	/** The digest of the transaction, may be set when the transaction is fully resolved */
+	digest: string | null | undefined;
+}
+
+/**
+ * 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;
+	mutable?: boolean | 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: { [key: string]: Argument | Argument[] };
+				data: { [key: string]: unknown };
+			};
+	  };

package/src/wallet.ts

@@ -0,0 +1,100 @@
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+import { bcs } from '@haneullabs/haneul/bcs';
+import { Transaction } from '@haneullabs/haneul/transactions';
+import { fromBase64, toBase64 } from '@haneullabs/haneul/utils';
+import type { WalletWithFeatures } from '@wallet-standard/core';
+
+import type {
+	HaneulSignAndExecuteTransactionInput,
+	HaneulSignTransactionInput,
+	HaneulWalletFeatures,
+} from './features/index.js';
+
+declare module '@wallet-standard/core' {
+	export interface Wallet {
+		/**
+		 * Unique identifier of the Wallet.
+		 *
+		 * If not provided, the wallet name will be used as the identifier.
+		 */
+		readonly id?: string;
+	}
+
+	export interface StandardConnectOutput {
+		supportedIntents?: string[];
+	}
+}
+
+export type { Wallet } from '@wallet-standard/core';
+
+export async function signAndExecuteTransaction(
+	wallet: WalletWithFeatures<Partial<HaneulWalletFeatures>>,
+	input: HaneulSignAndExecuteTransactionInput,
+) {
+	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({
+		account: input.account,
+		chain: input.chain,
+		transactionBlock,
+		options: {
+			showRawEffects: true,
+			showRawInput: true,
+		},
+	});
+
+	const [
+		{
+			txSignatures: [signature],
+			intentMessage: { value: bcsTransaction },
+		},
+	] = bcs.SenderSignedData.parse(fromBase64(rawTransaction!));
+
+	const bytes = bcs.TransactionData.serialize(bcsTransaction).toBase64();
+
+	return {
+		digest,
+		signature,
+		bytes,
+		effects: toBase64(new Uint8Array(rawEffects!)),
+	};
+}
+
+export async function signTransaction(
+	wallet: WalletWithFeatures<Partial<HaneulWalletFeatures>>,
+	input: HaneulSignTransactionInput,
+) {
+	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({
+		transactionBlock: transaction,
+		account: input.account,
+		chain: input.chain,
+	});
+
+	return { bytes: transactionBlockBytes, signature };
+}