@solana/react 6.3.1 → 6.3.2-canary-20260313143218

package/src/useSignAndSendTransaction.ts

@@ -0,0 +1,168 @@
+import {
+    SolanaSignAndSendTransaction,
+    SolanaSignAndSendTransactionFeature,
+    SolanaSignAndSendTransactionInput,
+    SolanaSignAndSendTransactionOutput,
+} from '@solana/wallet-standard-features';
+import {
+    WALLET_STANDARD_ERROR__FEATURES__WALLET_ACCOUNT_CHAIN_UNSUPPORTED,
+    WalletStandardError,
+} from '@wallet-standard/errors';
+import { getWalletAccountFeature, type UiWalletAccount } from '@wallet-standard/ui';
+import { getWalletAccountForUiWalletAccount_DO_NOT_USE_OR_YOU_WILL_BE_FIRED } from '@wallet-standard/ui-registry';
+import { useCallback } from 'react';
+
+import { OnlySolanaChains } from './chain';
+
+type Input = Readonly<
+    Omit<SolanaSignAndSendTransactionInput, 'account' | 'chain' | 'options'> & {
+        options?: Readonly<{
+            minContextSlot?: bigint;
+        }>;
+    }
+>;
+type Output = SolanaSignAndSendTransactionOutput;
+
+/**
+ * Use this to get a function capable of signing a serialized transaction with the private key of a
+ * {@link UiWalletAccount} and sending it to the network for processing.
+ *
+ * @param chain The identifier of the chain the transaction is destined for. Wallets may use this to
+ * simulate the transaction for the user.
+ *
+ * @example
+ * ```tsx
+ * import { getBase58Decoder } from '@solana/codecs-strings';
+ * import { useSignAndSendTransaction } from '@solana/react';
+ *
+ * function SignAndSendTransactionButton({ account, transactionBytes }) {
+ *     const signAndSendTransaction = useSignAndSendTransaction(account, 'solana:devnet');
+ *     return (
+ *         <button
+ *             onClick={async () => {
+ *                 try {
+ *                     const { signature } = await signAndSendTransaction({
+ *                         transaction: transactionBytes,
+ *                     });
+ *                     const base58TransactionSignature = getBase58Decoder().decode(signature);
+ *                     window.alert(
+ *                         `View transaction: https://explorer.solana.com/tx/${base58TransactionSignature}?cluster=devnet`,
+ *                     );
+ *                 } catch (e) {
+ *                     console.error('Failed to send transaction', e);
+ *                 }
+ *             }}
+ *         >
+ *             Sign and Send Transaction
+ *         </button>
+ *     );
+ * }
+ * ```
+ */
+export function useSignAndSendTransaction<TWalletAccount extends UiWalletAccount>(
+    uiWalletAccount: TWalletAccount,
+    chain: OnlySolanaChains<TWalletAccount['chains']>,
+): (input: Input) => Promise<Output>;
+export function useSignAndSendTransaction<TWalletAccount extends UiWalletAccount>(
+    uiWalletAccount: TWalletAccount,
+    chain: `solana:${string}`,
+): (input: Input) => Promise<Output>;
+export function useSignAndSendTransaction<TWalletAccount extends UiWalletAccount>(
+    uiWalletAccount: TWalletAccount,
+    chain: `solana:${string}`,
+): (input: Input) => Promise<Output> {
+    const signAndSendTransactions = useSignAndSendTransactions(uiWalletAccount, chain);
+    return useCallback(
+        async input => {
+            const [result] = await signAndSendTransactions(input);
+            return result;
+        },
+        [signAndSendTransactions],
+    );
+}
+
+/**
+ * Use this to get a function capable of signing one or more serialized transactions with the private
+ * key of a {@link UiWalletAccount} and sending them to the network for processing. This supports
+ * wallets that allow batching multiple transactions in a single request.
+ *
+ * @example
+ * ```tsx
+ * import { useSignAndSendTransactions } from '@solana/react';
+ *
+ * function SignAndSendTransactionsButton({ account, transactionBytes1, transactionBytes2 }) {
+ *     const signAndSendTransactions = useSignAndSendTransactions(account, 'solana:devnet');
+ *     return (
+ *         <button
+ *             onClick={async () => {
+ *                 try {
+ *                     const [first, second] = await signAndSendTransactions(
+ *                         { transaction: transactionBytes1 },
+ *                         { transaction: transactionBytes2 },
+ *                     );
+ *                     window.alert(
+ *                         `Transaction signatures: ${first.signature.toString()}, ${second.signature.toString()}`,
+ *                     );
+ *                 } catch (e) {
+ *                     console.error('Failed to send transactions', e);
+ *                 }
+ *             }}
+ *         >
+ *             Sign and Send Transactions
+ *         </button>
+ *     );
+ * }
+ * ```
+ */
+export function useSignAndSendTransactions<TWalletAccount extends UiWalletAccount>(
+    uiWalletAccount: TWalletAccount,
+    chain: OnlySolanaChains<TWalletAccount['chains']>,
+): (...inputs: readonly Input[]) => Promise<readonly Output[]>;
+export function useSignAndSendTransactions<TWalletAccount extends UiWalletAccount>(
+    uiWalletAccount: TWalletAccount,
+    chain: `solana:${string}`,
+): (...inputs: readonly Input[]) => Promise<readonly Output[]>;
+export function useSignAndSendTransactions<TWalletAccount extends UiWalletAccount>(
+    uiWalletAccount: TWalletAccount,
+    chain: `solana:${string}`,
+): (...inputs: readonly Input[]) => Promise<readonly Output[]> {
+    if (!uiWalletAccount.chains.includes(chain)) {
+        throw new WalletStandardError(WALLET_STANDARD_ERROR__FEATURES__WALLET_ACCOUNT_CHAIN_UNSUPPORTED, {
+            address: uiWalletAccount.address,
+            chain,
+            featureName: SolanaSignAndSendTransaction,
+            supportedChains: [...uiWalletAccount.chains],
+            supportedFeatures: [...uiWalletAccount.features],
+        });
+    }
+    const signAndSendTransactionFeature = getWalletAccountFeature(
+        uiWalletAccount,
+        SolanaSignAndSendTransaction,
+    ) as SolanaSignAndSendTransactionFeature[typeof SolanaSignAndSendTransaction];
+    const account = getWalletAccountForUiWalletAccount_DO_NOT_USE_OR_YOU_WILL_BE_FIRED(uiWalletAccount);
+    return useCallback(
+        async (...inputs) => {
+            if (inputs.length === 0) {
+                return [];
+            }
+            const inputsWithChainAndAccount = inputs.map(({ options, ...rest }) => {
+                const minContextSlot = options?.minContextSlot;
+                return {
+                    ...rest,
+                    account,
+                    chain,
+                    ...(minContextSlot != null
+                        ? {
+                              options: {
+                                  minContextSlot: Number(minContextSlot),
+                              },
+                          }
+                        : null),
+                };
+            });
+            const results = await signAndSendTransactionFeature.signAndSendTransaction(...inputsWithChainAndAccount);
+            return results;
+        },
+        [account, chain, signAndSendTransactionFeature],
+    );
+}

package/src/useSignIn.ts

@@ -0,0 +1,124 @@
+import { Address } from '@solana/addresses';
+import {
+    SolanaSignIn,
+    SolanaSignInFeature,
+    SolanaSignInInput,
+    SolanaSignInOutput,
+} from '@solana/wallet-standard-features';
+import {
+    getWalletAccountFeature,
+    getWalletFeature,
+    UiWallet,
+    UiWalletAccount,
+    UiWalletHandle,
+} from '@wallet-standard/ui';
+import {
+    getOrCreateUiWalletAccountForStandardWalletAccount_DO_NOT_USE_OR_YOU_WILL_BE_FIRED,
+    getWalletAccountForUiWalletAccount_DO_NOT_USE_OR_YOU_WILL_BE_FIRED,
+    getWalletForHandle_DO_NOT_USE_OR_YOU_WILL_BE_FIRED,
+} from '@wallet-standard/ui-registry';
+import { useCallback } from 'react';
+
+type Input = SolanaSignInInput;
+type Output = Omit<SolanaSignInOutput, 'account' | 'signatureType'> &
+    Readonly<{
+        account: UiWalletAccount;
+    }>;
+
+/**
+ * Use the ['Sign In With Solana'](https://phantom.app/learn/developers/sign-in-with-solana) feature
+ * of a {@link UiWallet} or {@link UiWalletAccount}.
+ *
+ * @returns A function that you can call to sign in with the particular wallet and address specified
+ * by the supplied {@link UiWalletAccount}
+ *
+ * @example
+ * ```tsx
+ * import { useSignIn } from '@solana/react';
+ *
+ * function SignInButton({ wallet }) {
+ *     const csrfToken = useCsrfToken();
+ *     const signIn = useSignIn(wallet);
+ *     return (
+ *         <button
+ *             onClick={async () => {
+ *                 try {
+ *                     const { account, signedMessage, signature } = await signIn({
+ *                         requestId: csrfToken,
+ *                     });
+ *                     // Authenticate the user, typically on the server, by verifying that
+ *                     // `signedMessage` was signed by the person who holds the private key for
+ *                     // `account.publicKey`.
+ *                     //
+ *                     // Authorize the user, also on the server, by decoding `signedMessage` as the
+ *                     // text of a Sign In With Solana message, verifying that it was not modified
+ *                     // from the values your application expects, and that its content is sufficient
+ *                     // to grant them access.
+ *                     window.alert(`You are now signed in with the address ${account.address}`);
+ *                 } catch (e) {
+ *                     console.error('Failed to sign in', e);
+ *                 }
+ *             }}
+ *         >
+ *             Sign In
+ *         </button>
+ *     );
+ * }
+ * ```
+ */
+export function useSignIn(uiWalletAccount: UiWalletAccount): (input?: Omit<Input, 'address'>) => Promise<Output>;
+/**
+ * @returns A function that you can call to sign in with the supplied {@link UiWallet}
+ */
+export function useSignIn(uiWallet: UiWallet): (input?: Input) => Promise<Output>;
+export function useSignIn(uiWalletHandle: UiWalletHandle): (input?: Input) => Promise<Output> {
+    const signIns = useSignIns(uiWalletHandle);
+    return useCallback(
+        async input => {
+            const [result] = await signIns(input);
+            return result;
+        },
+        [signIns],
+    );
+}
+
+function useSignIns(
+    uiWalletHandle: UiWalletHandle,
+): (...inputs: readonly (Input | undefined)[]) => Promise<readonly Output[]> {
+    let signMessageFeature: SolanaSignInFeature[typeof SolanaSignIn];
+    if ('address' in uiWalletHandle && typeof uiWalletHandle.address === 'string') {
+        getWalletAccountForUiWalletAccount_DO_NOT_USE_OR_YOU_WILL_BE_FIRED(uiWalletHandle as UiWalletAccount);
+        signMessageFeature = getWalletAccountFeature(
+            uiWalletHandle as UiWalletAccount,
+            SolanaSignIn,
+        ) as SolanaSignInFeature[typeof SolanaSignIn];
+    } else {
+        signMessageFeature = getWalletFeature(uiWalletHandle, SolanaSignIn) as SolanaSignInFeature[typeof SolanaSignIn];
+    }
+    const wallet = getWalletForHandle_DO_NOT_USE_OR_YOU_WILL_BE_FIRED(uiWalletHandle);
+    return useCallback(
+        async (...inputs) => {
+            const inputsWithAddressAndChainId = inputs.map(input => ({
+                ...input,
+                // Prioritize the `UiWalletAccount` address if it exists.
+                ...('address' in uiWalletHandle ? { address: uiWalletHandle.address as Address } : null),
+            }));
+            const results = await signMessageFeature.signIn(...inputsWithAddressAndChainId);
+            const resultsWithoutSignatureType = results.map(
+                ({
+                    account,
+                    signatureType: _, // Solana signatures are always of type `ed25519` so drop this property.
+                    ...rest
+                }) => ({
+                    ...rest,
+                    account: getOrCreateUiWalletAccountForStandardWalletAccount_DO_NOT_USE_OR_YOU_WILL_BE_FIRED(
+                        wallet,
+                        account,
+                    ),
+                }),
+            );
+            return resultsWithoutSignatureType;
+        },
+        [signMessageFeature, uiWalletHandle, wallet],
+    );
+}

package/src/useSignMessage.ts

@@ -0,0 +1,78 @@
+import {
+    SolanaSignMessage,
+    SolanaSignMessageFeature,
+    SolanaSignMessageInput,
+    SolanaSignMessageOutput,
+} from '@solana/wallet-standard-features';
+import { getWalletAccountFeature, UiWalletAccount } from '@wallet-standard/ui';
+import { getWalletAccountForUiWalletAccount_DO_NOT_USE_OR_YOU_WILL_BE_FIRED } from '@wallet-standard/ui-registry';
+import { useCallback } from 'react';
+
+type Input = Omit<SolanaSignMessageInput, 'account'>;
+type Output = Omit<SolanaSignMessageOutput, 'signatureType'>;
+
+/**
+ * Use this to get a function capable of signing a message with the private key of a
+ * {@link UiWalletAccount}
+ *
+ * @example
+ * ```tsx
+ * import { useSignMessage } from '@solana/react';
+ *
+ * function SignMessageButton({ account, messageBytes }) {
+ *     const signMessage = useSignMessage(account);
+ *     return (
+ *         <button
+ *             onClick={async () => {
+ *                 try {
+ *                     const { signature } = await signMessage({
+ *                         message: messageBytes,
+ *                     });
+ *                     window.alert(`Signature bytes: ${signature.toString()}`);
+ *                 } catch (e) {
+ *                     console.error('Failed to sign message', e);
+ *                 }
+ *             }}
+ *         >
+ *             Sign Message
+ *         </button>
+ *     );
+ * }
+ * ```
+ */
+export function useSignMessage<TWalletAccount extends UiWalletAccount>(
+    ...config: Parameters<typeof useSignMessages<TWalletAccount>>
+): (input: Input) => Promise<Output> {
+    const signMessages = useSignMessages(...config);
+    return useCallback(
+        async input => {
+            const [result] = await signMessages(input);
+            return result;
+        },
+        [signMessages],
+    );
+}
+
+function useSignMessages<TWalletAccount extends UiWalletAccount>(
+    uiWalletAccount: TWalletAccount,
+): (...inputs: readonly Input[]) => Promise<readonly Output[]> {
+    const signMessageFeature = getWalletAccountFeature(
+        uiWalletAccount,
+        SolanaSignMessage,
+    ) as SolanaSignMessageFeature[typeof SolanaSignMessage];
+    const account = getWalletAccountForUiWalletAccount_DO_NOT_USE_OR_YOU_WILL_BE_FIRED(uiWalletAccount);
+    return useCallback(
+        async (...inputs) => {
+            const inputsWithAccount = inputs.map(input => ({ ...input, account }));
+            const results = await signMessageFeature.signMessage(...inputsWithAccount);
+            const resultsWithoutSignatureType = results.map(
+                ({
+                    signatureType: _, // Solana signatures are always of type `ed25519` so drop this property.
+                    ...rest
+                }) => rest,
+            );
+            return resultsWithoutSignatureType;
+        },
+        [signMessageFeature, account],
+    );
+}

package/src/useSignTransaction.ts

@@ -0,0 +1,164 @@
+import {
+    SolanaSignTransaction,
+    SolanaSignTransactionFeature,
+    SolanaSignTransactionInput,
+    SolanaSignTransactionOutput,
+} from '@solana/wallet-standard-features';
+import {
+    WALLET_STANDARD_ERROR__FEATURES__WALLET_ACCOUNT_CHAIN_UNSUPPORTED,
+    WalletStandardError,
+} from '@wallet-standard/errors';
+import { getWalletAccountFeature, UiWalletAccount } from '@wallet-standard/ui';
+import { getWalletAccountForUiWalletAccount_DO_NOT_USE_OR_YOU_WILL_BE_FIRED } from '@wallet-standard/ui-registry';
+import { useCallback } from 'react';
+
+import { OnlySolanaChains } from './chain';
+
+type Input = Readonly<
+    Omit<SolanaSignTransactionInput, 'account' | 'chain' | 'options'> & {
+        options?: Readonly<{
+            minContextSlot?: bigint;
+        }>;
+    }
+>;
+type Output = SolanaSignTransactionOutput;
+
+/**
+ * Use this to get a function capable of signing a serialized transaction with the private key of a
+ * {@link UiWalletAccount}
+ *
+ * @param chain The identifier of the chain the transaction is destined for. Wallets may use this to
+ * simulate the transaction for the user.
+ *
+ * @example
+ * ```tsx
+ * import { useSignTransaction } from '@solana/react';
+ *
+ * function SignTransactionButton({ account, transactionBytes }) {
+ *     const signTransaction = useSignTransaction(account, 'solana:devnet');
+ *     return (
+ *         <button
+ *             onClick={async () => {
+ *                 try {
+ *                     const { signedTransaction } = await signTransaction({
+ *                         transaction: transactionBytes,
+ *                     });
+ *                     window.alert(`Signed transaction bytes: ${signedTransaction.toString()}`);
+ *                 } catch (e) {
+ *                     console.error('Failed to sign transaction', e);
+ *                 }
+ *             }}
+ *         >
+ *             Sign Transaction
+ *         </button>
+ *     );
+ * }
+ * ```
+ */
+export function useSignTransaction<TWalletAccount extends UiWalletAccount>(
+    uiWalletAccount: TWalletAccount,
+    chain: OnlySolanaChains<TWalletAccount['chains']>,
+): (input: Input) => Promise<Output>;
+export function useSignTransaction<TWalletAccount extends UiWalletAccount>(
+    uiWalletAccount: TWalletAccount,
+    chain: `solana:${string}`,
+): (input: Input) => Promise<Output>;
+export function useSignTransaction<TWalletAccount extends UiWalletAccount>(
+    uiWalletAccount: TWalletAccount,
+    chain: `solana:${string}`,
+): (input: Input) => Promise<Output> {
+    const signTransactions = useSignTransactions(uiWalletAccount, chain);
+    return useCallback(
+        async input => {
+            const [result] = await signTransactions(input);
+            return result;
+        },
+        [signTransactions],
+    );
+}
+
+/**
+ * Use this to get a function capable of signing one or more serialized transactions with the private
+ * key of a {@link UiWalletAccount}. This supports batching multiple transactions in a single wallet
+ * prompt when the wallet implementation allows it.
+ *
+ * @example
+ * ```tsx
+ * import { useSignTransactions } from '@solana/react';
+ *
+ * function SignTransactionsButton({ account, transactionBytes1, transactionBytes2 }) {
+ *     const signTransactions = useSignTransactions(account, 'solana:devnet');
+ *     return (
+ *         <button
+ *             onClick={async () => {
+ *                 try {
+ *                     const [first, second] = await signTransactions(
+ *                         { transaction: transactionBytes1 },
+ *                         { transaction: transactionBytes2 },
+ *                     );
+ *                     window.alert(
+ *                         `First transaction bytes: ${first.signedTransaction.toString()}, second transaction bytes: ${second.signedTransaction.toString()}`,
+ *                     );
+ *                 } catch (e) {
+ *                     console.error('Failed to sign transactions', e);
+ *                 }
+ *             }}
+ *         >
+ *             Sign Transactions
+ *         </button>
+ *     );
+ * }
+ * ```
+ */
+export function useSignTransactions<TWalletAccount extends UiWalletAccount>(
+    uiWalletAccount: TWalletAccount,
+    chain: OnlySolanaChains<TWalletAccount['chains']>,
+): (...inputs: readonly Input[]) => Promise<readonly Output[]>;
+export function useSignTransactions<TWalletAccount extends UiWalletAccount>(
+    uiWalletAccount: TWalletAccount,
+    chain: `solana:${string}`,
+): (...inputs: readonly Input[]) => Promise<readonly Output[]>;
+export function useSignTransactions<TWalletAccount extends UiWalletAccount>(
+    uiWalletAccount: TWalletAccount,
+    chain: `solana:${string}`,
+): (...inputs: readonly Input[]) => Promise<readonly Output[]> {
+    if (!uiWalletAccount.chains.includes(chain)) {
+        throw new WalletStandardError(WALLET_STANDARD_ERROR__FEATURES__WALLET_ACCOUNT_CHAIN_UNSUPPORTED, {
+            address: uiWalletAccount.address,
+            chain,
+            featureName: SolanaSignTransaction,
+            supportedChains: [...uiWalletAccount.chains],
+            supportedFeatures: [...uiWalletAccount.features],
+        });
+    }
+    const signTransactionFeature = getWalletAccountFeature(
+        uiWalletAccount,
+        SolanaSignTransaction,
+    ) as SolanaSignTransactionFeature[typeof SolanaSignTransaction];
+    const account = getWalletAccountForUiWalletAccount_DO_NOT_USE_OR_YOU_WILL_BE_FIRED(uiWalletAccount);
+    return useCallback(
+        async (...inputs) => {
+            if (inputs.length === 0) {
+                return [];
+            }
+            const inputsWithAccountAndChain = inputs.map(({ options, ...rest }) => {
+                const minContextSlot = options?.minContextSlot;
+                return {
+                    ...rest,
+                    account,
+                    chain,
+                    ...(minContextSlot != null
+                        ? {
+                              options: {
+                                  minContextSlot: Number(minContextSlot),
+                              },
+                          }
+                        : null),
+                };
+            });
+            const results = await signTransactionFeature.signTransaction(...inputsWithAccountAndChain);
+            return results;
+        },
+        [signTransactionFeature, account, chain],
+    );
+}

package/src/useWalletAccountMessageSigner.ts

@@ -0,0 +1,98 @@
+import { Address, address } from '@solana/addresses';
+import { bytesEqual } from '@solana/codecs-core';
+import { SOLANA_ERROR__SIGNER__WALLET_MULTISIGN_UNIMPLEMENTED, SolanaError } from '@solana/errors';
+import { SignatureBytes } from '@solana/keys';
+import { getAbortablePromise } from '@solana/promises';
+import { MessageModifyingSigner, SignableMessage } from '@solana/signers';
+import type { UiWalletAccount } from '@wallet-standard/ui';
+import { useMemo } from 'react';
+
+import { useSignMessage } from './useSignMessage';
+
+/**
+ * Use this to get a {@link MessageSigner} capable of signing messages with the private key of a
+ * {@link UiWalletAccount}
+ *
+ * @returns A {@link MessageModifyingSigner}. This is a conservative assumption based on the fact
+ * that your application can not control whether or not the wallet will modify the message before
+ * signing it. Otherwise this method could more specifically return a {@link MessageSigner} or a
+ * {@link MessagePartialSigner}.
+ *
+ * @example
+ * ```tsx
+ * import { useWalletAccountMessageSigner } from '@solana/react';
+ * import { createSignableMessage } from '@solana/signers';
+ *
+ * function SignMessageButton({ account, text }) {
+ *     const messageSigner = useWalletAccountMessageSigner(account);
+ *     return (
+ *         <button
+ *             onClick={async () => {
+ *                 try {
+ *                     const signableMessage = createSignableMessage(text);
+ *                     const [signedMessage] = await messageSigner.modifyAndSignMessages([signableMessage]);
+ *                     const messageWasModified = signableMessage.content !== signedMessage.content;
+ *                     const signatureBytes = signedMessage.signatures[messageSigner.address];
+ *                     window.alert(
+ *                         `Signature bytes: ${signatureBytes.toString()}${
+ *                             messageWasModified ? ' (message was modified)' : ''
+ *                         }`,
+ *                     );
+ *                 } catch (e) {
+ *                     console.error('Failed to sign message', e);
+ *                 }
+ *             }}
+ *         >
+ *             Sign Message: {text}
+ *         </button>
+ *     );
+ * }
+ * ```
+ */
+export function useWalletAccountMessageSigner<TWalletAccount extends UiWalletAccount>(
+    uiWalletAccount: TWalletAccount,
+): MessageModifyingSigner<TWalletAccount['address']> {
+    const signMessage = useSignMessage(uiWalletAccount);
+    return useMemo(
+        () => ({
+            address: address(uiWalletAccount.address),
+            async modifyAndSignMessages(messages, config) {
+                config?.abortSignal?.throwIfAborted();
+                if (messages.length > 1) {
+                    throw new SolanaError(SOLANA_ERROR__SIGNER__WALLET_MULTISIGN_UNIMPLEMENTED);
+                }
+                if (messages.length === 0) {
+                    return messages;
+                }
+                const { content: originalMessage, signatures: originalSignatureMap } = messages[0];
+                const input = {
+                    message: originalMessage,
+                };
+                const { signedMessage, signature } = await getAbortablePromise(signMessage(input), config?.abortSignal);
+                const messageWasModified =
+                    originalMessage.length !== signedMessage.length ||
+                    originalMessage.some((originalByte, ii) => originalByte !== signedMessage[ii]);
+                const originalSignature = originalSignatureMap[uiWalletAccount.address as Address<string>] as
+                    | SignatureBytes
+                    | undefined;
+                const signatureIsNew = originalSignature === undefined || !bytesEqual(originalSignature, signature);
+                if (!signatureIsNew && !messageWasModified) {
+                    // We already had this exact signature, and the message wasn't modified.
+                    // Don't replace the existing message object.
+                    return messages;
+                }
+                const nextSignatureMap = messageWasModified
+                    ? { [uiWalletAccount.address]: signature }
+                    : { ...originalSignatureMap, [uiWalletAccount.address]: signature };
+                const outputMessages = Object.freeze([
+                    Object.freeze({
+                        content: signedMessage,
+                        signatures: Object.freeze(nextSignatureMap),
+                    }) as SignableMessage,
+                ]);
+                return outputMessages;
+            },
+        }),
+        [uiWalletAccount, signMessage],
+    );
+}