@iota/dapp-kit 0.0.0-dev-20251015065834

package/src/hooks/wallet/useCurrentWallet.ts

@@ -0,0 +1,45 @@
+// Copyright (c) Mysten Labs, Inc.
+// Modifications Copyright (c) 2024 IOTA Stiftung
+// SPDX-License-Identifier: Apache-2.0
+
+import { useWalletStore } from './useWalletStore.js';
+
+/**
+ * Retrieves the wallet that is currently connected to the dApp, if one exists.
+ */
+export function useCurrentWallet() {
+    const currentWallet = useWalletStore((state) => state.currentWallet);
+    const connectionStatus = useWalletStore((state) => state.connectionStatus);
+    const supportedIntents = useWalletStore((state) => state.supportedIntents);
+
+    switch (connectionStatus) {
+        case 'connecting':
+            return {
+                connectionStatus,
+                currentWallet: null,
+                isDisconnected: false,
+                isConnecting: true,
+                isConnected: false,
+                supportedIntents: [],
+            } as const;
+        case 'disconnected':
+            return {
+                connectionStatus,
+                currentWallet: null,
+                isDisconnected: true,
+                isConnecting: false,
+                isConnected: false,
+                supportedIntents: [],
+            } as const;
+        case 'connected': {
+            return {
+                connectionStatus,
+                currentWallet: currentWallet!,
+                isDisconnected: false,
+                isConnecting: false,
+                isConnected: true,
+                supportedIntents,
+            } as const;
+        }
+    }
+}

package/src/hooks/wallet/useDisconnectWallet.ts

@@ -0,0 +1,57 @@
+// Copyright (c) Mysten Labs, Inc.
+// Modifications Copyright (c) 2024 IOTA Stiftung
+// SPDX-License-Identifier: Apache-2.0
+
+import type { UseMutationOptions, UseMutationResult } from '@tanstack/react-query';
+import { useMutation } from '@tanstack/react-query';
+
+import { walletMutationKeys } from '../../constants/walletMutationKeys.js';
+import { WalletNotConnectedError } from '../../errors/walletErrors.js';
+import { useCurrentWallet } from './useCurrentWallet.js';
+import { useWalletStore } from './useWalletStore.js';
+
+type UseDisconnectWalletError = WalletNotConnectedError | Error;
+
+type UseDisconnectWalletMutationOptions = Omit<
+    UseMutationOptions<void, UseDisconnectWalletError, void, unknown>,
+    'mutationFn'
+>;
+
+/**
+ * Mutation hook for disconnecting from an active wallet connection, if currently connected.
+ */
+export function useDisconnectWallet({
+    mutationKey,
+    ...mutationOptions
+}: UseDisconnectWalletMutationOptions = {}): UseMutationResult<
+    void,
+    UseDisconnectWalletError,
+    void
+> {
+    const { currentWallet } = useCurrentWallet();
+    const setWalletDisconnected = useWalletStore((state) => state.setWalletDisconnected);
+
+    return useMutation({
+        mutationKey: walletMutationKeys.disconnectWallet(mutationKey),
+        mutationFn: async () => {
+            if (!currentWallet) {
+                throw new WalletNotConnectedError('No wallet is connected.');
+            }
+
+            try {
+                // Wallets aren't required to implement the disconnect feature, so we'll
+                // optionally call the disconnect feature if it exists and reset the UI
+                // state on the frontend at a minimum.
+                await currentWallet.features['standard:disconnect']?.disconnect();
+            } catch (error) {
+                console.error(
+                    'Failed to disconnect the application from the current wallet.',
+                    error,
+                );
+            }
+
+            setWalletDisconnected();
+        },
+        ...mutationOptions,
+    });
+}

package/src/hooks/wallet/useReportTransactionEffects.ts

@@ -0,0 +1,87 @@
+// Copyright (c) Mysten Labs, Inc.
+// Modifications Copyright (c) 2024 IOTA Stiftung
+// SPDX-License-Identifier: Apache-2.0
+
+import { toBase64 } from '@iota/iota-sdk/utils';
+import type { IotaReportTransactionEffectsInput } from '@iota/wallet-standard';
+import type { UseMutationOptions, UseMutationResult } from '@tanstack/react-query';
+import { useMutation } from '@tanstack/react-query';
+
+import { walletMutationKeys } from '../../constants/walletMutationKeys.js';
+import type { WalletFeatureNotSupportedError } from '../../errors/walletErrors.js';
+import {
+    WalletNoAccountSelectedError,
+    WalletNotConnectedError,
+} from '../../errors/walletErrors.js';
+import type { PartialBy } from '../../types/utilityTypes.js';
+import { useCurrentAccount } from './useCurrentAccount.js';
+import { useCurrentWallet } from './useCurrentWallet.js';
+
+type UseReportTransactionEffectsArgs = Omit<
+    PartialBy<IotaReportTransactionEffectsInput, 'account' | 'chain'>,
+    'effects'
+> & {
+    effects: string | number[];
+};
+
+type UseReportTransactionEffectsError =
+    | WalletFeatureNotSupportedError
+    | WalletNoAccountSelectedError
+    | WalletNotConnectedError
+    | Error;
+
+type UseReportTransactionEffectsMutationOptions = Omit<
+    UseMutationOptions<
+        void,
+        UseReportTransactionEffectsError,
+        UseReportTransactionEffectsArgs,
+        unknown
+    >,
+    'mutationFn'
+>;
+
+/**
+ * Mutation hook for prompting the user to sign a message.
+ */
+export function useReportTransactionEffects({
+    mutationKey,
+    ...mutationOptions
+}: UseReportTransactionEffectsMutationOptions = {}): UseMutationResult<
+    void,
+    UseReportTransactionEffectsError,
+    UseReportTransactionEffectsArgs
+> {
+    const { currentWallet } = useCurrentWallet();
+    const currentAccount = useCurrentAccount();
+
+    return useMutation({
+        mutationKey: walletMutationKeys.reportTransactionEffects(mutationKey),
+        mutationFn: async ({
+            effects,
+            chain = currentWallet?.chains[0],
+            account = currentAccount,
+        }) => {
+            if (!currentWallet) {
+                throw new WalletNotConnectedError('No wallet is connected.');
+            }
+
+            if (!account) {
+                throw new WalletNoAccountSelectedError(
+                    'No wallet account is selected to report transaction effects for',
+                );
+            }
+
+            const reportTransactionEffectsFeature =
+                currentWallet.features['iota:reportTransactionEffects'];
+
+            if (reportTransactionEffectsFeature) {
+                return await reportTransactionEffectsFeature.reportTransactionEffects({
+                    effects: Array.isArray(effects) ? toBase64(new Uint8Array(effects)) : effects,
+                    account,
+                    chain: chain ?? currentWallet?.chains[0],
+                });
+            }
+        },
+        ...mutationOptions,
+    });
+}

package/src/hooks/wallet/useSignAndExecuteTransaction.ts

@@ -0,0 +1,172 @@
+// Copyright (c) Mysten Labs, Inc.
+// Modifications Copyright (c) 2024 IOTA Stiftung
+// SPDX-License-Identifier: Apache-2.0
+
+import type { Transaction } from '@iota/iota-sdk/transactions';
+import { toBase64 } from '@iota/iota-sdk/utils';
+import type {
+    IotaSignAndExecuteTransactionInput,
+    IotaSignAndExecuteTransactionOutput,
+} from '@iota/wallet-standard';
+import { signTransaction } from '@iota/wallet-standard';
+import type { UseMutationOptions, UseMutationResult } from '@tanstack/react-query';
+import { useMutation } from '@tanstack/react-query';
+
+import { walletMutationKeys } from '../../constants/walletMutationKeys.js';
+import {
+    WalletFeatureNotSupportedError,
+    WalletNoAccountSelectedError,
+    WalletNotConnectedError,
+} from '../../errors/walletErrors.js';
+import type { PartialBy } from '../../types/utilityTypes.js';
+import { useIotaClient } from '../useIotaClient.js';
+import { useCurrentAccount } from './useCurrentAccount.js';
+import { useCurrentWallet } from './useCurrentWallet.js';
+import { useReportTransactionEffects } from './useReportTransactionEffects.js';
+
+type UseSignAndExecuteTransactionArgs = PartialBy<
+    Omit<IotaSignAndExecuteTransactionInput, 'transaction'>,
+    'account' | 'chain'
+> & {
+    transaction: Transaction | string;
+    waitForTransaction?: boolean;
+};
+
+type UseSignAndExecuteTransactionResult = IotaSignAndExecuteTransactionOutput;
+
+type UseSignAndExecuteTransactionError =
+    | WalletFeatureNotSupportedError
+    | WalletNoAccountSelectedError
+    | WalletNotConnectedError
+    | Error;
+
+type ExecuteTransactionResult =
+    | {
+          digest: string;
+          rawEffects?: number[];
+      }
+    | {
+          effects?: {
+              bcs?: string;
+          };
+      };
+
+type UseSignAndExecuteTransactionMutationOptions<Result extends ExecuteTransactionResult> = Omit<
+    UseMutationOptions<
+        Result,
+        UseSignAndExecuteTransactionError,
+        UseSignAndExecuteTransactionArgs,
+        unknown
+    >,
+    'mutationFn'
+> & {
+    execute?: ({ bytes, signature }: { bytes: string; signature: string }) => Promise<Result>;
+};
+
+/**
+ * Mutation hook for prompting the user to sign and execute a transaction.
+ */
+export function useSignAndExecuteTransaction<
+    Result extends ExecuteTransactionResult = UseSignAndExecuteTransactionResult,
+>({
+    mutationKey,
+    execute,
+    ...mutationOptions
+}: UseSignAndExecuteTransactionMutationOptions<Result> = {}): UseMutationResult<
+    Result,
+    UseSignAndExecuteTransactionError,
+    UseSignAndExecuteTransactionArgs
+> {
+    const { currentWallet, supportedIntents } = useCurrentWallet();
+    const currentAccount = useCurrentAccount();
+    const client = useIotaClient();
+    const { mutate: reportTransactionEffects } = useReportTransactionEffects();
+
+    const executeTransaction: ({
+        bytes,
+        signature,
+    }: {
+        bytes: string;
+        signature: string;
+    }) => Promise<ExecuteTransactionResult> =
+        execute ??
+        (async ({ bytes, signature }) => {
+            const { digest, rawEffects } = await client.executeTransactionBlock({
+                transactionBlock: bytes,
+                signature,
+                options: {
+                    showRawEffects: true,
+                },
+            });
+
+            return {
+                digest,
+                rawEffects,
+                effects: toBase64(new Uint8Array(rawEffects!)),
+                bytes,
+                signature,
+            };
+        });
+
+    return useMutation({
+        mutationKey: walletMutationKeys.signAndExecuteTransaction(mutationKey),
+        mutationFn: async ({ transaction, ...signTransactionArgs }): Promise<Result> => {
+            if (!currentWallet) {
+                throw new WalletNotConnectedError('No wallet is connected.');
+            }
+
+            const signerAccount = signTransactionArgs.account ?? currentAccount;
+            if (!signerAccount) {
+                throw new WalletNoAccountSelectedError(
+                    'No wallet account is selected to sign the transaction with.',
+                );
+            }
+            const chain = signTransactionArgs.chain ?? signerAccount?.chains[0];
+
+            if (!currentWallet.features['iota:signTransaction']) {
+                throw new WalletFeatureNotSupportedError(
+                    "This wallet doesn't support the `signTransaction` feature.",
+                );
+            }
+
+            const { signature, bytes } = await signTransaction(currentWallet, {
+                ...signTransactionArgs,
+                transaction: {
+                    async toJSON() {
+                        return typeof transaction === 'string'
+                            ? transaction
+                            : await transaction.toJSON({
+                                  supportedIntents,
+                                  client,
+                              });
+                    },
+                },
+                account: signerAccount,
+                chain: signTransactionArgs.chain ?? signerAccount.chains[0],
+            });
+
+            const result = await executeTransaction({ bytes, signature });
+
+            let effects: string;
+
+            if ('effects' in result && result.effects?.bcs) {
+                effects = result.effects.bcs;
+            } else if ('rawEffects' in result) {
+                effects = toBase64(new Uint8Array(result.rawEffects!));
+            } else {
+                throw new Error('Could not parse effects from transaction result.');
+            }
+
+            reportTransactionEffects({ effects, account: signerAccount, chain });
+
+            if (signTransactionArgs.waitForTransaction && 'digest' in result) {
+                await client.waitForTransaction({
+                    digest: result.digest,
+                });
+            }
+
+            return result as Result;
+        },
+        ...mutationOptions,
+    });
+}

package/src/hooks/wallet/useSignPersonalMessage.ts

@@ -0,0 +1,84 @@
+// Copyright (c) Mysten Labs, Inc.
+// Modifications Copyright (c) 2024 IOTA Stiftung
+// SPDX-License-Identifier: Apache-2.0
+
+import type {
+    IotaSignPersonalMessageInput,
+    IotaSignPersonalMessageOutput,
+} from '@iota/wallet-standard';
+import type { UseMutationOptions, UseMutationResult } from '@tanstack/react-query';
+import { useMutation } from '@tanstack/react-query';
+
+import {
+    WalletFeatureNotSupportedError,
+    WalletNoAccountSelectedError,
+    WalletNotConnectedError,
+} from '../..//errors/walletErrors.js';
+import { walletMutationKeys } from '../../constants/walletMutationKeys.js';
+import type { PartialBy } from '../../types/utilityTypes.js';
+import { useCurrentAccount } from './useCurrentAccount.js';
+import { useCurrentWallet } from './useCurrentWallet.js';
+
+type UseSignPersonalMessageArgs = PartialBy<IotaSignPersonalMessageInput, 'account'>;
+
+type UseSignPersonalMessageResult = IotaSignPersonalMessageOutput;
+
+type UseSignPersonalMessageError =
+    | WalletFeatureNotSupportedError
+    | WalletNoAccountSelectedError
+    | WalletNotConnectedError
+    | Error;
+
+type UseSignPersonalMessageMutationOptions = Omit<
+    UseMutationOptions<
+        UseSignPersonalMessageResult,
+        UseSignPersonalMessageError,
+        UseSignPersonalMessageArgs,
+        unknown
+    >,
+    'mutationFn'
+>;
+
+/**
+ * Mutation hook for prompting the user to sign a message.
+ */
+export function useSignPersonalMessage({
+    mutationKey,
+    ...mutationOptions
+}: UseSignPersonalMessageMutationOptions = {}): UseMutationResult<
+    UseSignPersonalMessageResult,
+    UseSignPersonalMessageError,
+    UseSignPersonalMessageArgs
+> {
+    const { currentWallet } = useCurrentWallet();
+    const currentAccount = useCurrentAccount();
+
+    return useMutation({
+        mutationKey: walletMutationKeys.signPersonalMessage(mutationKey),
+        mutationFn: async (signPersonalMessageArgs) => {
+            if (!currentWallet) {
+                throw new WalletNotConnectedError('No wallet is connected.');
+            }
+
+            const signPersonalMessageFeature = currentWallet.features['iota:signPersonalMessage'];
+            if (!signPersonalMessageFeature) {
+                throw new WalletFeatureNotSupportedError(
+                    "This wallet doesn't support the `signPersonalMessage` feature.",
+                );
+            }
+
+            const signerAccount = signPersonalMessageArgs.account ?? currentAccount;
+            if (!signerAccount) {
+                throw new WalletNoAccountSelectedError(
+                    'No wallet account is selected to sign the personal message with.',
+                );
+            }
+
+            return await signPersonalMessageFeature.signPersonalMessage({
+                ...signPersonalMessageArgs,
+                account: signerAccount,
+            });
+        },
+        ...mutationOptions,
+    });
+}

package/src/hooks/wallet/useSignTransaction.ts

@@ -0,0 +1,117 @@
+// Copyright (c) Mysten Labs, Inc.
+// Modifications Copyright (c) 2024 IOTA Stiftung
+// SPDX-License-Identifier: Apache-2.0
+
+import type { Transaction } from '@iota/iota-sdk/transactions';
+import { signTransaction } from '@iota/wallet-standard';
+import type { SignedTransaction, IotaSignTransactionInput } from '@iota/wallet-standard';
+import type { UseMutationOptions, UseMutationResult } from '@tanstack/react-query';
+import { useMutation } from '@tanstack/react-query';
+
+import { walletMutationKeys } from '../../constants/walletMutationKeys.js';
+import {
+    WalletFeatureNotSupportedError,
+    WalletNoAccountSelectedError,
+    WalletNotConnectedError,
+} from '../../errors/walletErrors.js';
+import type { PartialBy } from '../../types/utilityTypes.js';
+import { useIotaClient } from '../useIotaClient.js';
+import { useCurrentAccount } from './useCurrentAccount.js';
+import { useCurrentWallet } from './useCurrentWallet.js';
+import { useReportTransactionEffects } from './useReportTransactionEffects.js';
+
+type UseSignTransactionArgs = PartialBy<
+    Omit<IotaSignTransactionInput, 'transaction'>,
+    'account' | 'chain'
+> & {
+    transaction: Transaction | string;
+};
+
+interface UseSignTransactionResult extends SignedTransaction {
+    reportTransactionEffects: (effects: string) => void;
+}
+
+type UseSignTransactionError =
+    | WalletFeatureNotSupportedError
+    | WalletNoAccountSelectedError
+    | WalletNotConnectedError
+    | Error;
+
+type UseSignTransactionMutationOptions = Omit<
+    UseMutationOptions<
+        UseSignTransactionResult,
+        UseSignTransactionError,
+        UseSignTransactionArgs,
+        unknown
+    >,
+    'mutationFn'
+>;
+
+/**
+ * Mutation hook for prompting the user to sign a transaction.
+ */
+export function useSignTransaction({
+    mutationKey,
+    ...mutationOptions
+}: UseSignTransactionMutationOptions = {}): UseMutationResult<
+    UseSignTransactionResult,
+    UseSignTransactionError,
+    UseSignTransactionArgs
+> {
+    const { currentWallet } = useCurrentWallet();
+    const currentAccount = useCurrentAccount();
+    const client = useIotaClient();
+
+    const { mutate: reportTransactionEffects } = useReportTransactionEffects();
+
+    return useMutation({
+        mutationKey: walletMutationKeys.signTransaction(mutationKey),
+        mutationFn: async ({ transaction, ...signTransactionArgs }) => {
+            if (!currentWallet) {
+                throw new WalletNotConnectedError('No wallet is connected.');
+            }
+
+            const signerAccount = signTransactionArgs.account ?? currentAccount;
+            if (!signerAccount) {
+                throw new WalletNoAccountSelectedError(
+                    'No wallet account is selected to sign the transaction with.',
+                );
+            }
+
+            if (!currentWallet.features['iota:signTransaction']) {
+                throw new WalletFeatureNotSupportedError(
+                    "This wallet doesn't support the `signTransaction` feature.",
+                );
+            }
+
+            const { bytes, signature } = await signTransaction(currentWallet, {
+                ...signTransactionArgs,
+                transaction: {
+                    toJSON: async () => {
+                        return typeof transaction === 'string'
+                            ? transaction
+                            : await transaction.toJSON({
+                                  supportedIntents: [],
+                                  client,
+                              });
+                    },
+                },
+                account: signerAccount,
+                chain: signTransactionArgs.chain ?? signerAccount.chains[0],
+            });
+
+            return {
+                bytes,
+                signature,
+                reportTransactionEffects: (effects) => {
+                    reportTransactionEffects({
+                        effects,
+                        account: signerAccount,
+                        chain: signTransactionArgs.chain ?? signerAccount.chains[0],
+                    });
+                },
+            };
+        },
+        ...mutationOptions,
+    });
+}

package/src/hooks/wallet/useSwitchAccount.ts

@@ -0,0 +1,61 @@
+// Copyright (c) Mysten Labs, Inc.
+// Modifications Copyright (c) 2024 IOTA Stiftung
+// SPDX-License-Identifier: Apache-2.0
+
+import type { WalletAccount } from '@iota/wallet-standard';
+import type { UseMutationOptions, UseMutationResult } from '@tanstack/react-query';
+import { useMutation } from '@tanstack/react-query';
+
+import { walletMutationKeys } from '../../constants/walletMutationKeys.js';
+import { WalletAccountNotFoundError, WalletNotConnectedError } from '../../errors/walletErrors.js';
+import { useCurrentWallet } from './useCurrentWallet.js';
+import { useWalletStore } from './useWalletStore.js';
+
+type SwitchAccountArgs = {
+    account: WalletAccount;
+};
+
+type SwitchAccountResult = void;
+
+type UseSwitchAccountError = WalletNotConnectedError | WalletAccountNotFoundError | Error;
+
+type UseSwitchAccountMutationOptions = Omit<
+    UseMutationOptions<SwitchAccountResult, UseSwitchAccountError, SwitchAccountArgs, unknown>,
+    'mutationFn'
+>;
+
+/**
+ * Mutation hook for switching to a specific wallet account.
+ */
+export function useSwitchAccount({
+    mutationKey,
+    ...mutationOptions
+}: UseSwitchAccountMutationOptions = {}): UseMutationResult<
+    SwitchAccountResult,
+    UseSwitchAccountError,
+    SwitchAccountArgs
+> {
+    const { currentWallet } = useCurrentWallet();
+    const setAccountSwitched = useWalletStore((state) => state.setAccountSwitched);
+
+    return useMutation({
+        mutationKey: walletMutationKeys.switchAccount(mutationKey),
+        mutationFn: async ({ account }) => {
+            if (!currentWallet) {
+                throw new WalletNotConnectedError('No wallet is connected.');
+            }
+
+            const accountToSelect = currentWallet.accounts.find(
+                (walletAccount) => walletAccount.address === account.address,
+            );
+            if (!accountToSelect) {
+                throw new WalletAccountNotFoundError(
+                    `No account with address ${account.address} is connected to ${currentWallet.name}.`,
+                );
+            }
+
+            setAccountSwitched(accountToSelect);
+        },
+        ...mutationOptions,
+    });
+}