@solana/react 6.3.1 → 6.3.2-canary-20260313143218

package/src/useWalletAccountTransactionSendingSigner.ts

@@ -0,0 +1,101 @@
+import { address } from '@solana/addresses';
+import { SOLANA_ERROR__SIGNER__WALLET_MULTISIGN_UNIMPLEMENTED, SolanaError } from '@solana/errors';
+import { SignatureBytes } from '@solana/keys';
+import { getAbortablePromise } from '@solana/promises';
+import { TransactionSendingSigner } from '@solana/signers';
+import { getTransactionEncoder } from '@solana/transactions';
+import { UiWalletAccount } from '@wallet-standard/ui';
+import { useMemo, useRef } from 'react';
+
+import { OnlySolanaChains } from './chain';
+import { useSignAndSendTransaction } from './useSignAndSendTransaction';
+
+/**
+ * Use this to get a {@link TransactionSendingSigner} 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 { useWalletAccountTransactionSendingSigner } from '@solana/react';
+ * import {
+ *     appendTransactionMessageInstruction,
+ *     createSolanaRpc,
+ *     getBase58Decoder,
+ *     pipe,
+ *     setTransactionMessageFeePayerSigner,
+ *     setTransactionMessageLifetimeUsingBlockhash,
+ *     signAndSendTransactionMessageWithSigners,
+ * } from '@solana/kit';
+ *
+ * function RecordMemoButton({ account, rpc, text }) {
+ *     const signer = useWalletAccountTransactionSendingSigner(account, 'solana:devnet');
+ *     return (
+ *         <button
+ *             onClick={async () => {
+ *                 try {
+ *                     const { value: latestBlockhash } = await createSolanaRpc('https://api.devnet.solana.com')
+ *                         .getLatestBlockhash()
+ *                         .send();
+ *                     const message = pipe(
+ *                         createTransactionMessage({ version: 'legacy' }),
+ *                         m => setTransactionMessageFeePayerSigner(signer, m),
+ *                         m => setTransactionMessageLifetimeUsingBlockhash(latestBlockhash, m),
+ *                         m => appendTransactionMessageInstruction(getAddMemoInstruction({ memo: text }), m),
+ *                     );
+ *                     const signatureBytes = await signAndSendTransactionMessageWithSigners(message);
+ *                     const base58Signature = getBase58Decoder().decode(signature);
+ *                     window.alert(`View transaction: https://explorer.solana.com/tx/${base58Signature}?cluster=devnet`);
+ *                 } catch (e) {
+ *                     console.error('Failed to record memo', e);
+ *                 }
+ *             }}
+ *         >
+ *             Record Memo
+ *         </button>
+ *     );
+ * }
+ * ```
+ */
+export function useWalletAccountTransactionSendingSigner<TWalletAccount extends UiWalletAccount>(
+    uiWalletAccount: TWalletAccount,
+    chain: OnlySolanaChains<TWalletAccount['chains']>,
+): TransactionSendingSigner<TWalletAccount['address']>;
+export function useWalletAccountTransactionSendingSigner<TWalletAccount extends UiWalletAccount>(
+    uiWalletAccount: TWalletAccount,
+    chain: `solana:${string}`,
+): TransactionSendingSigner<TWalletAccount['address']>;
+export function useWalletAccountTransactionSendingSigner<TWalletAccount extends UiWalletAccount>(
+    uiWalletAccount: TWalletAccount,
+    chain: `solana:${string}`,
+): TransactionSendingSigner<TWalletAccount['address']> {
+    const encoderRef = useRef<ReturnType<typeof getTransactionEncoder> | null>(null);
+    const signAndSendTransaction = useSignAndSendTransaction(uiWalletAccount, chain);
+    return useMemo(
+        () => ({
+            address: address(uiWalletAccount.address),
+            async signAndSendTransactions(transactions, config = {}) {
+                const { abortSignal, ...options } = config;
+                abortSignal?.throwIfAborted();
+                const transactionEncoder = (encoderRef.current ||= getTransactionEncoder());
+                if (transactions.length > 1) {
+                    throw new SolanaError(SOLANA_ERROR__SIGNER__WALLET_MULTISIGN_UNIMPLEMENTED);
+                }
+                if (transactions.length === 0) {
+                    return [];
+                }
+                const [transaction] = transactions;
+                const wireTransactionBytes = transactionEncoder.encode(transaction);
+                const inputWithOptions = {
+                    ...options,
+                    transaction: wireTransactionBytes as Uint8Array,
+                };
+                const { signature } = await getAbortablePromise(signAndSendTransaction(inputWithOptions), abortSignal);
+                return Object.freeze([signature as SignatureBytes]);
+            },
+        }),
+        [signAndSendTransaction, uiWalletAccount.address],
+    );
+}

package/src/useWalletAccountTransactionSigner.ts

@@ -0,0 +1,146 @@
+import { address } from '@solana/addresses';
+import { bytesEqual } from '@solana/codecs-core';
+import { SOLANA_ERROR__SIGNER__WALLET_MULTISIGN_UNIMPLEMENTED, SolanaError } from '@solana/errors';
+import { getAbortablePromise } from '@solana/promises';
+import { TransactionModifyingSigner } from '@solana/signers';
+import { getCompiledTransactionMessageDecoder } from '@solana/transaction-messages';
+import {
+    assertIsTransactionWithinSizeLimit,
+    getTransactionCodec,
+    getTransactionLifetimeConstraintFromCompiledTransactionMessage,
+    Transaction,
+    TransactionWithinSizeLimit,
+    TransactionWithLifetime,
+} from '@solana/transactions';
+import { UiWalletAccount } from '@wallet-standard/ui';
+import { useMemo, useRef } from 'react';
+
+import { OnlySolanaChains } from './chain';
+import { useSignTransaction } from './useSignTransaction';
+
+/**
+ * Use this to get a {@link TransactionSigner} capable of signing serialized transactions with the
+ * private key of a {@link UiWalletAccount}
+ *
+ * @returns A {@link TransactionModifyingSigner}. This is a conservative assumption based on the
+ * fact that your application can not control whether or not the wallet will modify the transaction
+ * before signing it (eg. to add guard instructions, or a priority fee budget). Otherwise this
+ * method could more specifically return a {@link TransactionSigner} or a
+ * {@link TransactionPartialSigner}.
+ *
+ * @example
+ * ```tsx
+ * import { useWalletAccountTransactionSigner } from '@solana/react';
+ *
+ * function SignTransactionButton({ account, transaction }) {
+ *     const transactionSigner = useWalletAccountTransactionSigner(account, 'solana:devnet');
+ *     return (
+ *         <button
+ *             onClick={async () => {
+ *                 try {
+ *                     const [{ signatures }] = await transactionSigner.modifyAndSignTransactions([transaction]);
+ *                     const signatureBytes = signatures[transactionSigner.address];
+ *                     window.alert(`Signature bytes: ${signatureBytes.toString()}`);
+ *                 } catch (e) {
+ *                     console.error('Failed to sign transaction', e);
+ *                 }
+ *             }}
+ *         >
+ *             Sign Transaction
+ *         </button>
+ *     );
+ * }
+ * ```
+ */
+export function useWalletAccountTransactionSigner<TWalletAccount extends UiWalletAccount>(
+    uiWalletAccount: TWalletAccount,
+    chain: OnlySolanaChains<TWalletAccount['chains']>,
+): TransactionModifyingSigner<TWalletAccount['address']>;
+export function useWalletAccountTransactionSigner<TWalletAccount extends UiWalletAccount>(
+    uiWalletAccount: TWalletAccount,
+    chain: `solana:${string}`,
+): TransactionModifyingSigner<TWalletAccount['address']>;
+export function useWalletAccountTransactionSigner<TWalletAccount extends UiWalletAccount>(
+    uiWalletAccount: TWalletAccount,
+    chain: `solana:${string}`,
+): TransactionModifyingSigner<TWalletAccount['address']> {
+    const encoderRef = useRef<ReturnType<typeof getTransactionCodec> | null>(null);
+    const signTransaction = useSignTransaction(uiWalletAccount, chain);
+    return useMemo(
+        () => ({
+            address: address(uiWalletAccount.address),
+            async modifyAndSignTransactions(transactions, config = {}) {
+                const { abortSignal, ...options } = config;
+                abortSignal?.throwIfAborted();
+                const transactionCodec = (encoderRef.current ||= getTransactionCodec());
+                if (transactions.length > 1) {
+                    throw new SolanaError(SOLANA_ERROR__SIGNER__WALLET_MULTISIGN_UNIMPLEMENTED);
+                }
+                if (transactions.length === 0) {
+                    return transactions as readonly (Transaction &
+                        TransactionWithinSizeLimit &
+                        TransactionWithLifetime)[];
+                }
+                const [transaction] = transactions;
+                const wireTransactionBytes = transactionCodec.encode(transaction);
+                const inputWithOptions = {
+                    ...options,
+                    transaction: wireTransactionBytes as Uint8Array,
+                };
+                const { signedTransaction } = await getAbortablePromise(signTransaction(inputWithOptions), abortSignal);
+                const decodedSignedTransaction = transactionCodec.decode(
+                    signedTransaction,
+                ) as (typeof transactions)[number];
+
+                assertIsTransactionWithinSizeLimit(decodedSignedTransaction);
+
+                const existingLifetime =
+                    'lifetimeConstraint' in transaction
+                        ? (transaction as TransactionWithLifetime).lifetimeConstraint
+                        : undefined;
+
+                if (existingLifetime) {
+                    if (bytesEqual(decodedSignedTransaction.messageBytes, transaction.messageBytes)) {
+                        // If the transaction has identical bytes, the lifetime won't have changed
+                        return Object.freeze([
+                            {
+                                ...decodedSignedTransaction,
+                                lifetimeConstraint: existingLifetime,
+                            },
+                        ]);
+                    }
+
+                    // If the transaction has changed, check the lifetime constraint field
+                    const compiledTransactionMessage = getCompiledTransactionMessageDecoder().decode(
+                        decodedSignedTransaction.messageBytes,
+                    );
+                    const currentToken =
+                        'blockhash' in existingLifetime ? existingLifetime.blockhash : existingLifetime.nonce;
+
+                    if (compiledTransactionMessage.lifetimeToken === currentToken) {
+                        return Object.freeze([
+                            {
+                                ...decodedSignedTransaction,
+                                lifetimeConstraint: existingLifetime,
+                            },
+                        ]);
+                    }
+                }
+
+                // If we get here then there is no existing lifetime, or the lifetime has changed. We need to attach a new lifetime
+                const compiledTransactionMessage = getCompiledTransactionMessageDecoder().decode(
+                    decodedSignedTransaction.messageBytes,
+                );
+                const lifetimeConstraint =
+                    await getTransactionLifetimeConstraintFromCompiledTransactionMessage(compiledTransactionMessage);
+                return Object.freeze([
+                    {
+                        ...decodedSignedTransaction,
+                        lifetimeConstraint,
+                    },
+                ]);
+            },
+        }),
+        [uiWalletAccount.address, signTransaction],
+    );
+}