Update useWalletAccountTransactionSigner to return a LifetimeConstraint for the updated transaction (#919)

mcintyre94 · web-flow · commit c87cada3ddf0 · 2025-10-03T11:39:26.000+01:00
#### Problem Currently this signer only returns what is required for the signer interface, a `Transaction`. However, per #891 this interface needs to be changed to return a `Transaction & TransactionWithLifetime`, ie augmented with a `lifetimeConstraint` field. #### Summary of Changes The signer now returns a lifetime, by decoding the returned `messageBytes` and comparing the returned `lifetimeToken` with the existing lifetime of the input transaction. - If the input transaction does not have a lifetime, then we create one for the signed transaction using #918. Otherwise: - If the input transaction and signed transaction have identical message bytes, then we return the existing lifetime. Ie if the wallet returns the transaction unchanged. - If the message bytes differ, but the `lifetimeToken` of the signed transaction matches the existing lifetime (either blockhash or nonce field), then we return the existing lifetime. Ie if the wallet modifies the transaction but not its lifetime. - If the lifetime token of the signed transaction differs from that of the input transaction, then we create a new lifetime for the signed transaction using #918. This pre-emptively makes `useWalletAccountTransactionSigner` comply with a stricter interface for `TransactionModifyingSigner` that will require returning `Transaction & TransactionWithLifetime`.
diff --git a/.changeset/sharp-falcons-end.md b/.changeset/sharp-falcons-end.md
@@ -0,0 +1,6 @@
+---
+'@solana/errors': patch
+'@solana/react': patch
+---
+
+Update useWalletAccountTransactionSigner to return a LifetimeConstraint for the updated transaction
diff --git a/packages/react/package.json b/packages/react/package.json
@@ -78,6 +78,7 @@
         "@solana/keys": "workspace:*",
         "@solana/promises": "workspace:*",
         "@solana/signers": "workspace:*",
+        "@solana/transaction-messages": "workspace:*",
         "@solana/transactions": "workspace:*",
         "@solana/wallet-standard-features": "^1.3.0",
         "@wallet-standard/base": "^1.1.0",
@@ -87,6 +88,7 @@
     },
     "devDependencies": {
         "@solana/codecs-core": "workspace:*",
+        "@solana/rpc-types": "workspace:*",
         "@types/react": "^19",
         "@types/react-test-renderer": "^19",
         "react": "^19",
diff --git a/packages/react/src/__tests__/useWalletAccountTransactionSigner-test.ts b/packages/react/src/__tests__/useWalletAccountTransactionSigner-test.ts
@@ -1,15 +1,30 @@
 import { Address } from '@solana/addresses';
-import type { VariableSizeCodec } from '@solana/codecs-core';
-import { SOLANA_ERROR__SIGNER__WALLET_MULTISIGN_UNIMPLEMENTED, SolanaError } from '@solana/errors';
+import type { VariableSizeCodec, VariableSizeDecoder } from '@solana/codecs-core';
+import {
+    SOLANA_ERROR__SIGNER__WALLET_MULTISIGN_UNIMPLEMENTED,
+    SOLANA_ERROR__TRANSACTION__NONCE_ACCOUNT_CANNOT_BE_IN_LOOKUP_TABLE,
+    SolanaError,
+} from '@solana/errors';
 import { SignatureBytes } from '@solana/keys';
-import { Transaction, TransactionMessageBytes } from '@solana/transactions';
+import { Blockhash } from '@solana/rpc-types';
+import {
+    CompiledTransactionMessage,
+    CompiledTransactionMessageWithLifetime,
+    getCompiledTransactionMessageDecoder,
+} from '@solana/transaction-messages';
+import {
+    getTransactionLifetimeConstraintFromCompiledTransactionMessage,
+    Transaction,
+    TransactionMessageBytes,
+} from '@solana/transactions';
 import { getTransactionCodec } from '@solana/transactions';
 import type { UiWalletAccount } from '@wallet-standard/ui';
 
 import { renderHook } from '../test-renderer';
 import { useSignTransaction } from '../useSignTransaction';
 import { useWalletAccountTransactionSigner } from '../useWalletAccountTransactionSigner';
 
+jest.mock('@solana/transaction-messages');
 jest.mock('@solana/transactions');
 jest.mock('../useSignTransaction');
 
@@ -120,8 +135,8 @@ describe('useWalletAccountTransactionSigner', () => {
     });
     it('decodes and returns the signed transaction bytes returned by `signTransactions`', async () => {
         expect.assertions(2);
-        const mockSignedTransaction = new Uint8Array([1, 2, 3]);
-        const mockDecodedTransaction = {} as Transaction;
+        const mockSignedTransaction = new Uint8Array([1, 2, 3, 4, 5, 6]);
+        const mockDecodedTransaction = { messageBytes: [1, 2, 3] } as unknown as Transaction;
         mockSignTransaction.mockResolvedValue({ signedTransaction: mockSignedTransaction });
         mockDecodeTransaction.mockReturnValue(mockDecodedTransaction);
         const { result } = renderHook(() => useWalletAccountTransactionSigner(mockUiWalletAccount, 'solana:danknet'));
@@ -130,7 +145,9 @@ describe('useWalletAccountTransactionSigner', () => {
             throw result.current;
         } else {
             const { modifyAndSignTransactions } = result.current;
+            const lifetimeConstraint = { blockhash: 'abc', lastValidBlockHeight: 123n };
             const inputTransaction = {
+                lifetimeConstraint,
                 messageBytes: new Uint8Array([1, 2, 3]) as unknown as TransactionMessageBytes,
                 signatures: {
                     '11111111111111111111111111111114': new Uint8Array(64).fill(2) as SignatureBytes,
@@ -141,7 +158,7 @@ describe('useWalletAccountTransactionSigner', () => {
             // eslint-disable-next-line jest/no-conditional-expect
             expect(mockDecodeTransaction).toHaveBeenCalledWith(mockSignedTransaction);
             // eslint-disable-next-line jest/no-conditional-expect
-            await expect(signPromise).resolves.toEqual([mockDecodedTransaction]);
+            await expect(signPromise).resolves.toEqual([{ ...mockDecodedTransaction, lifetimeConstraint }]);
         }
     });
     it('calls `signTransaction` with all options except the `abortSignal`', () => {
@@ -193,4 +210,133 @@ describe('useWalletAccountTransactionSigner', () => {
             await expect(signPromise).rejects.toThrow(new Error('o no'));
         }
     });
+    it('returns an unchanged lifetime constraint if the signed transaction has the same one', async () => {
+        expect.assertions(1);
+        const mockSignedTransaction = new Uint8Array([1, 2, 3, 4, 5, 6]);
+        const mockDecodedTransaction = { messageBytes: [4, 5, 6] } as unknown as Transaction;
+        mockSignTransaction.mockResolvedValue({ signedTransaction: mockSignedTransaction });
+        mockDecodeTransaction.mockReturnValue(mockDecodedTransaction);
+        const { result } = renderHook(() => useWalletAccountTransactionSigner(mockUiWalletAccount, 'solana:danknet'));
+        // eslint-disable-next-line jest/no-conditional-in-test
+        if (result.__type === 'error' || !result.current) {
+            throw result.current;
+        } else {
+            const { modifyAndSignTransactions } = result.current;
+            const lifetimeConstraint = { blockhash: 'abc', lastValidBlockHeight: 123n };
+            const inputTransaction = {
+                lifetimeConstraint,
+                messageBytes: new Uint8Array([1, 2, 3]) as unknown as TransactionMessageBytes,
+                signatures: {},
+            };
+            jest.mocked(getCompiledTransactionMessageDecoder).mockReturnValue({
+                decode: jest.fn().mockReturnValue({
+                    lifetimeToken: 'abc',
+                }),
+            } as unknown as VariableSizeDecoder<CompiledTransactionMessage & CompiledTransactionMessageWithLifetime>);
+            const signPromise = modifyAndSignTransactions([inputTransaction]);
+            await jest.runAllTimersAsync();
+            // eslint-disable-next-line jest/no-conditional-expect
+            await expect(signPromise).resolves.toEqual([{ ...mockDecodedTransaction, lifetimeConstraint }]);
+        }
+    });
+    it('returns a new lifetime constraint if the input transaction does not have one', async () => {
+        expect.assertions(1);
+        const mockSignedTransaction = new Uint8Array([1, 2, 3, 4, 5, 6]);
+        const mockDecodedTransaction = { messageBytes: [4, 5, 6] } as unknown as Transaction;
+        mockSignTransaction.mockResolvedValue({ signedTransaction: mockSignedTransaction });
+        mockDecodeTransaction.mockReturnValue(mockDecodedTransaction);
+        const { result } = renderHook(() => useWalletAccountTransactionSigner(mockUiWalletAccount, 'solana:danknet'));
+        // eslint-disable-next-line jest/no-conditional-in-test
+        if (result.__type === 'error' || !result.current) {
+            throw result.current;
+        } else {
+            const { modifyAndSignTransactions } = result.current;
+            const inputTransaction = {
+                messageBytes: new Uint8Array([1, 2, 3]) as unknown as TransactionMessageBytes,
+                signatures: {},
+            };
+            jest.mocked(getCompiledTransactionMessageDecoder).mockReturnValue({
+                decode: jest.fn().mockReturnValue({}),
+            } as unknown as VariableSizeDecoder<CompiledTransactionMessage & CompiledTransactionMessageWithLifetime>);
+            const newLifetimeConstraint = { blockhash: 'abc' as Blockhash, lastValidBlockHeight: 123n };
+            jest.mocked(getTransactionLifetimeConstraintFromCompiledTransactionMessage).mockResolvedValue(
+                newLifetimeConstraint,
+            );
+            const signPromise = modifyAndSignTransactions([inputTransaction]);
+            await jest.runAllTimersAsync();
+            // eslint-disable-next-line jest/no-conditional-expect
+            await expect(signPromise).resolves.toEqual([
+                { ...mockDecodedTransaction, lifetimeConstraint: newLifetimeConstraint },
+            ]);
+        }
+    });
+    it('returns a new lifetime constraint if the signed transaction has a different one', async () => {
+        expect.assertions(1);
+        const mockSignedTransaction = new Uint8Array([1, 2, 3, 4, 5, 6]);
+        const mockDecodedTransaction = { messageBytes: [4, 5, 6] } as unknown as Transaction;
+        mockSignTransaction.mockResolvedValue({ signedTransaction: mockSignedTransaction });
+        mockDecodeTransaction.mockReturnValue(mockDecodedTransaction);
+        const { result } = renderHook(() => useWalletAccountTransactionSigner(mockUiWalletAccount, 'solana:danknet'));
+        // eslint-disable-next-line jest/no-conditional-in-test
+        if (result.__type === 'error' || !result.current) {
+            throw result.current;
+        } else {
+            const { modifyAndSignTransactions } = result.current;
+            const inputLifetimeConstraint = { blockhash: 'abc', lastValidBlockHeight: 123n };
+            const inputTransaction = {
+                lifetimeConstraint: inputLifetimeConstraint,
+                messageBytes: new Uint8Array([1, 2, 3]) as unknown as TransactionMessageBytes,
+                signatures: {},
+            };
+            jest.mocked(getCompiledTransactionMessageDecoder).mockReturnValue({
+                decode: jest.fn().mockReturnValue({
+                    lifetimeToken: 'def',
+                }),
+            } as unknown as VariableSizeDecoder<CompiledTransactionMessage & CompiledTransactionMessageWithLifetime>);
+            const newLifetimeConstraint = { blockhash: 'def' as Blockhash, lastValidBlockHeight: 456n };
+            jest.mocked(getTransactionLifetimeConstraintFromCompiledTransactionMessage).mockResolvedValue(
+                newLifetimeConstraint,
+            );
+            const signPromise = modifyAndSignTransactions([inputTransaction]);
+            await jest.runAllTimersAsync();
+            // eslint-disable-next-line jest/no-conditional-expect
+            await expect(signPromise).resolves.toEqual([
+                { ...mockDecodedTransaction, lifetimeConstraint: newLifetimeConstraint },
+            ]);
+        }
+    });
+    it('fatals when the signed transaction has a new durable nonce lifetime but the nonce account is only in a lookup table', async () => {
+        expect.assertions(1);
+        const mockSignedTransaction = new Uint8Array([1, 2, 3, 4, 5, 6]);
+        const mockDecodedTransaction = { messageBytes: [4, 5, 6] } as unknown as Transaction;
+        mockSignTransaction.mockResolvedValue({ signedTransaction: mockSignedTransaction });
+        mockDecodeTransaction.mockReturnValue(mockDecodedTransaction);
+        const { result } = renderHook(() => useWalletAccountTransactionSigner(mockUiWalletAccount, 'solana:danknet'));
+        // eslint-disable-next-line jest/no-conditional-in-test
+        if (result.__type === 'error' || !result.current) {
+            throw result.current;
+        } else {
+            const { modifyAndSignTransactions } = result.current;
+            const inputTransaction = {
+                messageBytes: new Uint8Array([1, 2, 3]) as unknown as TransactionMessageBytes,
+                signatures: {},
+            };
+            jest.mocked(getCompiledTransactionMessageDecoder).mockReturnValue({
+                decode: jest.fn().mockReturnValue({}),
+            } as unknown as VariableSizeDecoder<CompiledTransactionMessage & CompiledTransactionMessageWithLifetime>);
+            jest.mocked(getTransactionLifetimeConstraintFromCompiledTransactionMessage).mockRejectedValue(
+                new SolanaError(SOLANA_ERROR__TRANSACTION__NONCE_ACCOUNT_CANNOT_BE_IN_LOOKUP_TABLE, {
+                    nonce: 'abc',
+                }),
+            );
+            const signPromise = modifyAndSignTransactions([inputTransaction]);
+            await jest.runAllTimersAsync();
+            // eslint-disable-next-line jest/no-conditional-expect
+            await expect(signPromise).rejects.toThrow(
+                new SolanaError(SOLANA_ERROR__TRANSACTION__NONCE_ACCOUNT_CANNOT_BE_IN_LOOKUP_TABLE, {
+                    nonce: 'abc',
+                }),
+            );
+        }
+    });
 });
diff --git a/packages/react/src/useWalletAccountTransactionSigner.ts b/packages/react/src/useWalletAccountTransactionSigner.ts
@@ -1,8 +1,14 @@
 import { address } from '@solana/addresses';
+import { ReadonlyUint8Array } 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 { getTransactionCodec } from '@solana/transactions';
+import { getCompiledTransactionMessageDecoder } from '@solana/transaction-messages';
+import {
+    getTransactionCodec,
+    getTransactionLifetimeConstraintFromCompiledTransactionMessage,
+    TransactionWithLifetime,
+} from '@solana/transactions';
 import { UiWalletAccount } from '@wallet-standard/ui';
 import { useMemo, useRef } from 'react';
 
@@ -80,9 +86,58 @@ export function useWalletAccountTransactionSigner<TWalletAccount extends UiWalle
                 const decodedSignedTransaction = transactionCodec.decode(
                     signedTransaction,
                 ) as (typeof transactions)[number];
-                return Object.freeze([decodedSignedTransaction]);
+
+                const existingLifetime =
+                    'lifetimeConstraint' in transaction
+                        ? (transaction as TransactionWithLifetime).lifetimeConstraint
+                        : undefined;
+
+                if (existingLifetime) {
+                    if (uint8ArraysEqual(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],
     );
 }
+
+function uint8ArraysEqual(arr1: ReadonlyUint8Array, arr2: ReadonlyUint8Array) {
+    return arr1.length === arr2.length && arr1.every((value, index) => value === arr2[index]);
+}
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
