@bitgo-beta/sdk-coin-sol 7.6.4-beta.78 → 7.6.4-beta.780

package/dist/cjs/test/unit/transactionBuilder/customInstructionBuilder.js

@@ -0,0 +1,724 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const should_1 = __importDefault(require("should"));
+const web3_js_1 = require("@solana/web3.js");
+const getBuilderFactory_1 = require("../getBuilderFactory");
+const src_1 = require("../../../src");
+const testData = __importStar(require("../../resources/sol"));
+const bs58_1 = __importDefault(require("bs58"));
+describe('Sol Custom Instruction Builder', () => {
+    const factory = (0, getBuilderFactory_1.getBuilderFactory)('tsol');
+    const customInstructionBuilder = () => {
+        const txBuilder = factory.getCustomInstructionBuilder();
+        txBuilder.nonce(recentBlockHash);
+        txBuilder.sender(authAccount.pub);
+        return txBuilder;
+    };
+    const authAccount = new src_1.KeyPair(testData.authAccount).getKeys();
+    const otherAccount = new src_1.KeyPair({ prv: testData.prvKeys.prvKey1.base58 }).getKeys();
+    const recentBlockHash = 'GHtXQBsoZHVnNFa9YevAzFr17DJjgHXk3ycTKD5xD3Zi';
+    const memo = 'test memo';
+    // Helper to deconstruct a serialized VersionedTransaction into the data shape
+    // consumed by fromVersionedTransactionData
+    function extractVersionedTransactionData(base64Bytes) {
+        const buffer = Buffer.from(base64Bytes, 'base64');
+        const versionedTx = web3_js_1.VersionedTransaction.deserialize(buffer);
+        return {
+            versionedInstructions: versionedTx.message.compiledInstructions.map((ci) => ({
+                programIdIndex: ci.programIdIndex,
+                accountKeyIndexes: ci.accountKeyIndexes,
+                data: bs58_1.default.encode(ci.data),
+            })),
+            addressLookupTables: versionedTx.message.addressTableLookups.map((alt) => ({
+                accountKey: alt.accountKey.toString(),
+                writableIndexes: alt.writableIndexes,
+                readonlyIndexes: alt.readonlyIndexes,
+            })),
+            staticAccountKeys: versionedTx.message.staticAccountKeys.map((key) => key.toString()),
+            messageHeader: {
+                numRequiredSignatures: versionedTx.message.header.numRequiredSignatures,
+                numReadonlySignedAccounts: versionedTx.message.header.numReadonlySignedAccounts,
+                numReadonlyUnsignedAccounts: versionedTx.message.header.numReadonlyUnsignedAccounts,
+            },
+        };
+    }
+    // Helper function to convert TransactionInstruction to the expected format
+    const convertInstructionToParams = (instruction) => ({
+        programId: instruction.programId.toString(),
+        keys: instruction.keys.map((key) => ({
+            pubkey: key.pubkey.toString(),
+            isSigner: key.isSigner,
+            isWritable: key.isWritable,
+        })),
+        data: instruction.data.toString('hex'),
+    });
+    describe('Succeed', () => {
+        it('build a transaction with a single custom instruction', async () => {
+            const transferInstruction = web3_js_1.SystemProgram.transfer({
+                fromPubkey: new web3_js_1.PublicKey(authAccount.pub),
+                toPubkey: new web3_js_1.PublicKey(otherAccount.pub),
+                lamports: 1000000,
+            });
+            const txBuilder = customInstructionBuilder();
+            txBuilder.addCustomInstruction(convertInstructionToParams(transferInstruction));
+            const tx = await txBuilder.build();
+            tx.inputs.length.should.equal(0);
+            const rawTx = tx.toBroadcastFormat();
+            should_1.default.equal(src_1.Utils.isValidRawTransaction(rawTx), true);
+        });
+        it('build a transaction with multiple custom instructions', async () => {
+            const transferInstruction = web3_js_1.SystemProgram.transfer({
+                fromPubkey: new web3_js_1.PublicKey(authAccount.pub),
+                toPubkey: new web3_js_1.PublicKey(otherAccount.pub),
+                lamports: 1000000,
+            });
+            const priorityFeeInstruction = web3_js_1.ComputeBudgetProgram.setComputeUnitPrice({
+                microLamports: 1000,
+            });
+            const txBuilder = customInstructionBuilder();
+            txBuilder.addCustomInstructions([
+                convertInstructionToParams(transferInstruction),
+                convertInstructionToParams(priorityFeeInstruction),
+            ]);
+            const tx = await txBuilder.build();
+            tx.inputs.length.should.equal(0);
+            tx.outputs.length.should.equal(0);
+            const rawTx = tx.toBroadcastFormat();
+            should_1.default.equal(src_1.Utils.isValidRawTransaction(rawTx), true);
+            // Should have 2 instructions
+            tx.solTransaction.instructions.should.have.length(2);
+        });
+        it('build a transaction with custom instruction and memo', async () => {
+            const transferInstruction = web3_js_1.SystemProgram.transfer({
+                fromPubkey: new web3_js_1.PublicKey(authAccount.pub),
+                toPubkey: new web3_js_1.PublicKey(otherAccount.pub),
+                lamports: 1000000,
+            });
+            const txBuilder = customInstructionBuilder();
+            txBuilder.addCustomInstruction(convertInstructionToParams(transferInstruction));
+            txBuilder.memo(memo);
+            const tx = await txBuilder.build();
+            const rawTx = tx.toBroadcastFormat();
+            should_1.default.equal(src_1.Utils.isValidRawTransaction(rawTx), true);
+            // Should have instruction + memo
+            tx.solTransaction.instructions.should.have.length(2);
+        });
+        it('build a signed transaction with custom instruction', async () => {
+            const transferInstruction = web3_js_1.SystemProgram.transfer({
+                fromPubkey: new web3_js_1.PublicKey(authAccount.pub),
+                toPubkey: new web3_js_1.PublicKey(otherAccount.pub),
+                lamports: 1000000,
+            });
+            const txBuilder = customInstructionBuilder();
+            txBuilder.addCustomInstruction(convertInstructionToParams(transferInstruction));
+            txBuilder.sign({ key: authAccount.prv });
+            const tx = await txBuilder.build();
+            const rawTx = tx.toBroadcastFormat();
+            should_1.default.equal(src_1.Utils.isValidRawTransaction(rawTx), true);
+            // Should be signed
+            tx.solTransaction.signatures.should.not.be.empty();
+        });
+        it('clear instructions from builder', async () => {
+            const transferInstruction = web3_js_1.SystemProgram.transfer({
+                fromPubkey: new web3_js_1.PublicKey(authAccount.pub),
+                toPubkey: new web3_js_1.PublicKey(otherAccount.pub),
+                lamports: 1000000,
+            });
+            const txBuilder = customInstructionBuilder();
+            txBuilder.addCustomInstruction(convertInstructionToParams(transferInstruction));
+            txBuilder.getInstructions().should.have.length(1);
+            txBuilder.clearInstructions();
+            txBuilder.getInstructions().should.have.length(0);
+        });
+    });
+    describe('Fail', () => {
+        it('for null instruction', () => {
+            const txBuilder = customInstructionBuilder();
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            (0, should_1.default)(() => txBuilder.addCustomInstruction(null)).throwError('Instruction cannot be null or undefined');
+        });
+        it('for undefined instruction', () => {
+            const txBuilder = customInstructionBuilder();
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            (0, should_1.default)(() => txBuilder.addCustomInstruction(undefined)).throwError('Instruction cannot be null or undefined');
+        });
+        it('for instruction without programId', () => {
+            const txBuilder = customInstructionBuilder();
+            const invalidInstruction = {
+                keys: [],
+                data: '',
+            };
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            (0, should_1.default)(() => txBuilder.addCustomInstruction(invalidInstruction)).throwError('Versioned instruction must have a valid programIdIndex number');
+        });
+        it('for instruction without keys', () => {
+            const txBuilder = customInstructionBuilder();
+            const invalidInstruction = {
+                programId: '11111111111111111111111111111112',
+                data: '',
+            };
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            (0, should_1.default)(() => txBuilder.addCustomInstruction(invalidInstruction)).throwError('Instruction must have valid keys array');
+        });
+        it('for instruction without data', () => {
+            const txBuilder = customInstructionBuilder();
+            const invalidInstruction = {
+                programId: '11111111111111111111111111111112',
+                keys: [],
+            };
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            (0, should_1.default)(() => txBuilder.addCustomInstruction(invalidInstruction)).throwError('Instruction must have valid data string');
+        });
+        it('for non-array in addCustomInstructions', () => {
+            const txBuilder = customInstructionBuilder();
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            (0, should_1.default)(() => txBuilder.addCustomInstructions('invalid')).throwError('Instructions must be an array');
+        });
+        it('when building without instructions', async () => {
+            const txBuilder = customInstructionBuilder();
+            await txBuilder.build().should.be.rejectedWith('At least one custom instruction must be specified');
+        });
+        it('when building without sender', async () => {
+            const transferInstruction = web3_js_1.SystemProgram.transfer({
+                fromPubkey: new web3_js_1.PublicKey(authAccount.pub),
+                toPubkey: new web3_js_1.PublicKey(otherAccount.pub),
+                lamports: 1000000,
+            });
+            const txBuilder = factory.getCustomInstructionBuilder();
+            txBuilder.nonce(recentBlockHash);
+            txBuilder.addCustomInstruction(convertInstructionToParams(transferInstruction));
+            await txBuilder.build().should.be.rejectedWith('Invalid transaction: missing sender');
+        });
+        it('when building without nonce', async () => {
+            const transferInstruction = web3_js_1.SystemProgram.transfer({
+                fromPubkey: new web3_js_1.PublicKey(authAccount.pub),
+                toPubkey: new web3_js_1.PublicKey(otherAccount.pub),
+                lamports: 1000000,
+            });
+            const txBuilder = factory.getCustomInstructionBuilder();
+            txBuilder.sender(authAccount.pub);
+            txBuilder.addCustomInstruction(convertInstructionToParams(transferInstruction));
+            await txBuilder.build().should.be.rejectedWith('Invalid transaction: missing nonce blockhash');
+        });
+    });
+    describe('SolVersionedInstruction Support', () => {
+        it('should accept and validate SolVersionedInstruction format', () => {
+            const compiledInstruction = {
+                programIdIndex: 1,
+                accountKeyIndexes: [0, 2, 3],
+                data: '3Bxs43ZMjSRQLs6o', // base58 encoded instruction data
+            };
+            const txBuilder = customInstructionBuilder();
+            (0, should_1.default)(() => txBuilder.addCustomInstruction(compiledInstruction)).not.throwError();
+            txBuilder.getInstructions().should.have.length(1);
+            const addedInstruction = txBuilder.getInstructions()[0];
+            addedInstruction.params.should.deepEqual(compiledInstruction);
+        });
+        it('should validate versioned instruction format', () => {
+            const txBuilder = customInstructionBuilder();
+            // Invalid programIdIndex
+            (0, should_1.default)(() => txBuilder.addCustomInstruction({
+                programIdIndex: -1,
+                accountKeyIndexes: [0],
+                data: '1', // base58 for 0x00
+            })).throwError('Versioned instruction must have a valid programIdIndex number');
+            // Invalid accountKeyIndexes
+            (0, should_1.default)(() => txBuilder.addCustomInstruction({
+                programIdIndex: 0,
+                accountKeyIndexes: [-1],
+                data: '1', // base58 for 0x00
+            })).throwError('Each accountKeyIndex must be a non-negative number');
+            // Missing data
+            (0, should_1.default)(() => txBuilder.addCustomInstruction({
+                programIdIndex: 0,
+                accountKeyIndexes: [0],
+            })).throwError('Versioned instruction must have valid data string');
+        });
+        it('should handle mixed SolInstruction and SolVersionedInstruction', () => {
+            const traditionalInstruction = convertInstructionToParams(web3_js_1.SystemProgram.transfer({
+                fromPubkey: new web3_js_1.PublicKey(authAccount.pub),
+                toPubkey: new web3_js_1.PublicKey(otherAccount.pub),
+                lamports: 1000000,
+            }));
+            const compiledInstruction = {
+                programIdIndex: 1,
+                accountKeyIndexes: [0, 2],
+                data: '4HSo5YVBrgChTZX5',
+            };
+            const txBuilder = customInstructionBuilder();
+            txBuilder.addCustomInstruction(traditionalInstruction);
+            txBuilder.addCustomInstruction(compiledInstruction);
+            txBuilder.getInstructions().should.have.length(2);
+        });
+    });
+    describe('fromVersionedTransactionData', () => {
+        it('should process VersionedTransactionData and extract instructions', () => {
+            const txBuilder = customInstructionBuilder();
+            const versionedTxData = extractVersionedTransactionData(testData.JUPITER_VERSIONED_TX_BYTES);
+            // Should parse without throwing errors
+            (0, should_1.default)(() => txBuilder.fromVersionedTransactionData(versionedTxData)).not.throwError();
+            // Should have extracted instructions
+            const instructions = txBuilder.getInstructions();
+            instructions.length.should.be.greaterThan(0);
+            for (const instruction of instructions) {
+                instruction.type.should.equal('VersionedCustomInstruction');
+                instruction.params.should.have.property('programIdIndex');
+                instruction.params.should.have.property('accountKeyIndexes');
+                instruction.params.should.have.property('data');
+            }
+        });
+        it('should store VersionedTransactionData in underlying transaction', async () => {
+            const txBuilder = customInstructionBuilder();
+            const versionedTxData = extractVersionedTransactionData(testData.JUPITER_VERSIONED_TX_BYTES);
+            txBuilder.fromVersionedTransactionData(versionedTxData);
+            const tx = txBuilder['_transaction'];
+            const storedData = tx.getVersionedTransactionData();
+            should_1.default.exist(storedData);
+            storedData.versionedInstructions.length.should.equal(versionedTxData.versionedInstructions.length);
+            storedData.addressLookupTables.length.should.equal(versionedTxData.addressLookupTables.length);
+            storedData.staticAccountKeys.length.should.equal(versionedTxData.staticAccountKeys.length);
+        });
+        it('should validate input data', () => {
+            const txBuilder = customInstructionBuilder();
+            // Invalid: null/undefined
+            (0, should_1.default)(() => txBuilder.fromVersionedTransactionData(null)).throwError(/must be a valid object/);
+            (0, should_1.default)(() => txBuilder.fromVersionedTransactionData(undefined)).throwError(/must be a valid object/);
+            // Invalid: empty instructions
+            (0, should_1.default)(() => txBuilder.fromVersionedTransactionData({
+                versionedInstructions: [],
+                addressLookupTables: [],
+                staticAccountKeys: ['test'],
+                messageHeader: { numRequiredSignatures: 1, numReadonlySignedAccounts: 0, numReadonlyUnsignedAccounts: 0 },
+            })).throwError(/non-empty array/);
+            // Invalid: missing addressLookupTables
+            (0, should_1.default)(() => txBuilder.fromVersionedTransactionData({
+                versionedInstructions: [{ programIdIndex: 0, accountKeyIndexes: [0], data: '1' }], // base58 for 0x00
+                staticAccountKeys: ['test'],
+            })).throwError(/must be an array/);
+            // Invalid: empty staticAccountKeys
+            (0, should_1.default)(() => txBuilder.fromVersionedTransactionData({
+                versionedInstructions: [{ programIdIndex: 0, accountKeyIndexes: [0], data: '1' }], // base58 for 0x00
+                addressLookupTables: [],
+                staticAccountKeys: [],
+                messageHeader: { numRequiredSignatures: 1, numReadonlySignedAccounts: 0, numReadonlyUnsignedAccounts: 0 },
+            })).throwError(/non-empty array/);
+        });
+        it('should work with the complete transaction building flow', async () => {
+            const txBuilder = customInstructionBuilder();
+            const versionedTxData = extractVersionedTransactionData(testData.JUPITER_VERSIONED_TX_BYTES);
+            // Process the VersionedTransactionData
+            txBuilder.fromVersionedTransactionData(versionedTxData);
+            txBuilder.sender(versionedTxData.staticAccountKeys[0]); // Fee payer
+            txBuilder.nonce(testData.blockHashes.validBlockHashes[0]);
+            const tx = await txBuilder.build();
+            // Verify transaction properties
+            tx.should.be.ok();
+            tx.type.should.equal(31); // TransactionType.CustomTx enum value
+            // Verify signable payload
+            const payload = tx.signablePayload;
+            payload.should.be.instanceOf(Buffer);
+            payload.length.should.be.greaterThan(0);
+            // Verify payload is deterministic - rebuilding with same params produces same payload
+            const txBuilder2 = customInstructionBuilder();
+            txBuilder2.fromVersionedTransactionData(versionedTxData);
+            txBuilder2.sender(versionedTxData.staticAccountKeys[0]);
+            txBuilder2.nonce(testData.blockHashes.validBlockHashes[0]);
+            const tx2 = await txBuilder2.build();
+            should_1.default.equal(tx2.signablePayload.toString('hex'), payload.toString('hex'));
+        });
+        it('should extract the correct number of instructions from Jupiter transaction', () => {
+            const txBuilder = customInstructionBuilder();
+            const versionedTxData = extractVersionedTransactionData(testData.JUPITER_VERSIONED_TX_BYTES);
+            txBuilder.fromVersionedTransactionData(versionedTxData);
+            const instructions = txBuilder.getInstructions();
+            // Verify we extracted instructions
+            instructions.length.should.be.greaterThan(0);
+            instructions.length.should.equal(versionedTxData.versionedInstructions.length);
+            // Verify each instruction has valid compiled format
+            for (const instruction of instructions) {
+                const params = instruction.params;
+                (typeof params.programIdIndex).should.equal('number');
+                params.programIdIndex.should.be.greaterThanOrEqual(0);
+                Array.isArray(params.accountKeyIndexes).should.equal(true);
+                (typeof params.data).should.equal('string');
+                // Data should be valid base58 string (non-empty)
+                params.data.length.should.be.greaterThan(0);
+                // Verify it can be decoded
+                should_1.default.doesNotThrow(() => bs58_1.default.decode(params.data));
+            }
+        });
+        it('should clear instructions properly after using fromVersionedTransactionData', () => {
+            const txBuilder = customInstructionBuilder();
+            const versionedTxData = extractVersionedTransactionData(testData.JUPITER_VERSIONED_TX_BYTES);
+            txBuilder.fromVersionedTransactionData(versionedTxData);
+            txBuilder.getInstructions().length.should.be.greaterThan(0);
+            // Clear should work
+            txBuilder.clearInstructions();
+            txBuilder.getInstructions().should.have.length(0);
+        });
+        it('should extract fee payer from staticAccountKeys', () => {
+            const txBuilder = factory.getCustomInstructionBuilder();
+            txBuilder.nonce(recentBlockHash);
+            const versionedTxData = extractVersionedTransactionData(testData.JUPITER_VERSIONED_TX_BYTES);
+            txBuilder.fromVersionedTransactionData(versionedTxData);
+            const sender = txBuilder['_sender'];
+            should_1.default.exist(sender);
+            sender.should.equal(versionedTxData.staticAccountKeys[0]);
+        });
+        it('should not override existing sender', () => {
+            const txBuilder = customInstructionBuilder();
+            const versionedTxData = extractVersionedTransactionData(testData.JUPITER_VERSIONED_TX_BYTES);
+            const originalSender = txBuilder['_sender'];
+            txBuilder.fromVersionedTransactionData(versionedTxData);
+            const sender = txBuilder['_sender'];
+            sender.should.equal(originalSender);
+            sender.should.equal(authAccount.pub);
+        });
+    });
+    describe('durable nonce injection', () => {
+        const SYSTEM_PROGRAM_ID = web3_js_1.SystemProgram.programId.toBase58();
+        const SYSVAR_RECENT_BLOCKHASHES_ID = web3_js_1.SYSVAR_RECENT_BLOCKHASHES_PUBKEY.toBase58();
+        const walletNonceAddress = testData.nonceAccount.pub;
+        const authWalletAddress = authAccount.pub;
+        const seededPublicKey = (seed) => web3_js_1.Keypair.fromSeed(Buffer.alloc(32, seed)).publicKey;
+        // Deterministic fixture keys covering all four MessageV0 header sections
+        const fixturePayer = seededPublicKey(11); // writable signer (account 0)
+        const fixtureRoSigner = seededPublicKey(12); // read-only signer
+        const fixtureWritableNonSigner = seededPublicKey(13);
+        const fixtureRoNonSigner = seededPublicKey(14);
+        const fixtureAltWritable = seededPublicKey(15); // loaded from the lookup table
+        const fixtureAltReadonly = seededPublicKey(16); // loaded from the lookup table
+        const fixtureProgram = seededPublicKey(17);
+        // The lookup table has filler addresses at indexes 0 and 2 so the
+        // referenced indexes (1 writable, 3 readonly) are non-trivial
+        const lookupTableAccount = new web3_js_1.AddressLookupTableAccount({
+            key: seededPublicKey(200),
+            state: {
+                deactivationSlot: BigInt(0),
+                lastExtendedSlot: 0,
+                lastExtendedSlotStartIndex: 0,
+                addresses: [seededPublicKey(90), fixtureAltWritable, seededPublicKey(91), fixtureAltReadonly],
+            },
+        });
+        /**
+         * Compile versioned transaction data through web3.js with a lookup table,
+         * mirroring the data callers extract from a real VersionedTransaction.
+         */
+        function buildVersionedFixture(payerKey, instructions) {
+            const message = web3_js_1.MessageV0.compile({
+                payerKey,
+                recentBlockhash: recentBlockHash,
+                addressLookupTableAccounts: [lookupTableAccount],
+                instructions: instructions.map((ix) => new web3_js_1.TransactionInstruction({
+                    programId: ix.programId,
+                    keys: ix.keys,
+                    data: Buffer.from([1, 2, 3, 4]),
+                })),
+            });
+            const data = {
+                versionedInstructions: message.compiledInstructions.map((ci) => ({
+                    programIdIndex: ci.programIdIndex,
+                    accountKeyIndexes: [...ci.accountKeyIndexes],
+                    data: bs58_1.default.encode(ci.data),
+                })),
+                addressLookupTables: message.addressTableLookups.map((alt) => ({
+                    accountKey: alt.accountKey.toBase58(),
+                    writableIndexes: [...alt.writableIndexes],
+                    readonlyIndexes: [...alt.readonlyIndexes],
+                })),
+                staticAccountKeys: message.staticAccountKeys.map((key) => key.toBase58()),
+                messageHeader: {
+                    numRequiredSignatures: message.header.numRequiredSignatures,
+                    numReadonlySignedAccounts: message.header.numReadonlySignedAccounts,
+                    numReadonlyUnsignedAccounts: message.header.numReadonlyUnsignedAccounts,
+                },
+                recentBlockhash: recentBlockHash,
+            };
+            return { message, data };
+        }
+        /** Compile processed VersionedTransactionData back into a MessageV0 */
+        function compileProcessedMessage(data) {
+            return new web3_js_1.MessageV0({
+                header: { ...data.messageHeader },
+                staticAccountKeys: data.staticAccountKeys.map((key) => new web3_js_1.PublicKey(key)),
+                recentBlockhash: data.recentBlockhash ?? recentBlockHash,
+                compiledInstructions: data.versionedInstructions.map((instruction) => ({
+                    programIdIndex: instruction.programIdIndex,
+                    accountKeyIndexes: [...instruction.accountKeyIndexes],
+                    data: Buffer.from(bs58_1.default.decode(instruction.data)),
+                })),
+                addressTableLookups: data.addressLookupTables.map((alt) => ({
+                    accountKey: new web3_js_1.PublicKey(alt.accountKey),
+                    writableIndexes: [...alt.writableIndexes],
+                    readonlyIndexes: [...alt.readonlyIndexes],
+                })),
+            });
+        }
+        /** Inject the durable nonce advance instruction and return the processed data */
+        function injectNonceAdvance(data) {
+            const txBuilder = factory.getCustomInstructionBuilder();
+            txBuilder.nonce(recentBlockHash, { walletNonceAddress, authWalletAddress });
+            txBuilder.fromVersionedTransactionData(data);
+            const processed = txBuilder['_transaction'].getVersionedTransactionData();
+            should_1.default.exist(processed);
+            return processed;
+        }
+        /** Fixture using every header section and both lookup-table slots */
+        const mainFixture = () => buildVersionedFixture(fixturePayer, [
+            {
+                programId: fixtureProgram,
+                keys: [
+                    { pubkey: fixturePayer, isSigner: true, isWritable: true },
+                    { pubkey: fixtureRoSigner, isSigner: true, isWritable: false },
+                    { pubkey: fixtureAltWritable, isSigner: false, isWritable: true },
+                    { pubkey: fixtureAltReadonly, isSigner: false, isWritable: false },
+                    { pubkey: fixtureWritableNonSigner, isSigner: false, isWritable: true },
+                    { pubkey: fixtureRoNonSigner, isSigner: false, isWritable: false },
+                ],
+            },
+        ]);
+        it('keeps lookup-table-referencing instructions pointing at the same accounts', () => {
+            const { message, data } = mainFixture();
+            const processed = injectNonceAdvance(data);
+            // The fixture must actually reference accounts loaded from the lookup table
+            Math.max(...data.versionedInstructions.flatMap((ix) => [...ix.accountKeyIndexes, ix.programIdIndex])).should.be.greaterThanOrEqual(data.staticAccountKeys.length);
+            const before = message.getAccountKeys({ addressLookupTableAccounts: [lookupTableAccount] });
+            const after = compileProcessedMessage(processed).getAccountKeys({
+                addressLookupTableAccounts: [lookupTableAccount],
+            });
+            processed.versionedInstructions.should.have.length(data.versionedInstructions.length + 1);
+            const remappedInstructions = processed.versionedInstructions.slice(1);
+            remappedInstructions.forEach((instruction, ixIndex) => {
+                const original = data.versionedInstructions[ixIndex];
+                before.get(original.programIdIndex).toBase58().should.equal(after.get(instruction.programIdIndex).toBase58());
+                instruction.accountKeyIndexes.should.have.length(original.accountKeyIndexes.length);
+                original.accountKeyIndexes.forEach((_, k) => {
+                    before
+                        .get(original.accountKeyIndexes[k])
+                        .toBase58()
+                        .should.equal(after.get(instruction.accountKeyIndexes[k]).toBase58());
+                });
+                instruction.data.should.equal(original.data);
+            });
+        });
+        it('keeps Jupiter lookup-table accounts pointing at the same accounts', () => {
+            const data = extractVersionedTransactionData(testData.JUPITER_VERSIONED_TX_BYTES);
+            const processed = injectNonceAdvance(data);
+            // authority, nonce account and sysvar are added; the system program is already present
+            const shift = processed.staticAccountKeys.length - data.staticAccountKeys.length;
+            shift.should.equal(3);
+            processed.messageHeader.should.deepEqual({
+                numRequiredSignatures: 2,
+                numReadonlySignedAccounts: 1,
+                numReadonlyUnsignedAccounts: 6,
+            });
+            const oldStaticLen = data.staticAccountKeys.length;
+            const remappedInstructions = processed.versionedInstructions.slice(1);
+            remappedInstructions.forEach((instruction, ixIndex) => {
+                const original = data.versionedInstructions[ixIndex];
+                const remappedProgramIndex = instruction.programIdIndex;
+                if (original.programIdIndex < oldStaticLen) {
+                    processed.staticAccountKeys[remappedProgramIndex].should.equal(data.staticAccountKeys[original.programIdIndex]);
+                }
+                else {
+                    remappedProgramIndex.should.equal(original.programIdIndex + shift);
+                }
+                original.accountKeyIndexes.forEach((oldIndex, k) => {
+                    const newIndex = instruction.accountKeyIndexes[k];
+                    if (oldIndex < oldStaticLen) {
+                        processed.staticAccountKeys[newIndex].should.equal(data.staticAccountKeys[oldIndex]);
+                    }
+                    else {
+                        newIndex.should.equal(oldIndex + shift);
+                    }
+                });
+            });
+        });
+        it('makes the nonce account writable and keeps original read-only accounts read-only', () => {
+            const { data } = mainFixture();
+            const processed = injectNonceAdvance(data);
+            const message = compileProcessedMessage(processed);
+            // header adjusted for the new authority, nonce account, sysvar and system program
+            processed.messageHeader.should.deepEqual({
+                numRequiredSignatures: 3, // payer + ro signer + new authority
+                numReadonlySignedAccounts: 2, // ro signer + new authority
+                numReadonlyUnsignedAccounts: 4, // ro non-signer, program, system program, sysvar
+            });
+            const indexOf = (key) => processed.staticAccountKeys.indexOf(key);
+            // AdvanceNonceAccount requires a writable nonce account
+            message.isAccountWritable(indexOf(walletNonceAddress)).should.equal(true);
+            // original accounts keep their writability
+            message.isAccountWritable(indexOf(fixturePayer.toBase58())).should.equal(true);
+            message.isAccountWritable(indexOf(fixtureWritableNonSigner.toBase58())).should.equal(true);
+            message.isAccountWritable(indexOf(fixtureRoSigner.toBase58())).should.equal(false);
+            message.isAccountWritable(indexOf(fixtureRoNonSigner.toBase58())).should.equal(false);
+            message.isAccountWritable(indexOf(fixtureProgram.toBase58())).should.equal(false);
+            // the new authority is a read-only signer
+            message.isAccountSigner(indexOf(authWalletAddress)).should.equal(true);
+            message.isAccountWritable(indexOf(authWalletAddress)).should.equal(false);
+            // no duplicate keys
+            new Set(processed.staticAccountKeys).size.should.equal(processed.staticAccountKeys.length);
+        });
+        it('prepends a well-formed AdvanceNonceAccount instruction', () => {
+            const { data } = mainFixture();
+            const processed = injectNonceAdvance(data);
+            const [nonceAdvance] = processed.versionedInstructions;
+            should_1.default.exist(nonceAdvance);
+            nonceAdvance.data.should.equal('6vx8P'); // SystemProgram AdvanceNonceAccount
+            nonceAdvance.programIdIndex.should.equal(processed.staticAccountKeys.indexOf(SYSTEM_PROGRAM_ID));
+            nonceAdvance.accountKeyIndexes.should.deepEqual([
+                processed.staticAccountKeys.indexOf(walletNonceAddress),
+                processed.staticAccountKeys.indexOf(SYSVAR_RECENT_BLOCKHASHES_ID),
+                processed.staticAccountKeys.indexOf(authWalletAddress),
+            ]);
+        });
+        it('turns an authority already present as a writable non-signer into a writable signer, once', () => {
+            const { data } = buildVersionedFixture(fixturePayer, [
+                {
+                    programId: fixtureProgram,
+                    keys: [
+                        { pubkey: fixturePayer, isSigner: true, isWritable: true },
+                        // authority already present as a writable non-signer
+                        { pubkey: new web3_js_1.PublicKey(authWalletAddress), isSigner: false, isWritable: true },
+                        { pubkey: fixtureRoNonSigner, isSigner: false, isWritable: false },
+                    ],
+                },
+            ]);
+            const processed = injectNonceAdvance(data);
+            const message = compileProcessedMessage(processed);
+            // appears once, as a signer, keeping its writability
+            processed.staticAccountKeys.filter((key) => key === authWalletAddress).should.have.length(1);
+            const authIndex = processed.staticAccountKeys.indexOf(authWalletAddress);
+            message.isAccountSigner(authIndex).should.equal(true);
+            message.isAccountWritable(authIndex).should.equal(true);
+            processed.messageHeader.numRequiredSignatures.should.equal(data.messageHeader.numRequiredSignatures + 1);
+            processed.messageHeader.numReadonlySignedAccounts.should.equal(data.messageHeader.numReadonlySignedAccounts);
+        });
+        it('turns an authority already present as a read-only non-signer into a read-only signer, once', () => {
+            const { data } = buildVersionedFixture(fixturePayer, [
+                {
+                    programId: fixtureProgram,
+                    keys: [
+                        { pubkey: fixturePayer, isSigner: true, isWritable: true },
+                        // authority already present as a read-only non-signer
+                        { pubkey: new web3_js_1.PublicKey(authWalletAddress), isSigner: false, isWritable: false },
+                        { pubkey: fixtureWritableNonSigner, isSigner: false, isWritable: true },
+                    ],
+                },
+            ]);
+            const processed = injectNonceAdvance(data);
+            const message = compileProcessedMessage(processed);
+            // appears once, as a read-only signer
+            processed.staticAccountKeys.filter((key) => key === authWalletAddress).should.have.length(1);
+            const authIndex = processed.staticAccountKeys.indexOf(authWalletAddress);
+            message.isAccountSigner(authIndex).should.equal(true);
+            message.isAccountWritable(authIndex).should.equal(false);
+            processed.messageHeader.numRequiredSignatures.should.equal(data.messageHeader.numRequiredSignatures + 1);
+            processed.messageHeader.numReadonlySignedAccounts.should.equal(data.messageHeader.numReadonlySignedAccounts + 1);
+            // it left the read-only non-signers (system program + sysvar are added)
+            processed.messageHeader.numReadonlyUnsignedAccounts.should.equal(data.messageHeader.numReadonlyUnsignedAccounts + 1);
+        });
+        it('does not add a signer when the nonce authority is already the fee payer', () => {
+            const { data } = buildVersionedFixture(new web3_js_1.PublicKey(authWalletAddress), [
+                {
+                    programId: fixtureProgram,
+                    keys: [
+                        { pubkey: new web3_js_1.PublicKey(authWalletAddress), isSigner: true, isWritable: true },
+                        { pubkey: fixtureWritableNonSigner, isSigner: false, isWritable: true },
+                    ],
+                },
+            ]);
+            const processed = injectNonceAdvance(data);
+            const message = compileProcessedMessage(processed);
+            processed.staticAccountKeys[0].should.equal(authWalletAddress);
+            processed.staticAccountKeys.filter((key) => key === authWalletAddress).should.have.length(1);
+            processed.messageHeader.numRequiredSignatures.should.equal(data.messageHeader.numRequiredSignatures);
+            processed.messageHeader.numReadonlySignedAccounts.should.equal(data.messageHeader.numReadonlySignedAccounts);
+            message.isAccountSigner(0).should.equal(true);
+        });
+        it('moves a nonce account already present as read-only into the writable non-signers', () => {
+            const { data } = buildVersionedFixture(fixturePayer, [
+                {
+                    programId: fixtureProgram,
+                    keys: [
+                        { pubkey: fixturePayer, isSigner: true, isWritable: true },
+                        { pubkey: fixtureRoNonSigner, isSigner: false, isWritable: false },
+                        // nonce account already present as a read-only non-signer
+                        { pubkey: new web3_js_1.PublicKey(walletNonceAddress), isSigner: false, isWritable: false },
+                    ],
+                },
+            ]);
+            const processed = injectNonceAdvance(data);
+            const message = compileProcessedMessage(processed);
+            processed.staticAccountKeys.filter((key) => key === walletNonceAddress).should.have.length(1);
+            const nonceIndex = processed.staticAccountKeys.indexOf(walletNonceAddress);
+            message.isAccountWritable(nonceIndex).should.equal(true);
+            message.isAccountSigner(nonceIndex).should.equal(false);
+            // the other original read-only account stays read-only
+            message.isAccountWritable(processed.staticAccountKeys.indexOf(fixtureRoNonSigner.toBase58())).should.equal(false);
+        });
+        it('produces a signable payload that deserializes as a MessageV0 with the nonce advance first', async () => {
+            const { data } = mainFixture();
+            const txBuilder = factory.getCustomInstructionBuilder();
+            txBuilder.nonce(recentBlockHash, { walletNonceAddress, authWalletAddress });
+            txBuilder.fromVersionedTransactionData(data);
+            const tx = await txBuilder.build();
+            const message = web3_js_1.MessageV0.deserialize(tx.signablePayload);
+            message.compiledInstructions.should.have.length(data.versionedInstructions.length + 1);
+            const nonceAdvance = message.compiledInstructions[0];
+            message.staticAccountKeys[nonceAdvance.programIdIndex].toBase58().should.equal(SYSTEM_PROGRAM_ID);
+            message.staticAccountKeys[nonceAdvance.accountKeyIndexes[0]].toBase58().should.equal(walletNonceAddress);
+            message.staticAccountKeys[nonceAdvance.accountKeyIndexes[1]]
+                .toBase58()
+                .should.equal(SYSVAR_RECENT_BLOCKHASHES_ID);
+            message.staticAccountKeys[nonceAdvance.accountKeyIndexes[2]].toBase58().should.equal(authWalletAddress);
+        });
+        it('rejects versioned data whose message header is inconsistent', () => {
+            const { data } = mainFixture();
+            const inconsistent = {
+                ...data,
+                messageHeader: { ...data.messageHeader, numReadonlyUnsignedAccounts: 99 },
+            };
+            const txBuilder = factory.getCustomInstructionBuilder();
+            txBuilder.nonce(recentBlockHash, { walletNonceAddress, authWalletAddress });
+            (0, should_1.default)(() => txBuilder.fromVersionedTransactionData(inconsistent)).throwError(/Invalid message header/);
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"customInstructionBuilder.js","sourceRoot":"","sources":["../../../../../test/unit/transactionBuilder/customInstructionBuilder.ts"],"names":[],"mappings":"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","sourcesContent":["import should from 'should';\nimport {\n  SystemProgram,\n  PublicKey,\n  TransactionInstruction,\n  ComputeBudgetProgram,\n  VersionedTransaction,\n  Keypair,\n  MessageV0,\n  AddressLookupTableAccount,\n  SYSVAR_RECENT_BLOCKHASHES_PUBKEY,\n} from '@solana/web3.js';\nimport { getBuilderFactory } from '../getBuilderFactory';\nimport { KeyPair, Utils, Transaction } from '../../../src';\nimport * as testData from '../../resources/sol';\nimport { SolVersionedInstruction } from '@bitgo-beta/sdk-core';\nimport { VersionedTransactionData } from '../../../src/lib/iface';\nimport base58 from 'bs58';\n\ndescribe('Sol Custom Instruction Builder', () => {\n  const factory = getBuilderFactory('tsol');\n\n  const customInstructionBuilder = () => {\n    const txBuilder = factory.getCustomInstructionBuilder();\n    txBuilder.nonce(recentBlockHash);\n    txBuilder.sender(authAccount.pub);\n    return txBuilder;\n  };\n\n  const authAccount = new KeyPair(testData.authAccount).getKeys();\n  const otherAccount = new KeyPair({ prv: testData.prvKeys.prvKey1.base58 }).getKeys();\n  const recentBlockHash = 'GHtXQBsoZHVnNFa9YevAzFr17DJjgHXk3ycTKD5xD3Zi';\n  const memo = 'test memo';\n\n  // Helper to deconstruct a serialized VersionedTransaction into the data shape\n  // consumed by fromVersionedTransactionData\n  function extractVersionedTransactionData(base64Bytes: string): VersionedTransactionData {\n    const buffer = Buffer.from(base64Bytes, 'base64');\n    const versionedTx = VersionedTransaction.deserialize(buffer);\n\n    return {\n      versionedInstructions: versionedTx.message.compiledInstructions.map((ci) => ({\n        programIdIndex: ci.programIdIndex,\n        accountKeyIndexes: ci.accountKeyIndexes,\n        data: base58.encode(ci.data),\n      })),\n      addressLookupTables: versionedTx.message.addressTableLookups.map((alt) => ({\n        accountKey: alt.accountKey.toString(),\n        writableIndexes: alt.writableIndexes,\n        readonlyIndexes: alt.readonlyIndexes,\n      })),\n      staticAccountKeys: versionedTx.message.staticAccountKeys.map((key) => key.toString()),\n      messageHeader: {\n        numRequiredSignatures: versionedTx.message.header.numRequiredSignatures,\n        numReadonlySignedAccounts: versionedTx.message.header.numReadonlySignedAccounts,\n        numReadonlyUnsignedAccounts: versionedTx.message.header.numReadonlyUnsignedAccounts,\n      },\n    };\n  }\n\n  // Helper function to convert TransactionInstruction to the expected format\n  const convertInstructionToParams = (instruction: TransactionInstruction) => ({\n    programId: instruction.programId.toString(),\n    keys: instruction.keys.map((key) => ({\n      pubkey: key.pubkey.toString(),\n      isSigner: key.isSigner,\n      isWritable: key.isWritable,\n    })),\n    data: instruction.data.toString('hex'),\n  });\n\n  describe('Succeed', () => {\n    it('build a transaction with a single custom instruction', async () => {\n      const transferInstruction = SystemProgram.transfer({\n        fromPubkey: new PublicKey(authAccount.pub),\n        toPubkey: new PublicKey(otherAccount.pub),\n        lamports: 1000000,\n      });\n\n      const txBuilder = customInstructionBuilder();\n      txBuilder.addCustomInstruction(convertInstructionToParams(transferInstruction));\n      const tx = await txBuilder.build();\n\n      tx.inputs.length.should.equal(0);\n\n      const rawTx = tx.toBroadcastFormat();\n      should.equal(Utils.isValidRawTransaction(rawTx), true);\n    });\n\n    it('build a transaction with multiple custom instructions', async () => {\n      const transferInstruction = SystemProgram.transfer({\n        fromPubkey: new PublicKey(authAccount.pub),\n        toPubkey: new PublicKey(otherAccount.pub),\n        lamports: 1000000,\n      });\n\n      const priorityFeeInstruction = ComputeBudgetProgram.setComputeUnitPrice({\n        microLamports: 1000,\n      });\n\n      const txBuilder = customInstructionBuilder();\n      txBuilder.addCustomInstructions([\n        convertInstructionToParams(transferInstruction),\n        convertInstructionToParams(priorityFeeInstruction),\n      ]);\n      const tx = await txBuilder.build();\n\n      tx.inputs.length.should.equal(0);\n      tx.outputs.length.should.equal(0);\n\n      const rawTx = tx.toBroadcastFormat();\n      should.equal(Utils.isValidRawTransaction(rawTx), true);\n\n      // Should have 2 instructions\n      (tx as Transaction).solTransaction.instructions.should.have.length(2);\n    });\n\n    it('build a transaction with custom instruction and memo', async () => {\n      const transferInstruction = SystemProgram.transfer({\n        fromPubkey: new PublicKey(authAccount.pub),\n        toPubkey: new PublicKey(otherAccount.pub),\n        lamports: 1000000,\n      });\n\n      const txBuilder = customInstructionBuilder();\n      txBuilder.addCustomInstruction(convertInstructionToParams(transferInstruction));\n      txBuilder.memo(memo);\n      const tx = await txBuilder.build();\n\n      const rawTx = tx.toBroadcastFormat();\n      should.equal(Utils.isValidRawTransaction(rawTx), true);\n\n      // Should have instruction + memo\n      (tx as Transaction).solTransaction.instructions.should.have.length(2);\n    });\n\n    it('build a signed transaction with custom instruction', async () => {\n      const transferInstruction = SystemProgram.transfer({\n        fromPubkey: new PublicKey(authAccount.pub),\n        toPubkey: new PublicKey(otherAccount.pub),\n        lamports: 1000000,\n      });\n\n      const txBuilder = customInstructionBuilder();\n      txBuilder.addCustomInstruction(convertInstructionToParams(transferInstruction));\n      txBuilder.sign({ key: authAccount.prv });\n      const tx = await txBuilder.build();\n\n      const rawTx = tx.toBroadcastFormat();\n      should.equal(Utils.isValidRawTransaction(rawTx), true);\n\n      // Should be signed\n      (tx as Transaction).solTransaction.signatures.should.not.be.empty();\n    });\n\n    it('clear instructions from builder', async () => {\n      const transferInstruction = SystemProgram.transfer({\n        fromPubkey: new PublicKey(authAccount.pub),\n        toPubkey: new PublicKey(otherAccount.pub),\n        lamports: 1000000,\n      });\n\n      const txBuilder = customInstructionBuilder();\n      txBuilder.addCustomInstruction(convertInstructionToParams(transferInstruction));\n      txBuilder.getInstructions().should.have.length(1);\n\n      txBuilder.clearInstructions();\n      txBuilder.getInstructions().should.have.length(0);\n    });\n  });\n\n  // Type for testing invalid instruction formats\n  interface InvalidInstruction {\n    programId?: string;\n    keys?: unknown;\n    data?: unknown;\n  }\n\n  describe('Fail', () => {\n    it('for null instruction', () => {\n      const txBuilder = customInstructionBuilder();\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      should(() => txBuilder.addCustomInstruction(null as any)).throwError('Instruction cannot be null or undefined');\n    });\n\n    it('for undefined instruction', () => {\n      const txBuilder = customInstructionBuilder();\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      should(() => txBuilder.addCustomInstruction(undefined as any)).throwError(\n        'Instruction cannot be null or undefined'\n      );\n    });\n\n    it('for instruction without programId', () => {\n      const txBuilder = customInstructionBuilder();\n      const invalidInstruction: InvalidInstruction = {\n        keys: [],\n        data: '',\n      };\n\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      should(() => txBuilder.addCustomInstruction(invalidInstruction as any)).throwError(\n        'Versioned instruction must have a valid programIdIndex number'\n      );\n    });\n\n    it('for instruction without keys', () => {\n      const txBuilder = customInstructionBuilder();\n      const invalidInstruction: InvalidInstruction = {\n        programId: '11111111111111111111111111111112',\n        data: '',\n      };\n\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      should(() => txBuilder.addCustomInstruction(invalidInstruction as any)).throwError(\n        'Instruction must have valid keys array'\n      );\n    });\n\n    it('for instruction without data', () => {\n      const txBuilder = customInstructionBuilder();\n      const invalidInstruction: InvalidInstruction = {\n        programId: '11111111111111111111111111111112',\n        keys: [],\n      };\n\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      should(() => txBuilder.addCustomInstruction(invalidInstruction as any)).throwError(\n        'Instruction must have valid data string'\n      );\n    });\n\n    it('for non-array in addCustomInstructions', () => {\n      const txBuilder = customInstructionBuilder();\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      should(() => txBuilder.addCustomInstructions('invalid' as any)).throwError('Instructions must be an array');\n    });\n\n    it('when building without instructions', async () => {\n      const txBuilder = customInstructionBuilder();\n      await txBuilder.build().should.be.rejectedWith('At least one custom instruction must be specified');\n    });\n\n    it('when building without sender', async () => {\n      const transferInstruction = SystemProgram.transfer({\n        fromPubkey: new PublicKey(authAccount.pub),\n        toPubkey: new PublicKey(otherAccount.pub),\n        lamports: 1000000,\n      });\n\n      const txBuilder = factory.getCustomInstructionBuilder();\n      txBuilder.nonce(recentBlockHash);\n      txBuilder.addCustomInstruction(convertInstructionToParams(transferInstruction));\n\n      await txBuilder.build().should.be.rejectedWith('Invalid transaction: missing sender');\n    });\n\n    it('when building without nonce', async () => {\n      const transferInstruction = SystemProgram.transfer({\n        fromPubkey: new PublicKey(authAccount.pub),\n        toPubkey: new PublicKey(otherAccount.pub),\n        lamports: 1000000,\n      });\n\n      const txBuilder = factory.getCustomInstructionBuilder();\n      txBuilder.sender(authAccount.pub);\n      txBuilder.addCustomInstruction(convertInstructionToParams(transferInstruction));\n\n      await txBuilder.build().should.be.rejectedWith('Invalid transaction: missing nonce blockhash');\n    });\n  });\n\n  describe('SolVersionedInstruction Support', () => {\n    it('should accept and validate SolVersionedInstruction format', () => {\n      const compiledInstruction: SolVersionedInstruction = {\n        programIdIndex: 1,\n        accountKeyIndexes: [0, 2, 3],\n        data: '3Bxs43ZMjSRQLs6o', // base58 encoded instruction data\n      };\n\n      const txBuilder = customInstructionBuilder();\n      should(() => txBuilder.addCustomInstruction(compiledInstruction)).not.throwError();\n\n      txBuilder.getInstructions().should.have.length(1);\n      const addedInstruction = txBuilder.getInstructions()[0];\n      addedInstruction.params.should.deepEqual(compiledInstruction);\n    });\n\n    it('should validate versioned instruction format', () => {\n      const txBuilder = customInstructionBuilder();\n\n      // Invalid programIdIndex\n      should(() =>\n        txBuilder.addCustomInstruction({\n          programIdIndex: -1,\n          accountKeyIndexes: [0],\n          data: '1', // base58 for 0x00\n        } as SolVersionedInstruction)\n      ).throwError('Versioned instruction must have a valid programIdIndex number');\n\n      // Invalid accountKeyIndexes\n      should(() =>\n        txBuilder.addCustomInstruction({\n          programIdIndex: 0,\n          accountKeyIndexes: [-1],\n          data: '1', // base58 for 0x00\n        } as SolVersionedInstruction)\n      ).throwError('Each accountKeyIndex must be a non-negative number');\n\n      // Missing data\n      should(() =>\n        txBuilder.addCustomInstruction({\n          programIdIndex: 0,\n          accountKeyIndexes: [0],\n        } as SolVersionedInstruction)\n      ).throwError('Versioned instruction must have valid data string');\n    });\n\n    it('should handle mixed SolInstruction and SolVersionedInstruction', () => {\n      const traditionalInstruction = convertInstructionToParams(\n        SystemProgram.transfer({\n          fromPubkey: new PublicKey(authAccount.pub),\n          toPubkey: new PublicKey(otherAccount.pub),\n          lamports: 1000000,\n        })\n      );\n\n      const compiledInstruction: SolVersionedInstruction = {\n        programIdIndex: 1,\n        accountKeyIndexes: [0, 2],\n        data: '4HSo5YVBrgChTZX5',\n      };\n\n      const txBuilder = customInstructionBuilder();\n      txBuilder.addCustomInstruction(traditionalInstruction);\n      txBuilder.addCustomInstruction(compiledInstruction);\n\n      txBuilder.getInstructions().should.have.length(2);\n    });\n  });\n\n  describe('fromVersionedTransactionData', () => {\n    it('should process VersionedTransactionData and extract instructions', () => {\n      const txBuilder = customInstructionBuilder();\n      const versionedTxData = extractVersionedTransactionData(testData.JUPITER_VERSIONED_TX_BYTES);\n\n      // Should parse without throwing errors\n      should(() => txBuilder.fromVersionedTransactionData(versionedTxData)).not.throwError();\n\n      // Should have extracted instructions\n      const instructions = txBuilder.getInstructions();\n      instructions.length.should.be.greaterThan(0);\n\n      for (const instruction of instructions) {\n        instruction.type.should.equal('VersionedCustomInstruction');\n        instruction.params.should.have.property('programIdIndex');\n        instruction.params.should.have.property('accountKeyIndexes');\n        instruction.params.should.have.property('data');\n      }\n    });\n\n    it('should store VersionedTransactionData in underlying transaction', async () => {\n      const txBuilder = customInstructionBuilder();\n      const versionedTxData = extractVersionedTransactionData(testData.JUPITER_VERSIONED_TX_BYTES);\n\n      txBuilder.fromVersionedTransactionData(versionedTxData);\n\n      const tx = txBuilder['_transaction'];\n      const storedData = tx.getVersionedTransactionData();\n      should.exist(storedData);\n      storedData!.versionedInstructions.length.should.equal(versionedTxData.versionedInstructions.length);\n      storedData!.addressLookupTables.length.should.equal(versionedTxData.addressLookupTables.length);\n      storedData!.staticAccountKeys.length.should.equal(versionedTxData.staticAccountKeys.length);\n    });\n\n    it('should validate input data', () => {\n      const txBuilder = customInstructionBuilder();\n\n      // Invalid: null/undefined\n      should(() => txBuilder.fromVersionedTransactionData(null as any)).throwError(/must be a valid object/);\n      should(() => txBuilder.fromVersionedTransactionData(undefined as any)).throwError(/must be a valid object/);\n\n      // Invalid: empty instructions\n      should(() =>\n        txBuilder.fromVersionedTransactionData({\n          versionedInstructions: [],\n          addressLookupTables: [],\n          staticAccountKeys: ['test'],\n          messageHeader: { numRequiredSignatures: 1, numReadonlySignedAccounts: 0, numReadonlyUnsignedAccounts: 0 },\n        })\n      ).throwError(/non-empty array/);\n\n      // Invalid: missing addressLookupTables\n      should(() =>\n        txBuilder.fromVersionedTransactionData({\n          versionedInstructions: [{ programIdIndex: 0, accountKeyIndexes: [0], data: '1' }], // base58 for 0x00\n          staticAccountKeys: ['test'],\n        } as any)\n      ).throwError(/must be an array/);\n\n      // Invalid: empty staticAccountKeys\n      should(() =>\n        txBuilder.fromVersionedTransactionData({\n          versionedInstructions: [{ programIdIndex: 0, accountKeyIndexes: [0], data: '1' }], // base58 for 0x00\n          addressLookupTables: [],\n          staticAccountKeys: [],\n          messageHeader: { numRequiredSignatures: 1, numReadonlySignedAccounts: 0, numReadonlyUnsignedAccounts: 0 },\n        })\n      ).throwError(/non-empty array/);\n    });\n\n    it('should work with the complete transaction building flow', async () => {\n      const txBuilder = customInstructionBuilder();\n      const versionedTxData = extractVersionedTransactionData(testData.JUPITER_VERSIONED_TX_BYTES);\n\n      // Process the VersionedTransactionData\n      txBuilder.fromVersionedTransactionData(versionedTxData);\n\n      txBuilder.sender(versionedTxData.staticAccountKeys[0]); // Fee payer\n      txBuilder.nonce(testData.blockHashes.validBlockHashes[0]);\n\n      const tx = await txBuilder.build();\n\n      // Verify transaction properties\n      tx.should.be.ok();\n      tx.type.should.equal(31); // TransactionType.CustomTx enum value\n\n      // Verify signable payload\n      const payload = tx.signablePayload;\n      payload.should.be.instanceOf(Buffer);\n      payload.length.should.be.greaterThan(0);\n\n      // Verify payload is deterministic - rebuilding with same params produces same payload\n      const txBuilder2 = customInstructionBuilder();\n      txBuilder2.fromVersionedTransactionData(versionedTxData);\n      txBuilder2.sender(versionedTxData.staticAccountKeys[0]);\n      txBuilder2.nonce(testData.blockHashes.validBlockHashes[0]);\n      const tx2 = await txBuilder2.build();\n      should.equal(tx2.signablePayload.toString('hex'), payload.toString('hex'));\n    });\n\n    it('should extract the correct number of instructions from Jupiter transaction', () => {\n      const txBuilder = customInstructionBuilder();\n      const versionedTxData = extractVersionedTransactionData(testData.JUPITER_VERSIONED_TX_BYTES);\n\n      txBuilder.fromVersionedTransactionData(versionedTxData);\n\n      const instructions = txBuilder.getInstructions();\n\n      // Verify we extracted instructions\n      instructions.length.should.be.greaterThan(0);\n      instructions.length.should.equal(versionedTxData.versionedInstructions.length);\n\n      // Verify each instruction has valid compiled format\n      for (const instruction of instructions) {\n        const params = instruction.params as SolVersionedInstruction;\n        (typeof params.programIdIndex).should.equal('number');\n        params.programIdIndex.should.be.greaterThanOrEqual(0);\n        Array.isArray(params.accountKeyIndexes).should.equal(true);\n        (typeof params.data).should.equal('string');\n        // Data should be valid base58 string (non-empty)\n        params.data.length.should.be.greaterThan(0);\n        // Verify it can be decoded\n        should.doesNotThrow(() => base58.decode(params.data));\n      }\n    });\n\n    it('should clear instructions properly after using fromVersionedTransactionData', () => {\n      const txBuilder = customInstructionBuilder();\n      const versionedTxData = extractVersionedTransactionData(testData.JUPITER_VERSIONED_TX_BYTES);\n\n      txBuilder.fromVersionedTransactionData(versionedTxData);\n      txBuilder.getInstructions().length.should.be.greaterThan(0);\n\n      // Clear should work\n      txBuilder.clearInstructions();\n      txBuilder.getInstructions().should.have.length(0);\n    });\n\n    it('should extract fee payer from staticAccountKeys', () => {\n      const txBuilder = factory.getCustomInstructionBuilder();\n      txBuilder.nonce(recentBlockHash);\n\n      const versionedTxData = extractVersionedTransactionData(testData.JUPITER_VERSIONED_TX_BYTES);\n\n      txBuilder.fromVersionedTransactionData(versionedTxData);\n\n      const sender = txBuilder['_sender'];\n      should.exist(sender);\n      sender.should.equal(versionedTxData.staticAccountKeys[0]);\n    });\n\n    it('should not override existing sender', () => {\n      const txBuilder = customInstructionBuilder();\n      const versionedTxData = extractVersionedTransactionData(testData.JUPITER_VERSIONED_TX_BYTES);\n\n      const originalSender = txBuilder['_sender'];\n      txBuilder.fromVersionedTransactionData(versionedTxData);\n\n      const sender = txBuilder['_sender'];\n      sender.should.equal(originalSender);\n      sender.should.equal(authAccount.pub);\n    });\n  });\n\n  describe('durable nonce injection', () => {\n    const SYSTEM_PROGRAM_ID = SystemProgram.programId.toBase58();\n    const SYSVAR_RECENT_BLOCKHASHES_ID = SYSVAR_RECENT_BLOCKHASHES_PUBKEY.toBase58();\n    const walletNonceAddress = testData.nonceAccount.pub;\n    const authWalletAddress = authAccount.pub;\n\n    const seededPublicKey = (seed: number): PublicKey => Keypair.fromSeed(Buffer.alloc(32, seed)).publicKey;\n\n    // Deterministic fixture keys covering all four MessageV0 header sections\n    const fixturePayer = seededPublicKey(11); // writable signer (account 0)\n    const fixtureRoSigner = seededPublicKey(12); // read-only signer\n    const fixtureWritableNonSigner = seededPublicKey(13);\n    const fixtureRoNonSigner = seededPublicKey(14);\n    const fixtureAltWritable = seededPublicKey(15); // loaded from the lookup table\n    const fixtureAltReadonly = seededPublicKey(16); // loaded from the lookup table\n    const fixtureProgram = seededPublicKey(17);\n\n    // The lookup table has filler addresses at indexes 0 and 2 so the\n    // referenced indexes (1 writable, 3 readonly) are non-trivial\n    const lookupTableAccount = new AddressLookupTableAccount({\n      key: seededPublicKey(200),\n      state: {\n        deactivationSlot: BigInt(0),\n        lastExtendedSlot: 0,\n        lastExtendedSlotStartIndex: 0,\n        addresses: [seededPublicKey(90), fixtureAltWritable, seededPublicKey(91), fixtureAltReadonly],\n      },\n    });\n\n    /**\n     * Compile versioned transaction data through web3.js with a lookup table,\n     * mirroring the data callers extract from a real VersionedTransaction.\n     */\n    function buildVersionedFixture(\n      payerKey: PublicKey,\n      instructions: {\n        programId: PublicKey;\n        keys: { pubkey: PublicKey; isSigner: boolean; isWritable: boolean }[];\n      }[]\n    ): { message: MessageV0; data: VersionedTransactionData } {\n      const message = MessageV0.compile({\n        payerKey,\n        recentBlockhash: recentBlockHash,\n        addressLookupTableAccounts: [lookupTableAccount],\n        instructions: instructions.map(\n          (ix) =>\n            new TransactionInstruction({\n              programId: ix.programId,\n              keys: ix.keys,\n              data: Buffer.from([1, 2, 3, 4]),\n            })\n        ),\n      });\n\n      const data: VersionedTransactionData = {\n        versionedInstructions: message.compiledInstructions.map((ci) => ({\n          programIdIndex: ci.programIdIndex,\n          accountKeyIndexes: [...ci.accountKeyIndexes],\n          data: base58.encode(ci.data),\n        })),\n        addressLookupTables: message.addressTableLookups.map((alt) => ({\n          accountKey: alt.accountKey.toBase58(),\n          writableIndexes: [...alt.writableIndexes],\n          readonlyIndexes: [...alt.readonlyIndexes],\n        })),\n        staticAccountKeys: message.staticAccountKeys.map((key) => key.toBase58()),\n        messageHeader: {\n          numRequiredSignatures: message.header.numRequiredSignatures,\n          numReadonlySignedAccounts: message.header.numReadonlySignedAccounts,\n          numReadonlyUnsignedAccounts: message.header.numReadonlyUnsignedAccounts,\n        },\n        recentBlockhash: recentBlockHash,\n      };\n\n      return { message, data };\n    }\n\n    /** Compile processed VersionedTransactionData back into a MessageV0 */\n    function compileProcessedMessage(data: VersionedTransactionData): MessageV0 {\n      return new MessageV0({\n        header: { ...data.messageHeader },\n        staticAccountKeys: data.staticAccountKeys.map((key) => new PublicKey(key)),\n        recentBlockhash: data.recentBlockhash ?? recentBlockHash,\n        compiledInstructions: data.versionedInstructions.map((instruction) => ({\n          programIdIndex: instruction.programIdIndex,\n          accountKeyIndexes: [...instruction.accountKeyIndexes],\n          data: Buffer.from(base58.decode(instruction.data)),\n        })),\n        addressTableLookups: data.addressLookupTables.map((alt) => ({\n          accountKey: new PublicKey(alt.accountKey),\n          writableIndexes: [...alt.writableIndexes],\n          readonlyIndexes: [...alt.readonlyIndexes],\n        })),\n      });\n    }\n\n    /** Inject the durable nonce advance instruction and return the processed data */\n    function injectNonceAdvance(data: VersionedTransactionData): VersionedTransactionData {\n      const txBuilder = factory.getCustomInstructionBuilder();\n      txBuilder.nonce(recentBlockHash, { walletNonceAddress, authWalletAddress });\n      txBuilder.fromVersionedTransactionData(data);\n      const processed = txBuilder['_transaction'].getVersionedTransactionData();\n      should.exist(processed);\n      return processed!;\n    }\n\n    /** Fixture using every header section and both lookup-table slots */\n    const mainFixture = () =>\n      buildVersionedFixture(fixturePayer, [\n        {\n          programId: fixtureProgram,\n          keys: [\n            { pubkey: fixturePayer, isSigner: true, isWritable: true },\n            { pubkey: fixtureRoSigner, isSigner: true, isWritable: false },\n            { pubkey: fixtureAltWritable, isSigner: false, isWritable: true },\n            { pubkey: fixtureAltReadonly, isSigner: false, isWritable: false },\n            { pubkey: fixtureWritableNonSigner, isSigner: false, isWritable: true },\n            { pubkey: fixtureRoNonSigner, isSigner: false, isWritable: false },\n          ],\n        },\n      ]);\n\n    it('keeps lookup-table-referencing instructions pointing at the same accounts', () => {\n      const { message, data } = mainFixture();\n      const processed = injectNonceAdvance(data);\n\n      // The fixture must actually reference accounts loaded from the lookup table\n      Math.max(\n        ...data.versionedInstructions.flatMap((ix) => [...ix.accountKeyIndexes, ix.programIdIndex])\n      ).should.be.greaterThanOrEqual(data.staticAccountKeys.length);\n\n      const before = message.getAccountKeys({ addressLookupTableAccounts: [lookupTableAccount] });\n      const after = compileProcessedMessage(processed).getAccountKeys({\n        addressLookupTableAccounts: [lookupTableAccount],\n      });\n\n      processed.versionedInstructions.should.have.length(data.versionedInstructions.length + 1);\n      const remappedInstructions = processed.versionedInstructions.slice(1);\n      remappedInstructions.forEach((instruction, ixIndex) => {\n        const original = data.versionedInstructions[ixIndex];\n        before.get(original.programIdIndex)!.toBase58().should.equal(after.get(instruction.programIdIndex)!.toBase58());\n        instruction.accountKeyIndexes.should.have.length(original.accountKeyIndexes.length);\n        original.accountKeyIndexes.forEach((_, k) => {\n          before\n            .get(original.accountKeyIndexes[k])!\n            .toBase58()\n            .should.equal(after.get(instruction.accountKeyIndexes[k])!.toBase58());\n        });\n        instruction.data.should.equal(original.data);\n      });\n    });\n\n    it('keeps Jupiter lookup-table accounts pointing at the same accounts', () => {\n      const data = extractVersionedTransactionData(testData.JUPITER_VERSIONED_TX_BYTES);\n      const processed = injectNonceAdvance(data);\n\n      // authority, nonce account and sysvar are added; the system program is already present\n      const shift = processed.staticAccountKeys.length - data.staticAccountKeys.length;\n      shift.should.equal(3);\n      processed.messageHeader.should.deepEqual({\n        numRequiredSignatures: 2,\n        numReadonlySignedAccounts: 1,\n        numReadonlyUnsignedAccounts: 6,\n      });\n\n      const oldStaticLen = data.staticAccountKeys.length;\n      const remappedInstructions = processed.versionedInstructions.slice(1);\n      remappedInstructions.forEach((instruction, ixIndex) => {\n        const original = data.versionedInstructions[ixIndex];\n        const remappedProgramIndex = instruction.programIdIndex;\n        if (original.programIdIndex < oldStaticLen) {\n          processed.staticAccountKeys[remappedProgramIndex].should.equal(\n            data.staticAccountKeys[original.programIdIndex]\n          );\n        } else {\n          remappedProgramIndex.should.equal(original.programIdIndex + shift);\n        }\n        original.accountKeyIndexes.forEach((oldIndex, k) => {\n          const newIndex = instruction.accountKeyIndexes[k];\n          if (oldIndex < oldStaticLen) {\n            processed.staticAccountKeys[newIndex].should.equal(data.staticAccountKeys[oldIndex]);\n          } else {\n            newIndex.should.equal(oldIndex + shift);\n          }\n        });\n      });\n    });\n\n    it('makes the nonce account writable and keeps original read-only accounts read-only', () => {\n      const { data } = mainFixture();\n      const processed = injectNonceAdvance(data);\n      const message = compileProcessedMessage(processed);\n\n      // header adjusted for the new authority, nonce account, sysvar and system program\n      processed.messageHeader.should.deepEqual({\n        numRequiredSignatures: 3, // payer + ro signer + new authority\n        numReadonlySignedAccounts: 2, // ro signer + new authority\n        numReadonlyUnsignedAccounts: 4, // ro non-signer, program, system program, sysvar\n      });\n\n      const indexOf = (key: string) => processed.staticAccountKeys.indexOf(key);\n\n      // AdvanceNonceAccount requires a writable nonce account\n      message.isAccountWritable(indexOf(walletNonceAddress)).should.equal(true);\n      // original accounts keep their writability\n      message.isAccountWritable(indexOf(fixturePayer.toBase58())).should.equal(true);\n      message.isAccountWritable(indexOf(fixtureWritableNonSigner.toBase58())).should.equal(true);\n      message.isAccountWritable(indexOf(fixtureRoSigner.toBase58())).should.equal(false);\n      message.isAccountWritable(indexOf(fixtureRoNonSigner.toBase58())).should.equal(false);\n      message.isAccountWritable(indexOf(fixtureProgram.toBase58())).should.equal(false);\n      // the new authority is a read-only signer\n      message.isAccountSigner(indexOf(authWalletAddress)).should.equal(true);\n      message.isAccountWritable(indexOf(authWalletAddress)).should.equal(false);\n      // no duplicate keys\n      new Set(processed.staticAccountKeys).size.should.equal(processed.staticAccountKeys.length);\n    });\n\n    it('prepends a well-formed AdvanceNonceAccount instruction', () => {\n      const { data } = mainFixture();\n      const processed = injectNonceAdvance(data);\n\n      const [nonceAdvance] = processed.versionedInstructions;\n      should.exist(nonceAdvance);\n      nonceAdvance.data.should.equal('6vx8P'); // SystemProgram AdvanceNonceAccount\n      nonceAdvance.programIdIndex.should.equal(processed.staticAccountKeys.indexOf(SYSTEM_PROGRAM_ID));\n      nonceAdvance.accountKeyIndexes.should.deepEqual([\n        processed.staticAccountKeys.indexOf(walletNonceAddress),\n        processed.staticAccountKeys.indexOf(SYSVAR_RECENT_BLOCKHASHES_ID),\n        processed.staticAccountKeys.indexOf(authWalletAddress),\n      ]);\n    });\n\n    it('turns an authority already present as a writable non-signer into a writable signer, once', () => {\n      const { data } = buildVersionedFixture(fixturePayer, [\n        {\n          programId: fixtureProgram,\n          keys: [\n            { pubkey: fixturePayer, isSigner: true, isWritable: true },\n            // authority already present as a writable non-signer\n            { pubkey: new PublicKey(authWalletAddress), isSigner: false, isWritable: true },\n            { pubkey: fixtureRoNonSigner, isSigner: false, isWritable: false },\n          ],\n        },\n      ]);\n      const processed = injectNonceAdvance(data);\n      const message = compileProcessedMessage(processed);\n\n      // appears once, as a signer, keeping its writability\n      processed.staticAccountKeys.filter((key) => key === authWalletAddress).should.have.length(1);\n      const authIndex = processed.staticAccountKeys.indexOf(authWalletAddress);\n      message.isAccountSigner(authIndex).should.equal(true);\n      message.isAccountWritable(authIndex).should.equal(true);\n\n      processed.messageHeader.numRequiredSignatures.should.equal(data.messageHeader.numRequiredSignatures + 1);\n      processed.messageHeader.numReadonlySignedAccounts.should.equal(data.messageHeader.numReadonlySignedAccounts);\n    });\n\n    it('turns an authority already present as a read-only non-signer into a read-only signer, once', () => {\n      const { data } = buildVersionedFixture(fixturePayer, [\n        {\n          programId: fixtureProgram,\n          keys: [\n            { pubkey: fixturePayer, isSigner: true, isWritable: true },\n            // authority already present as a read-only non-signer\n            { pubkey: new PublicKey(authWalletAddress), isSigner: false, isWritable: false },\n            { pubkey: fixtureWritableNonSigner, isSigner: false, isWritable: true },\n          ],\n        },\n      ]);\n      const processed = injectNonceAdvance(data);\n      const message = compileProcessedMessage(processed);\n\n      // appears once, as a read-only signer\n      processed.staticAccountKeys.filter((key) => key === authWalletAddress).should.have.length(1);\n      const authIndex = processed.staticAccountKeys.indexOf(authWalletAddress);\n      message.isAccountSigner(authIndex).should.equal(true);\n      message.isAccountWritable(authIndex).should.equal(false);\n\n      processed.messageHeader.numRequiredSignatures.should.equal(data.messageHeader.numRequiredSignatures + 1);\n      processed.messageHeader.numReadonlySignedAccounts.should.equal(data.messageHeader.numReadonlySignedAccounts + 1);\n      // it left the read-only non-signers (system program + sysvar are added)\n      processed.messageHeader.numReadonlyUnsignedAccounts.should.equal(\n        data.messageHeader.numReadonlyUnsignedAccounts + 1\n      );\n    });\n\n    it('does not add a signer when the nonce authority is already the fee payer', () => {\n      const { data } = buildVersionedFixture(new PublicKey(authWalletAddress), [\n        {\n          programId: fixtureProgram,\n          keys: [\n            { pubkey: new PublicKey(authWalletAddress), isSigner: true, isWritable: true },\n            { pubkey: fixtureWritableNonSigner, isSigner: false, isWritable: true },\n          ],\n        },\n      ]);\n      const processed = injectNonceAdvance(data);\n      const message = compileProcessedMessage(processed);\n\n      processed.staticAccountKeys[0].should.equal(authWalletAddress);\n      processed.staticAccountKeys.filter((key) => key === authWalletAddress).should.have.length(1);\n      processed.messageHeader.numRequiredSignatures.should.equal(data.messageHeader.numRequiredSignatures);\n      processed.messageHeader.numReadonlySignedAccounts.should.equal(data.messageHeader.numReadonlySignedAccounts);\n      message.isAccountSigner(0).should.equal(true);\n    });\n\n    it('moves a nonce account already present as read-only into the writable non-signers', () => {\n      const { data } = buildVersionedFixture(fixturePayer, [\n        {\n          programId: fixtureProgram,\n          keys: [\n            { pubkey: fixturePayer, isSigner: true, isWritable: true },\n            { pubkey: fixtureRoNonSigner, isSigner: false, isWritable: false },\n            // nonce account already present as a read-only non-signer\n            { pubkey: new PublicKey(walletNonceAddress), isSigner: false, isWritable: false },\n          ],\n        },\n      ]);\n      const processed = injectNonceAdvance(data);\n      const message = compileProcessedMessage(processed);\n\n      processed.staticAccountKeys.filter((key) => key === walletNonceAddress).should.have.length(1);\n      const nonceIndex = processed.staticAccountKeys.indexOf(walletNonceAddress);\n      message.isAccountWritable(nonceIndex).should.equal(true);\n      message.isAccountSigner(nonceIndex).should.equal(false);\n      // the other original read-only account stays read-only\n      message.isAccountWritable(processed.staticAccountKeys.indexOf(fixtureRoNonSigner.toBase58())).should.equal(false);\n    });\n\n    it('produces a signable payload that deserializes as a MessageV0 with the nonce advance first', async () => {\n      const { data } = mainFixture();\n      const txBuilder = factory.getCustomInstructionBuilder();\n      txBuilder.nonce(recentBlockHash, { walletNonceAddress, authWalletAddress });\n      txBuilder.fromVersionedTransactionData(data);\n\n      const tx = await txBuilder.build();\n      const message = MessageV0.deserialize(tx.signablePayload);\n\n      message.compiledInstructions.should.have.length(data.versionedInstructions.length + 1);\n      const nonceAdvance = message.compiledInstructions[0];\n      message.staticAccountKeys[nonceAdvance.programIdIndex].toBase58().should.equal(SYSTEM_PROGRAM_ID);\n      message.staticAccountKeys[nonceAdvance.accountKeyIndexes[0]].toBase58().should.equal(walletNonceAddress);\n      message.staticAccountKeys[nonceAdvance.accountKeyIndexes[1]]\n        .toBase58()\n        .should.equal(SYSVAR_RECENT_BLOCKHASHES_ID);\n      message.staticAccountKeys[nonceAdvance.accountKeyIndexes[2]].toBase58().should.equal(authWalletAddress);\n    });\n\n    it('rejects versioned data whose message header is inconsistent', () => {\n      const { data } = mainFixture();\n      const inconsistent = {\n        ...data,\n        messageHeader: { ...data.messageHeader, numReadonlyUnsignedAccounts: 99 },\n      };\n      const txBuilder = factory.getCustomInstructionBuilder();\n      txBuilder.nonce(recentBlockHash, { walletNonceAddress, authWalletAddress });\n      should(() => txBuilder.fromVersionedTransactionData(inconsistent)).throwError(/Invalid message header/);\n    });\n  });\n});\n"]}