@bitgo-beta/sdk-coin-sol 2.4.3-beta.127 → 2.4.3-beta.1271

package/dist/test/unit/versionedTransaction.js

@@ -0,0 +1,205 @@
+"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 src_1 = require("../../src");
+const testData = __importStar(require("../resources/sol"));
+const getBuilderFactory_1 = require("./getBuilderFactory");
+const bs58_1 = __importDefault(require("bs58"));
+const { VersionedTransaction } = require('@solana/web3.js');
+describe('Sol Jupiter Swap Transaction', () => {
+    const walletKeyPair = new src_1.KeyPair(testData.authAccount);
+    const wallet = walletKeyPair.getKeys();
+    it('should preserve instructions and ALTs when building and signing', async function () {
+        // Jupiter Swap Transaction (Versioned)
+        const versionedTransaction = 'AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAQAFDTWoM5DBCGn7cn5aV56fomo6mhD2K1c5XYhQIan41E6dG9t06ox6DMdvVuBnSEATyN/8qIq246iO5aDm1jm82x4wM40FR8Q7xSZUpUtB0lbvelaZ46oRQ2GM9hWGMukHG1EUsA1R9ZO55ClUvNMyw8IQOrfRmu3ONG50oNeluT4LgaOacN+I4d0HStcu+oh0no4XXgVUwjzk5+egiUaQDkCCjXAlSDAb46ahLAfWeKOqzO/HC/z2WgRk8RS1yc6heMZzBbR3SPDwrNvWlCZGaETaixiH9ufdOJ823Gv+MnxH1SOu6TCsX1+TMskj94D3NElDpado8okFQbUuzaijU9oAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIyXJY9OJInxuz0QKRSODYMLWhOZ2v8QhASOe9jb6fhZAwZGb+UhFzL/7K26csOb57yM5bvF9xJrLEObOkAAAAAEedVb8jHAbu50xW7OaBUH/bGy3qP0jlECsc2iVrwTjwbd9uHXZaGT2cvhRs7reawctIXtX1s3kTqM9YV+/wCp+mGpF4I4ZrV12bapJ7p61Babt3ty7HYDUKtMso38OYgHCgAFAooyBAAKAAkDoQ4BAAAAAAAIAgAFDAIAAAAwKyIAAAAAAAsFBQAgDAgJk/F7ZPSErnb/CQYABwAdCAwBAQs/HgAFDg0HIB0MDBwLJg8mEBIODSAdESYeDAwkJgIDBgsmGyYWGQ4EICUaJh4MDCQmGBcBCyIjDCEeBA0VExQfMtGYU5N8/tjpC0ANAwAAAAAAWqwAAAAAAAAyAAAAAAADAAAAJiwaAAMm5AwAAgoQJwIDDAMFAAABCQQpv5UHKk+/BN9xdZPnOLzMIScoFcJHGoDZ+fVVsNSEJQI0IwUAKA4CFyo9SDjsPdfWXAdMF0mu2+xZbw9rbR6rzNAEeFkLmyKwBGBmYWUAMHCJ6Oi0A1Qjpjp1Yv3xP+sPLm2qJ//TKZd5Z9KzjvEDwb3CA77DwOtKd1MCu6h4XJjC42yc8TcL92nhzFUR6HLW3XrAIZOvBo6Ki5CRjQOMk5Q=';
+        const originalDeserialized = VersionedTransaction.deserialize(Buffer.from(versionedTransaction, 'base64'));
+        const versionedInstructions = originalDeserialized.message.compiledInstructions.map((ix) => ({
+            programIdIndex: ix.programIdIndex,
+            accountKeyIndexes: ix.accountKeyIndexes,
+            data: bs58_1.default.encode(ix.data),
+        }));
+        const addressLookupTables = originalDeserialized.message.addressTableLookups?.map((lookup) => ({
+            accountKey: lookup.accountKey.toBase58(),
+            writableIndexes: lookup.writableIndexes,
+            readonlyIndexes: lookup.readonlyIndexes,
+        })) || [];
+        const staticAccountKeys = originalDeserialized.message.staticAccountKeys.map((key) => key.toBase58());
+        staticAccountKeys[0] = testData.authAccount.pub; // Replace fee payer with our test account
+        const versionedTransactionData = {
+            versionedInstructions,
+            addressLookupTables,
+            staticAccountKeys,
+            messageHeader: originalDeserialized.message.header,
+        };
+        const factory = (0, getBuilderFactory_1.getBuilderFactory)('tsol');
+        const txBuilder = factory.getCustomInstructionBuilder();
+        // Build transaction from versioned transaction data
+        txBuilder.fromVersionedTransactionData(versionedTransactionData);
+        txBuilder.nonce(testData.blockHashes.validBlockHashes[0]);
+        // Build unsigned transaction
+        const txUnsigned = (await txBuilder.build());
+        should_1.default.exist(txUnsigned);
+        txUnsigned.isVersionedTransaction().should.be.true();
+        should_1.default.exist(txUnsigned.toBroadcastFormat());
+        // Sign the transaction
+        txBuilder.sign({ key: wallet.prv });
+        const tx = (await txBuilder.build());
+        const rawTx = tx.toBroadcastFormat();
+        tx.isVersionedTransaction().should.be.true();
+        should_1.default.exist(rawTx);
+        const txBuilder2 = factory.getCustomInstructionBuilder();
+        txBuilder2.fromVersionedTransactionData(versionedTransactionData);
+        txBuilder2.nonce(testData.blockHashes.validBlockHashes[0]);
+        const tx2 = await txBuilder2.build();
+        should_1.default.equal(tx2.signablePayload.toString('hex'), txUnsigned.signablePayload.toString('hex'));
+        should_1.default.equal(tx2.type, txUnsigned.type);
+        // Verify we can add signature manually
+        const signed = tx.signature[0];
+        const txBuilder3 = factory.getCustomInstructionBuilder();
+        txBuilder3.fromVersionedTransactionData(versionedTransactionData);
+        txBuilder3.nonce(testData.blockHashes.validBlockHashes[0]);
+        await txBuilder3.addSignature({ pub: wallet.pub }, Buffer.from(bs58_1.default.decode(signed)));
+        const signedTx = await txBuilder3.build();
+        should_1.default.equal(signedTx.type, tx.type);
+        const rawSignedTx = signedTx.toBroadcastFormat();
+        should_1.default.equal(rawSignedTx, rawTx);
+        const signedDeserialized = VersionedTransaction.deserialize(Buffer.from(rawTx, 'base64'));
+        // Verify all instructions are preserved
+        const origInstructions = originalDeserialized.message.compiledInstructions;
+        const signedInstructions = signedDeserialized.message.compiledInstructions;
+        should_1.default.equal(origInstructions.length, signedInstructions.length, 'Number of instructions should match');
+        for (let i = 0; i < origInstructions.length; i++) {
+            should_1.default.equal(origInstructions[i].programIdIndex, signedInstructions[i].programIdIndex, `Instruction ${i}: programIdIndex should match`);
+            should_1.default.deepEqual(origInstructions[i].accountKeyIndexes, signedInstructions[i].accountKeyIndexes, `Instruction ${i}: accountKeyIndexes should match`);
+            should_1.default.equal(Buffer.from(origInstructions[i].data).toString('hex'), Buffer.from(signedInstructions[i].data).toString('hex'), `Instruction ${i}: data should match`);
+        }
+        // Verify all ALTs are preserved
+        const origALTs = originalDeserialized.message.addressTableLookups || [];
+        const signedALTs = signedDeserialized.message.addressTableLookups || [];
+        should_1.default.equal(origALTs.length, signedALTs.length, 'Number of ALTs should match');
+        for (let i = 0; i < origALTs.length; i++) {
+            should_1.default.equal(origALTs[i].accountKey.toBase58(), signedALTs[i].accountKey.toBase58(), `ALT ${i}: accountKey should match`);
+            should_1.default.deepEqual(origALTs[i].writableIndexes, signedALTs[i].writableIndexes, `ALT ${i}: writableIndexes should match`);
+            should_1.default.deepEqual(origALTs[i].readonlyIndexes, signedALTs[i].readonlyIndexes, `ALT ${i}: readonlyIndexes should match`);
+        }
+    });
+    it('should automatically inject nonce advance instruction when using durable nonce with versioned transactions', async function () {
+        // Simple transaction with one memo instruction
+        const versionedTransactionData = {
+            versionedInstructions: [
+                {
+                    programIdIndex: 1,
+                    accountKeyIndexes: [0],
+                    data: bs58_1.default.encode(Buffer.from('Hello Versioned Tx', 'utf-8')),
+                },
+            ],
+            addressLookupTables: [],
+            staticAccountKeys: [testData.authAccount.pub, 'MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr'],
+            messageHeader: {
+                numRequiredSignatures: 1,
+                numReadonlySignedAccounts: 0,
+                numReadonlyUnsignedAccounts: 0,
+            },
+        };
+        const durableNonceParams = {
+            walletNonceAddress: 'GHtXQBsoZHVnNFa9YevAzxNzQBz7CV5hj6bSe3u52W9n',
+            authWalletAddress: '8Y7RM6JfcX4ASSNBkrkrmScq3Z9UWV4CJBwtfSNgqTN2',
+        };
+        const factory = (0, getBuilderFactory_1.getBuilderFactory)('tsol');
+        const txBuilder = factory.getCustomInstructionBuilder();
+        // Providing durableNonceParams triggers automatic nonce advance injection
+        txBuilder.nonce(testData.blockHashes.validBlockHashes[0], durableNonceParams);
+        txBuilder.fromVersionedTransactionData(versionedTransactionData);
+        const tx = (await txBuilder.build());
+        const builtData = tx.getVersionedTransactionData();
+        should_1.default.exist(builtData);
+        // Nonce advance instruction should be prepended
+        builtData.versionedInstructions.length.should.equal(2);
+        const nonceInstruction = builtData.versionedInstructions[0];
+        nonceInstruction.accountKeyIndexes.length.should.equal(3);
+        // numRequiredSignatures should be updated to include nonce authority
+        const numSigners = builtData.messageHeader.numRequiredSignatures;
+        numSigners.should.equal(2);
+        // Both fee payer and nonce authority should be in signer section
+        const signerKeys = builtData.staticAccountKeys.slice(0, numSigners);
+        signerKeys.should.containEql(testData.authAccount.pub);
+        signerKeys.should.containEql(durableNonceParams.authWalletAddress);
+        // Fee payer must remain at index 0
+        builtData.staticAccountKeys[0].should.equal(testData.authAccount.pub);
+        // Required accounts for nonce advance should be added
+        builtData.staticAccountKeys.should.containEql(durableNonceParams.walletNonceAddress);
+        builtData.staticAccountKeys.should.containEql('11111111111111111111111111111111');
+        builtData.staticAccountKeys.should.containEql('SysvarRecentB1ockHashes11111111111111111111');
+        // Original instruction indices should be remapped after account reordering
+        const originalInstruction = builtData.versionedInstructions[1];
+        originalInstruction.programIdIndex.should.equal(builtData.staticAccountKeys.indexOf('MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr'));
+        originalInstruction.accountKeyIndexes[0].should.equal(builtData.staticAccountKeys.indexOf(testData.authAccount.pub));
+    });
+    it('should not inject nonce advance when using regular nonce (no durableNonceParams)', async function () {
+        const versionedTransactionData = {
+            versionedInstructions: [
+                {
+                    programIdIndex: 1,
+                    accountKeyIndexes: [0],
+                    data: bs58_1.default.encode(Buffer.from('Hello', 'utf-8')),
+                },
+            ],
+            addressLookupTables: [],
+            staticAccountKeys: [testData.authAccount.pub, 'MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr'],
+            messageHeader: {
+                numRequiredSignatures: 1,
+                numReadonlySignedAccounts: 0,
+                numReadonlyUnsignedAccounts: 0,
+            },
+        };
+        const factory = (0, getBuilderFactory_1.getBuilderFactory)('tsol');
+        const txBuilder = factory.getCustomInstructionBuilder();
+        // Regular nonce without durableNonceParams should not trigger injection
+        txBuilder.nonce(testData.blockHashes.validBlockHashes[0]);
+        txBuilder.fromVersionedTransactionData(versionedTransactionData);
+        const tx = (await txBuilder.build());
+        const builtData = tx.getVersionedTransactionData();
+        should_1.default.exist(builtData);
+        // Transaction should remain unchanged
+        builtData.versionedInstructions.length.should.equal(1);
+        builtData.messageHeader.numRequiredSignatures.should.equal(1);
+        builtData.staticAccountKeys.length.should.equal(2);
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"versionedTransaction.js","sourceRoot":"","sources":["../../../test/unit/versionedTransaction.ts"],"names":[],"mappings":"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","sourcesContent":["import should from 'should';\nimport { KeyPair, Transaction } from '../../src';\nimport * as testData from '../resources/sol';\nimport { getBuilderFactory } from './getBuilderFactory';\nimport base58 from 'bs58';\nconst { VersionedTransaction } = require('@solana/web3.js');\n\ndescribe('Sol Jupiter Swap Transaction', () => {\n  const walletKeyPair = new KeyPair(testData.authAccount);\n  const wallet = walletKeyPair.getKeys();\n\n  it('should preserve instructions and ALTs when building and signing', async function () {\n    // Jupiter Swap Transaction (Versioned)\n    const versionedTransaction =\n      'AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAQAFDTWoM5DBCGn7cn5aV56fomo6mhD2K1c5XYhQIan41E6dG9t06ox6DMdvVuBnSEATyN/8qIq246iO5aDm1jm82x4wM40FR8Q7xSZUpUtB0lbvelaZ46oRQ2GM9hWGMukHG1EUsA1R9ZO55ClUvNMyw8IQOrfRmu3ONG50oNeluT4LgaOacN+I4d0HStcu+oh0no4XXgVUwjzk5+egiUaQDkCCjXAlSDAb46ahLAfWeKOqzO/HC/z2WgRk8RS1yc6heMZzBbR3SPDwrNvWlCZGaETaixiH9ufdOJ823Gv+MnxH1SOu6TCsX1+TMskj94D3NElDpado8okFQbUuzaijU9oAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIyXJY9OJInxuz0QKRSODYMLWhOZ2v8QhASOe9jb6fhZAwZGb+UhFzL/7K26csOb57yM5bvF9xJrLEObOkAAAAAEedVb8jHAbu50xW7OaBUH/bGy3qP0jlECsc2iVrwTjwbd9uHXZaGT2cvhRs7reawctIXtX1s3kTqM9YV+/wCp+mGpF4I4ZrV12bapJ7p61Babt3ty7HYDUKtMso38OYgHCgAFAooyBAAKAAkDoQ4BAAAAAAAIAgAFDAIAAAAwKyIAAAAAAAsFBQAgDAgJk/F7ZPSErnb/CQYABwAdCAwBAQs/HgAFDg0HIB0MDBwLJg8mEBIODSAdESYeDAwkJgIDBgsmGyYWGQ4EICUaJh4MDCQmGBcBCyIjDCEeBA0VExQfMtGYU5N8/tjpC0ANAwAAAAAAWqwAAAAAAAAyAAAAAAADAAAAJiwaAAMm5AwAAgoQJwIDDAMFAAABCQQpv5UHKk+/BN9xdZPnOLzMIScoFcJHGoDZ+fVVsNSEJQI0IwUAKA4CFyo9SDjsPdfWXAdMF0mu2+xZbw9rbR6rzNAEeFkLmyKwBGBmYWUAMHCJ6Oi0A1Qjpjp1Yv3xP+sPLm2qJ//TKZd5Z9KzjvEDwb3CA77DwOtKd1MCu6h4XJjC42yc8TcL92nhzFUR6HLW3XrAIZOvBo6Ki5CRjQOMk5Q=';\n\n    const originalDeserialized = VersionedTransaction.deserialize(Buffer.from(versionedTransaction, 'base64'));\n\n    const versionedInstructions = originalDeserialized.message.compiledInstructions.map((ix) => ({\n      programIdIndex: ix.programIdIndex,\n      accountKeyIndexes: ix.accountKeyIndexes,\n      data: base58.encode(ix.data),\n    }));\n\n    const addressLookupTables =\n      originalDeserialized.message.addressTableLookups?.map((lookup) => ({\n        accountKey: lookup.accountKey.toBase58(),\n        writableIndexes: lookup.writableIndexes,\n        readonlyIndexes: lookup.readonlyIndexes,\n      })) || [];\n\n    const staticAccountKeys = originalDeserialized.message.staticAccountKeys.map((key) => key.toBase58());\n    staticAccountKeys[0] = testData.authAccount.pub; // Replace fee payer with our test account\n\n    const versionedTransactionData = {\n      versionedInstructions,\n      addressLookupTables,\n      staticAccountKeys,\n      messageHeader: originalDeserialized.message.header,\n    };\n\n    const factory = getBuilderFactory('tsol');\n    const txBuilder = factory.getCustomInstructionBuilder();\n\n    // Build transaction from versioned transaction data\n    txBuilder.fromVersionedTransactionData(versionedTransactionData);\n    txBuilder.nonce(testData.blockHashes.validBlockHashes[0]);\n\n    // Build unsigned transaction\n    const txUnsigned = (await txBuilder.build()) as Transaction;\n    should.exist(txUnsigned);\n    txUnsigned.isVersionedTransaction().should.be.true();\n    should.exist(txUnsigned.toBroadcastFormat());\n\n    // Sign the transaction\n    txBuilder.sign({ key: wallet.prv });\n    const tx = (await txBuilder.build()) as Transaction;\n    const rawTx = tx.toBroadcastFormat();\n    tx.isVersionedTransaction().should.be.true();\n    should.exist(rawTx);\n\n    const txBuilder2 = factory.getCustomInstructionBuilder();\n    txBuilder2.fromVersionedTransactionData(versionedTransactionData);\n    txBuilder2.nonce(testData.blockHashes.validBlockHashes[0]);\n    const tx2 = await txBuilder2.build();\n\n    should.equal(tx2.signablePayload.toString('hex'), txUnsigned.signablePayload.toString('hex'));\n    should.equal(tx2.type, txUnsigned.type);\n\n    // Verify we can add signature manually\n    const signed = tx.signature[0];\n    const txBuilder3 = factory.getCustomInstructionBuilder();\n    txBuilder3.fromVersionedTransactionData(versionedTransactionData);\n    txBuilder3.nonce(testData.blockHashes.validBlockHashes[0]);\n    await txBuilder3.addSignature({ pub: wallet.pub }, Buffer.from(base58.decode(signed)));\n\n    const signedTx = await txBuilder3.build();\n    should.equal(signedTx.type, tx.type);\n\n    const rawSignedTx = signedTx.toBroadcastFormat();\n    should.equal(rawSignedTx, rawTx);\n\n    const signedDeserialized = VersionedTransaction.deserialize(Buffer.from(rawTx, 'base64'));\n\n    // Verify all instructions are preserved\n    const origInstructions = originalDeserialized.message.compiledInstructions;\n    const signedInstructions = signedDeserialized.message.compiledInstructions;\n    should.equal(origInstructions.length, signedInstructions.length, 'Number of instructions should match');\n\n    for (let i = 0; i < origInstructions.length; i++) {\n      should.equal(\n        origInstructions[i].programIdIndex,\n        signedInstructions[i].programIdIndex,\n        `Instruction ${i}: programIdIndex should match`\n      );\n      should.deepEqual(\n        origInstructions[i].accountKeyIndexes,\n        signedInstructions[i].accountKeyIndexes,\n        `Instruction ${i}: accountKeyIndexes should match`\n      );\n      should.equal(\n        Buffer.from(origInstructions[i].data).toString('hex'),\n        Buffer.from(signedInstructions[i].data).toString('hex'),\n        `Instruction ${i}: data should match`\n      );\n    }\n\n    // Verify all ALTs are preserved\n    const origALTs = originalDeserialized.message.addressTableLookups || [];\n    const signedALTs = signedDeserialized.message.addressTableLookups || [];\n    should.equal(origALTs.length, signedALTs.length, 'Number of ALTs should match');\n\n    for (let i = 0; i < origALTs.length; i++) {\n      should.equal(\n        origALTs[i].accountKey.toBase58(),\n        signedALTs[i].accountKey.toBase58(),\n        `ALT ${i}: accountKey should match`\n      );\n      should.deepEqual(\n        origALTs[i].writableIndexes,\n        signedALTs[i].writableIndexes,\n        `ALT ${i}: writableIndexes should match`\n      );\n      should.deepEqual(\n        origALTs[i].readonlyIndexes,\n        signedALTs[i].readonlyIndexes,\n        `ALT ${i}: readonlyIndexes should match`\n      );\n    }\n  });\n\n  it('should automatically inject nonce advance instruction when using durable nonce with versioned transactions', async function () {\n    // Simple transaction with one memo instruction\n    const versionedTransactionData = {\n      versionedInstructions: [\n        {\n          programIdIndex: 1,\n          accountKeyIndexes: [0],\n          data: base58.encode(Buffer.from('Hello Versioned Tx', 'utf-8')),\n        },\n      ],\n      addressLookupTables: [],\n      staticAccountKeys: [testData.authAccount.pub, 'MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr'],\n      messageHeader: {\n        numRequiredSignatures: 1,\n        numReadonlySignedAccounts: 0,\n        numReadonlyUnsignedAccounts: 0,\n      },\n    };\n\n    const durableNonceParams = {\n      walletNonceAddress: 'GHtXQBsoZHVnNFa9YevAzxNzQBz7CV5hj6bSe3u52W9n',\n      authWalletAddress: '8Y7RM6JfcX4ASSNBkrkrmScq3Z9UWV4CJBwtfSNgqTN2',\n    };\n\n    const factory = getBuilderFactory('tsol');\n    const txBuilder = factory.getCustomInstructionBuilder();\n\n    // Providing durableNonceParams triggers automatic nonce advance injection\n    txBuilder.nonce(testData.blockHashes.validBlockHashes[0], durableNonceParams);\n    txBuilder.fromVersionedTransactionData(versionedTransactionData);\n\n    const tx = (await txBuilder.build()) as Transaction;\n    const builtData = tx.getVersionedTransactionData();\n\n    should.exist(builtData);\n\n    // Nonce advance instruction should be prepended\n    builtData!.versionedInstructions.length.should.equal(2);\n    const nonceInstruction = builtData!.versionedInstructions[0];\n    nonceInstruction.accountKeyIndexes.length.should.equal(3);\n\n    // numRequiredSignatures should be updated to include nonce authority\n    const numSigners = builtData!.messageHeader.numRequiredSignatures;\n    numSigners.should.equal(2);\n\n    // Both fee payer and nonce authority should be in signer section\n    const signerKeys = builtData!.staticAccountKeys.slice(0, numSigners);\n    signerKeys.should.containEql(testData.authAccount.pub);\n    signerKeys.should.containEql(durableNonceParams.authWalletAddress);\n\n    // Fee payer must remain at index 0\n    builtData!.staticAccountKeys[0].should.equal(testData.authAccount.pub);\n\n    // Required accounts for nonce advance should be added\n    builtData!.staticAccountKeys.should.containEql(durableNonceParams.walletNonceAddress);\n    builtData!.staticAccountKeys.should.containEql('11111111111111111111111111111111');\n    builtData!.staticAccountKeys.should.containEql('SysvarRecentB1ockHashes11111111111111111111');\n\n    // Original instruction indices should be remapped after account reordering\n    const originalInstruction = builtData!.versionedInstructions[1];\n    originalInstruction.programIdIndex.should.equal(\n      builtData!.staticAccountKeys.indexOf('MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr')\n    );\n    originalInstruction.accountKeyIndexes[0].should.equal(\n      builtData!.staticAccountKeys.indexOf(testData.authAccount.pub)\n    );\n  });\n\n  it('should not inject nonce advance when using regular nonce (no durableNonceParams)', async function () {\n    const versionedTransactionData = {\n      versionedInstructions: [\n        {\n          programIdIndex: 1,\n          accountKeyIndexes: [0],\n          data: base58.encode(Buffer.from('Hello', 'utf-8')),\n        },\n      ],\n      addressLookupTables: [],\n      staticAccountKeys: [testData.authAccount.pub, 'MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr'],\n      messageHeader: {\n        numRequiredSignatures: 1,\n        numReadonlySignedAccounts: 0,\n        numReadonlyUnsignedAccounts: 0,\n      },\n    };\n\n    const factory = getBuilderFactory('tsol');\n    const txBuilder = factory.getCustomInstructionBuilder();\n\n    // Regular nonce without durableNonceParams should not trigger injection\n    txBuilder.nonce(testData.blockHashes.validBlockHashes[0]);\n    txBuilder.fromVersionedTransactionData(versionedTransactionData);\n\n    const tx = (await txBuilder.build()) as Transaction;\n    const builtData = tx.getVersionedTransactionData();\n\n    should.exist(builtData);\n\n    // Transaction should remain unchanged\n    builtData!.versionedInstructions.length.should.equal(1);\n    builtData!.messageHeader.numRequiredSignatures.should.equal(1);\n    builtData!.staticAccountKeys.length.should.equal(2);\n  });\n});\n"]}