@bitgo-beta/sdk-coin-sol 2.4.3-beta.999 → 7.6.3

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

@@ -0,0 +1,413 @@
+"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 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', () => {
+        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,
+                },
+            };
+        }
+        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);
+        });
+    });
+});
+//# 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} 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 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 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    function extractVersionedTransactionData(base64Bytes: string) {\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    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"]}

package/dist/test/unit/transactionBuilder/stakingActivateBuilder.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=stakingActivateBuilder.d.ts.map

package/dist/test/unit/transactionBuilder/stakingActivateBuilder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stakingActivateBuilder.d.ts","sourceRoot":"","sources":["../../../../test/unit/transactionBuilder/stakingActivateBuilder.ts"],"names":[],"mappings":""}