@iota/wallet-standard 0.0.0-dev-20251015065834

package/src/features/index.ts

@@ -0,0 +1,49 @@
+// Copyright (c) Mysten Labs, Inc.
+// Modifications Copyright (c) 2024 IOTA Stiftung
+// SPDX-License-Identifier: Apache-2.0
+
+import type {
+    IdentifierRecord,
+    StandardConnectFeature,
+    StandardDisconnectFeature,
+    StandardEventsFeature,
+    WalletWithFeatures,
+} from '@wallet-standard/core';
+
+import type { IotaReportTransactionEffectsFeature } from './iotaReportTransactionEffects.js';
+import type { IotaSignAndExecuteTransactionFeature } from './iotaSignAndExecuteTransaction.js';
+import type { IotaSignPersonalMessageFeature } from './iotaSignPersonalMessage.js';
+import type { IotaSignTransactionFeature } from './iotaSignTransaction.js';
+
+/**
+ * Wallet Standard features that are unique to IOTA, and that all IOTA wallets are expected to implement.
+ */
+export type IotaFeatures = IotaSignPersonalMessageFeature &
+    IotaSignAndExecuteTransactionFeature &
+    IotaSignTransactionFeature &
+    Partial<IotaReportTransactionEffectsFeature>;
+
+export type IotaWalletFeatures = StandardConnectFeature &
+    StandardEventsFeature &
+    IotaFeatures &
+    // Disconnect is an optional feature:
+    Partial<StandardDisconnectFeature>;
+
+export type WalletWithIotaFeatures = WalletWithFeatures<IotaWalletFeatures>;
+
+/**
+ * Represents a wallet with the absolute minimum feature set required to function in the IOTA ecosystem.
+ */
+export type WalletWithRequiredFeatures = WalletWithFeatures<
+    MinimallyRequiredFeatures &
+        Partial<IotaFeatures> &
+        Partial<StandardDisconnectFeature> &
+        IdentifierRecord<unknown>
+>;
+
+export type MinimallyRequiredFeatures = StandardConnectFeature & StandardEventsFeature;
+
+export * from './iotaSignTransaction.js';
+export * from './iotaSignAndExecuteTransaction.js';
+export * from './iotaSignPersonalMessage.js';
+export * from './iotaReportTransactionEffects.js';

package/src/features/iotaReportTransactionEffects.ts

@@ -0,0 +1,31 @@
+// Copyright (c) Mysten Labs, Inc.
+// Modifications Copyright (c) 2024 IOTA Stiftung
+// SPDX-License-Identifier: Apache-2.0
+
+import type { IdentifierString, WalletAccount } from '@wallet-standard/core';
+
+/**
+ * A Wallet Standard feature for reporting the effects of a transaction block executed by a dapp
+ * The feature allows wallets to updated their caches using the effects of the transaction
+ * executed outside of the wallet
+ */
+export type IotaReportTransactionEffectsFeature = {
+    /** Namespace for the feature. */
+    'iota:reportTransactionEffects': {
+        /** Version of the feature API. */
+        version: '1.0.0';
+        reportTransactionEffects: IotaReportTransactionEffectsMethod;
+    };
+};
+
+export type IotaReportTransactionEffectsMethod = (
+    input: IotaReportTransactionEffectsInput,
+) => Promise<void>;
+
+/** Input for signing transactions. */
+export interface IotaReportTransactionEffectsInput {
+    account: WalletAccount;
+    chain: IdentifierString;
+    /** Transaction effects as base64 encoded bcs. */
+    effects: string;
+}

package/src/features/iotaSignAndExecuteTransaction.ts

@@ -0,0 +1,40 @@
+// Copyright (c) Mysten Labs, Inc.
+// Modifications Copyright (c) 2024 IOTA Stiftung
+// SPDX-License-Identifier: Apache-2.0
+
+import type { IotaTransactionBlockResponseOptions } from '@iota/iota-sdk/client';
+import type { SignedTransaction, IotaSignTransactionInput } from './iotaSignTransaction.js';
+
+/** The latest API version of the signAndExecuteTransactionBlock API. */
+export type IotaSignAndExecuteTransactionVersion = '2.0.0';
+
+/**
+ * A Wallet Standard feature for signing a transaction, and submitting it to the
+ * network. The wallet is expected to submit the transaction to the network via RPC,
+ * and return the transaction response.
+ */
+export type IotaSignAndExecuteTransactionFeature = {
+    /** Namespace for the feature. */
+    'iota:signAndExecuteTransaction': {
+        /** Version of the feature API. */
+        version: IotaSignAndExecuteTransactionVersion;
+        signAndExecuteTransaction: IotaSignAndExecuteTransactionMethod;
+    };
+};
+
+export type IotaSignAndExecuteTransactionMethod = (
+    input: IotaSignAndExecuteTransactionInput,
+) => Promise<IotaSignAndExecuteTransactionOutput>;
+
+/** Input for signing and sending transactions. */
+export interface IotaSignAndExecuteTransactionInput extends IotaSignTransactionInput {
+    /** specify which fields to return (e.g., transaction, effects, events, etc). By default, only the transaction digest will be returned. */
+    options?: IotaTransactionBlockResponseOptions;
+}
+
+/** Output of signing and sending transactions. */
+export interface IotaSignAndExecuteTransactionOutput extends SignedTransaction {
+    digest: string;
+    /** Transaction effects as base64 encoded bcs. */
+    effects: string;
+}

package/src/features/iotaSignPersonalMessage.ts

@@ -0,0 +1,41 @@
+// Copyright (c) Mysten Labs, Inc.
+// Modifications Copyright (c) 2024 IOTA Stiftung
+// SPDX-License-Identifier: Apache-2.0
+
+import type { WalletAccount } from '@wallet-standard/core';
+
+/** The latest API version of the signPersonalMessage API. */
+export type IotaSignPersonalMessageVersion = '1.0.0';
+
+/**
+ * A Wallet Standard feature for signing a personal message, and returning the
+ * message bytes that were signed, and message signature.
+ */
+export type IotaSignPersonalMessageFeature = {
+    /** Namespace for the feature. */
+    'iota:signPersonalMessage': {
+        /** Version of the feature API. */
+        version: IotaSignPersonalMessageVersion;
+        signPersonalMessage: IotaSignPersonalMessageMethod;
+    };
+};
+
+export type IotaSignPersonalMessageMethod = (
+    input: IotaSignPersonalMessageInput,
+) => Promise<IotaSignPersonalMessageOutput>;
+
+/** Input for signing personal messages. */
+export interface IotaSignPersonalMessageInput {
+    message: Uint8Array;
+    account: WalletAccount;
+}
+
+/** Output of signing personal messages. */
+export interface IotaSignPersonalMessageOutput extends SignedPersonalMessage {}
+
+export interface SignedPersonalMessage {
+    /** Base64 encoded message bytes */
+    bytes: string;
+    /** Base64 encoded signature */
+    signature: string;
+}

package/src/features/iotaSignTransaction.ts

@@ -0,0 +1,44 @@
+// Copyright (c) Mysten Labs, Inc.
+// Modifications Copyright (c) 2024 IOTA Stiftung
+// SPDX-License-Identifier: Apache-2.0
+
+import type { IdentifierString, WalletAccount } from '@wallet-standard/core';
+
+/** The latest API version of the signTransaction API. */
+export type IotaSignTransactionVersion = '2.0.0';
+
+/**
+ * A Wallet Standard feature for signing a transaction, and returning the
+ * serialized transaction and transaction signature.
+ */
+export type IotaSignTransactionFeature = {
+    /** Namespace for the feature. */
+    'iota:signTransaction': {
+        /** Version of the feature API. */
+        version: IotaSignTransactionVersion;
+        signTransaction: IotaSignTransactionMethod;
+    };
+};
+
+export type IotaSignTransactionMethod = (
+    input: IotaSignTransactionInput,
+) => Promise<SignedTransaction>;
+
+/** Input for signing transactions. */
+export interface IotaSignTransactionInput {
+    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;
+}
+
+export interface IotaSignTransactionOutput extends SignedTransaction {}

package/src/index.ts

@@ -0,0 +1,11 @@
+// Copyright (c) Mysten Labs, Inc.
+// Modifications Copyright (c) 2024 IOTA Stiftung
+// 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,173 @@
+// Copyright (c) Mysten Labs, Inc.
+// Modifications Copyright (c) 2024 IOTA Stiftung
+// 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 IOTA 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 };
+}
+
+/**
+ * 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: { [key: string]: Argument | Argument[] };
+              data: { [key: string]: unknown };
+          };
+      };

package/src/wallet.ts

@@ -0,0 +1,54 @@
+// Copyright (c) Mysten Labs, Inc.
+// Modifications Copyright (c) 2024 IOTA Stiftung
+// SPDX-License-Identifier: Apache-2.0
+
+import type { WalletWithFeatures } from '@wallet-standard/core';
+
+import type {
+    IotaSignAndExecuteTransactionInput,
+    IotaSignTransactionInput,
+    IotaWalletFeatures,
+} 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<IotaWalletFeatures>>,
+    input: IotaSignAndExecuteTransactionInput,
+) {
+    if (!wallet.features['iota:signAndExecuteTransaction']) {
+        throw new Error(
+            `Provided wallet (${wallet.name}) does not support the signAndExecuteTransaction feature.`,
+        );
+    }
+
+    return wallet.features['iota:signAndExecuteTransaction'].signAndExecuteTransaction(input);
+}
+
+export async function signTransaction(
+    wallet: WalletWithFeatures<Partial<IotaWalletFeatures>>,
+    input: IotaSignTransactionInput,
+) {
+    if (!wallet.features['iota:signTransaction']) {
+        throw new Error(
+            `Provided wallet (${wallet.name}) does not support the signTransaction feature.`,
+        );
+    }
+
+    return wallet.features['iota:signTransaction'].signTransaction(input);
+}