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

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

@@ -0,0 +1,922 @@
+"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 src_1 = require("../../../src");
+const should_1 = __importDefault(require("should"));
+const testData = __importStar(require("../../resources/sol"));
+const getBuilderFactory_1 = require("../getBuilderFactory");
+describe('Solana Confidential Transfer Builder', () => {
+    const factory = (0, getBuilderFactory_1.getBuilderFactory)('sol');
+    const account = new src_1.KeyPair(testData.associatedTokenAccounts.accounts[0]).getKeys();
+    const recentBlockHash = 'GHtXQBsoZHVnNFa9YevAzFr17DJjgHXk3ycTKD5xD3Zi';
+    // Test addresses (Token-2022 mint + ATAs)
+    const mintAddress = testData.associatedTokenAccountsForSol2022.mintId;
+    const tokenAddress = testData.associatedTokenAccountsForSol2022.accounts[0].ata;
+    const destinationTokenAddress = 'ENn8a2tGMS9bR5XV7smGHJvNgzkyxJmnD2eUvQxY5jSP';
+    const authorityAddress = account.pub;
+    // Valid base58 addresses for context state accounts (any valid Solana pubkey)
+    const eqCtxAddress = testData.associatedTokenAccounts.accounts[0].ata;
+    const validityCtxAddress = testData.associatedTokenAccounts.accounts[0].pub;
+    const rangeCtxAddress = testData.nonceAccount.pub;
+    // Hex test data
+    const zeroBytes36 = '00'.repeat(36);
+    const zeroBytes64 = '00'.repeat(64);
+    const proofDataHex = '00'.repeat(320); // typical equality proof size
+    const ctBuilder = () => {
+        const txBuilder = factory.getConfidentialTransferBuilder();
+        txBuilder.nonce(recentBlockHash);
+        txBuilder.sender(account.pub);
+        return txBuilder;
+    };
+    /** Access the raw Solana Transaction from the built tx */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const solTx = (tx) => tx.solTransaction;
+    describe('ConfigureAccount', () => {
+        it('should build a configure account instruction with correct 79-byte layout', async () => {
+            const builder = ctBuilder();
+            builder.configureAccount({
+                tokenAddress,
+                mintAddress,
+                authorityAddress,
+                elgamalPubkey: '11'.repeat(32),
+                decryptableZeroBalance: zeroBytes36,
+                maximumPendingBalanceCreditCounter: '65536',
+                proofInstructionOffset: 1,
+            });
+            const tx = await builder.build();
+            const instructions = tx.toJson().instructionsData;
+            instructions.should.have.length(1);
+            instructions[0].type.should.equal('ConfigureConfidentialTransferAccount');
+            // Verify raw instruction data
+            const rawInstructions = solTx(tx).instructions;
+            rawInstructions.should.have.length(1);
+            const data = rawInstructions[0].data;
+            data.length.should.equal(79);
+            data[0].should.equal(27); // ConfidentialTransferExtension
+            data[1].should.equal(2); // ConfigureAccount
+            data.slice(2, 34).toString('hex').should.equal('11'.repeat(32)); // new_account_elgamal_pubkey
+            data.slice(34, 70).toString('hex').should.equal(zeroBytes36); // decryptable_zero_balance
+            data.readBigUInt64LE(70).toString().should.equal('65536'); // max pending balance credit counter
+            data[78].should.equal(1); // proof_instruction_offset
+            // Verify accounts
+            const keys = rawInstructions[0].keys;
+            keys.should.have.length(4);
+            keys[0].pubkey.toString().should.equal(tokenAddress);
+            keys[0].isWritable.should.be.true();
+            keys[1].pubkey.toString().should.equal(mintAddress);
+            keys[1].isWritable.should.be.false();
+            keys[2].pubkey.toString().should.equal('Sysvar1nstructions1111111111111111111111111'); // instructions sysvar
+            keys[3].pubkey.toString().should.equal(authorityAddress);
+            keys[3].isSigner.should.be.true();
+        });
+        it('should use context state address when provided', async () => {
+            const contextStateAddress = testData.associatedTokenAccounts.accounts[0].pub;
+            const builder = ctBuilder();
+            builder.configureAccount({
+                tokenAddress,
+                mintAddress,
+                authorityAddress,
+                elgamalPubkey: '11'.repeat(32),
+                instructionsSysvarOrContextStateAddress: contextStateAddress,
+                decryptableZeroBalance: zeroBytes36,
+                maximumPendingBalanceCreditCounter: '65536',
+                proofInstructionOffset: 0,
+            });
+            const tx = await builder.build();
+            const keys = solTx(tx).instructions[0].keys;
+            keys[2].pubkey.toString().should.equal(contextStateAddress);
+            const data = solTx(tx).instructions[0].data;
+            data[78].should.equal(0); // proof_instruction_offset = 0 (context state)
+        });
+    });
+    describe('ApplyPendingBalance', () => {
+        it('should build an apply pending balance instruction with correct 46-byte layout', async () => {
+            const builder = ctBuilder();
+            builder.applyPendingBalance({
+                tokenAddress,
+                authorityAddress,
+                expectedPendingBalanceCreditCounter: '3',
+                newDecryptableAvailableBalance: zeroBytes36,
+            });
+            const tx = await builder.build();
+            const instructions = tx.toJson().instructionsData;
+            instructions.should.have.length(1);
+            instructions[0].type.should.equal('ApplyPendingBalance');
+            const rawInstructions = solTx(tx).instructions;
+            rawInstructions.should.have.length(1);
+            const data = rawInstructions[0].data;
+            data.length.should.equal(46);
+            data[0].should.equal(27); // ConfidentialTransferExtension
+            data[1].should.equal(8); // ApplyPendingBalance
+            data.readBigUInt64LE(2).toString().should.equal('3'); // expected_pending_balance_credit_counter
+            data.slice(10, 46).toString('hex').should.equal(zeroBytes36); // new_decryptable_available_balance
+            // Verify accounts: [token(writable), authority(signer)]
+            const keys = rawInstructions[0].keys;
+            keys.should.have.length(2);
+            keys[0].pubkey.toString().should.equal(tokenAddress);
+            keys[0].isWritable.should.be.true();
+            keys[1].pubkey.toString().should.equal(authorityAddress);
+            keys[1].isSigner.should.be.true();
+        });
+    });
+    describe('Deposit', () => {
+        it('should build a deposit instruction with correct 11-byte layout', async () => {
+            const builder = ctBuilder();
+            builder.confidentialDeposit({
+                tokenAddress,
+                mintAddress,
+                authorityAddress,
+                amount: '1000000',
+                decimals: 6,
+            });
+            const tx = await builder.build();
+            const instructions = tx.toJson().instructionsData;
+            instructions.should.have.length(1);
+            instructions[0].type.should.equal('ConfidentialDeposit');
+            const rawInstructions = solTx(tx).instructions;
+            rawInstructions.should.have.length(1);
+            const data = rawInstructions[0].data;
+            data.length.should.equal(11);
+            data[0].should.equal(27); // ConfidentialTransferExtension
+            data[1].should.equal(5); // Deposit
+            data.readBigUInt64LE(2).toString().should.equal('1000000'); // amount
+            data[10].should.equal(6); // decimals
+            // Verify accounts: [token(writable), mint, authority(signer)]
+            const keys = rawInstructions[0].keys;
+            keys.should.have.length(3);
+            keys[0].pubkey.toString().should.equal(tokenAddress);
+            keys[0].isWritable.should.be.true();
+            keys[1].pubkey.toString().should.equal(mintAddress);
+            keys[2].pubkey.toString().should.equal(authorityAddress);
+            keys[2].isSigner.should.be.true();
+        });
+    });
+    describe('Withdraw', () => {
+        it('should build a withdraw instruction with correct 49-byte layout and inline proofs', async () => {
+            const builder = ctBuilder();
+            builder.confidentialWithdraw({
+                tokenAddress,
+                mintAddress,
+                authorityAddress,
+                amount: '500000',
+                decimals: 6,
+                newDecryptableAvailableBalance: zeroBytes36,
+                equalityProofInstructionOffset: 1,
+                rangeProofInstructionOffset: 2,
+            });
+            const tx = await builder.build();
+            const instructions = tx.toJson().instructionsData;
+            instructions.should.have.length(1);
+            instructions[0].type.should.equal('ConfidentialWithdraw');
+            const rawInstructions = solTx(tx).instructions;
+            rawInstructions.should.have.length(1);
+            const data = rawInstructions[0].data;
+            data.length.should.equal(49);
+            data[0].should.equal(27); // ConfidentialTransferExtension
+            data[1].should.equal(6); // Withdraw
+            data.readBigUInt64LE(2).toString().should.equal('500000'); // amount
+            data[10].should.equal(6); // decimals
+            data.slice(11, 47).toString('hex').should.equal(zeroBytes36); // new_decryptable
+            data[47].should.equal(1); // equality proof offset
+            data[48].should.equal(2); // range proof offset
+            // Verify accounts: [token(writable), mint, sysvar, authority(signer)]
+            const keys = rawInstructions[0].keys;
+            keys.should.have.length(4);
+            keys[0].pubkey.toString().should.equal(tokenAddress);
+            keys[0].isWritable.should.be.true();
+            keys[1].pubkey.toString().should.equal(mintAddress);
+            keys[2].pubkey.toString().should.equal('Sysvar1nstructions1111111111111111111111111');
+            keys[3].pubkey.toString().should.equal(authorityAddress);
+            keys[3].isSigner.should.be.true();
+        });
+        it('should build a withdraw instruction with context state accounts', async () => {
+            const builder = ctBuilder();
+            builder.confidentialWithdraw({
+                tokenAddress,
+                mintAddress,
+                authorityAddress,
+                equalityProofContextStateAddress: eqCtxAddress,
+                rangeProofContextStateAddress: rangeCtxAddress,
+                amount: '500000',
+                decimals: 6,
+                newDecryptableAvailableBalance: zeroBytes36,
+                equalityProofInstructionOffset: 0,
+                rangeProofInstructionOffset: 0,
+            });
+            const tx = await builder.build();
+            const keys = solTx(tx).instructions[0].keys;
+            // [token, mint, eqCtx, rgCtx, authority] — no sysvar since all proofs use context state
+            keys.should.have.length(5);
+            keys[2].pubkey.toString().should.equal(eqCtxAddress);
+            keys[3].pubkey.toString().should.equal(rangeCtxAddress);
+            keys[4].pubkey.toString().should.equal(authorityAddress);
+            keys[4].isSigner.should.be.true();
+        });
+    });
+    describe('ConfidentialTransfer', () => {
+        it('should build a transfer instruction with correct 169-byte layout and inline proofs', async () => {
+            const builder = ctBuilder();
+            builder.confidentialTransfer({
+                sourceTokenAddress: tokenAddress,
+                mintAddress,
+                destinationTokenAddress,
+                authorityAddress,
+                newSourceDecryptableAvailableBalance: zeroBytes36,
+                transferAmountAuditorCiphertextLo: zeroBytes64,
+                transferAmountAuditorCiphertextHi: zeroBytes64,
+                equalityProofInstructionOffset: 1,
+                ciphertextValidityProofInstructionOffset: 2,
+                rangeProofInstructionOffset: 3,
+            });
+            const tx = await builder.build();
+            const instructions = tx.toJson().instructionsData;
+            instructions.should.have.length(1);
+            instructions[0].type.should.equal('ConfidentialTransfer');
+            const rawInstructions = solTx(tx).instructions;
+            rawInstructions.should.have.length(1);
+            const data = rawInstructions[0].data;
+            data.length.should.equal(169);
+            data[0].should.equal(27); // ConfidentialTransferExtension
+            data[1].should.equal(7); // Transfer
+            data.slice(2, 38).toString('hex').should.equal(zeroBytes36); // new_source_decryptable
+            data.slice(38, 102).toString('hex').should.equal(zeroBytes64); // auditor_ct_lo
+            data.slice(102, 166).toString('hex').should.equal(zeroBytes64); // auditor_ct_hi
+            data[166].should.equal(1); // equality proof offset
+            data[167].should.equal(2); // validity proof offset
+            data[168].should.equal(3); // range proof offset
+            // Verify accounts: [source(writable), mint, dest(writable), sysvar, authority(signer)]
+            const keys = rawInstructions[0].keys;
+            keys.should.have.length(5);
+            keys[0].pubkey.toString().should.equal(tokenAddress);
+            keys[0].isWritable.should.be.true();
+            keys[1].pubkey.toString().should.equal(mintAddress);
+            keys[2].pubkey.toString().should.equal(destinationTokenAddress);
+            keys[2].isWritable.should.be.true();
+            keys[3].pubkey.toString().should.equal('Sysvar1nstructions1111111111111111111111111');
+            keys[4].pubkey.toString().should.equal(authorityAddress);
+            keys[4].isSigner.should.be.true();
+        });
+        it('should build a transfer instruction with context state accounts', async () => {
+            const builder = ctBuilder();
+            builder.confidentialTransfer({
+                sourceTokenAddress: tokenAddress,
+                mintAddress,
+                destinationTokenAddress,
+                authorityAddress,
+                equalityProofContextStateAddress: eqCtxAddress,
+                ciphertextValidityProofContextStateAddress: validityCtxAddress,
+                rangeProofContextStateAddress: rangeCtxAddress,
+                newSourceDecryptableAvailableBalance: zeroBytes36,
+                transferAmountAuditorCiphertextLo: zeroBytes64,
+                transferAmountAuditorCiphertextHi: zeroBytes64,
+                equalityProofInstructionOffset: 0,
+                ciphertextValidityProofInstructionOffset: 0,
+                rangeProofInstructionOffset: 0,
+            });
+            const tx = await builder.build();
+            const keys = solTx(tx).instructions[0].keys;
+            // [source, mint, dest, eqCtx, validityCtx, rangeCtx, authority] — no sysvar
+            keys.should.have.length(7);
+            keys[3].pubkey.toString().should.equal(eqCtxAddress);
+            keys[4].pubkey.toString().should.equal(validityCtxAddress);
+            keys[5].pubkey.toString().should.equal(rangeCtxAddress);
+            keys[6].pubkey.toString().should.equal(authorityAddress);
+            keys[6].isSigner.should.be.true();
+        });
+    });
+    describe('VerifyPubkeyValidity', () => {
+        it('should build a verify pubkey validity instruction with inline proof data', async () => {
+            const builder = ctBuilder();
+            builder.verifyPubkeyValidity({ proofData: proofDataHex });
+            const tx = await builder.build();
+            const rawInstructions = solTx(tx).instructions;
+            rawInstructions.should.have.length(1);
+            const data = rawInstructions[0].data;
+            data[0].should.equal(4); // VerifyPubkeyValidity discriminator
+            data.length.should.equal(1 + 320); // discriminator + proof data
+            data.slice(1).toString('hex').should.equal(proofDataHex);
+            // No accounts for inline proof
+            rawInstructions[0].keys.should.have.length(0);
+            // Verify program id (canonical on-chain id)
+            rawInstructions[0].programId.toString().should.equal('ZkE1Gama1Proof11111111111111111111111111111');
+        });
+        it('should build with context state account (fix #3)', async () => {
+            const builder = ctBuilder();
+            builder.verifyPubkeyValidity({
+                contextStateAccountAddress: eqCtxAddress,
+                contextStateAuthorityAddress: authorityAddress,
+            });
+            const tx = await builder.build();
+            const rawIx = solTx(tx).instructions[0];
+            const data = rawIx.data;
+            data[0].should.equal(4); // VerifyPubkeyValidity discriminator
+            // Context state accounts: [contextState(writable), authority]
+            rawIx.keys.should.have.length(2);
+            rawIx.keys[0].pubkey.toString().should.equal(eqCtxAddress);
+            rawIx.keys[0].isWritable.should.be.true();
+            rawIx.keys[1].pubkey.toString().should.equal(authorityAddress);
+        });
+    });
+    describe('VerifyEqualityProof', () => {
+        it('should build with inline proof data', async () => {
+            const builder = ctBuilder();
+            builder.verifyEqualityProof({ proofData: proofDataHex });
+            const tx = await builder.build();
+            const data = solTx(tx).instructions[0].data;
+            data[0].should.equal(3); // VerifyCiphertextCommitmentEquality discriminator
+            data.length.should.equal(1 + 320);
+            data.slice(1).toString('hex').should.equal(proofDataHex);
+        });
+        it('should build with context state offset', async () => {
+            const builder = ctBuilder();
+            builder.verifyEqualityProof({
+                contextStateAccountAddress: eqCtxAddress,
+                contextStateAuthorityAddress: authorityAddress,
+                offset: 0,
+            });
+            const tx = await builder.build();
+            const rawIx = solTx(tx).instructions[0];
+            const data = rawIx.data;
+            data[0].should.equal(3);
+            data.readUInt32LE(1).should.equal(0); // offset as u32
+            // Context state accounts: [contextState(writable), authority]
+            rawIx.keys.should.have.length(2);
+            rawIx.keys[0].pubkey.toString().should.equal(eqCtxAddress);
+            rawIx.keys[0].isWritable.should.be.true();
+            rawIx.keys[1].pubkey.toString().should.equal(authorityAddress);
+        });
+    });
+    describe('VerifyValidityProof', () => {
+        it('should build with inline proof data', async () => {
+            const builder = ctBuilder();
+            builder.verifyValidityProof({ proofData: proofDataHex });
+            const tx = await builder.build();
+            const data = solTx(tx).instructions[0].data;
+            data[0].should.equal(12); // VerifyBatchedGroupedCiphertext3HandlesValidity
+            data.length.should.equal(1 + 320);
+        });
+    });
+    describe('VerifyRangeProof', () => {
+        it('should build with inline proof data', async () => {
+            const builder = ctBuilder();
+            builder.verifyRangeProof({ proofData: '00'.repeat(1000) }); // range proof is ~1000 bytes
+            const tx = await builder.build();
+            const data = solTx(tx).instructions[0].data;
+            data[0].should.equal(7); // VerifyBatchedRangeProofU128
+            data.length.should.equal(1 + 1000);
+        });
+    });
+    describe('Multiple instructions (v1 tx simulation)', () => {
+        it('should build ApplyPendingBalance + 3 proofs + Transfer in correct order', async () => {
+            const builder = ctBuilder();
+            builder
+                .applyPendingBalance({
+                tokenAddress,
+                authorityAddress,
+                expectedPendingBalanceCreditCounter: '2',
+                newDecryptableAvailableBalance: zeroBytes36,
+            })
+                .verifyEqualityProof({ proofData: proofDataHex })
+                .verifyValidityProof({ proofData: proofDataHex })
+                .verifyRangeProof({ proofData: '00'.repeat(1000) })
+                .confidentialTransfer({
+                sourceTokenAddress: tokenAddress,
+                mintAddress,
+                destinationTokenAddress,
+                authorityAddress,
+                newSourceDecryptableAvailableBalance: zeroBytes36,
+                transferAmountAuditorCiphertextLo: zeroBytes64,
+                transferAmountAuditorCiphertextHi: zeroBytes64,
+                equalityProofInstructionOffset: 1,
+                ciphertextValidityProofInstructionOffset: 2,
+                rangeProofInstructionOffset: 3,
+            });
+            const tx = await builder.build();
+            const instructions = tx.toJson().instructionsData;
+            instructions.should.have.length(5);
+            instructions[0].type.should.equal('ApplyPendingBalance');
+            instructions[1].type.should.equal('VerifyEqualityProof');
+            instructions[2].type.should.equal('VerifyValidityProof');
+            instructions[3].type.should.equal('VerifyRangeProof');
+            instructions[4].type.should.equal('ConfidentialTransfer');
+            // Note: Cannot verify toBroadcastFormat() here because 3 proofs (320+320+1000 bytes)
+            // + transfer (169B) exceeds v0 tx size limit (1232B). These are v1 transactions (4132B).
+            // The instruction data layouts are verified individually in the tests above.
+        });
+        it('should build ConfigureAccount + VerifyPubkeyValidity', async () => {
+            const builder = ctBuilder();
+            builder
+                .configureAccount({
+                tokenAddress,
+                mintAddress,
+                authorityAddress,
+                elgamalPubkey: '11'.repeat(32),
+                decryptableZeroBalance: zeroBytes36,
+                maximumPendingBalanceCreditCounter: '65536',
+                proofInstructionOffset: 1,
+            })
+                .verifyPubkeyValidity({ proofData: proofDataHex });
+            const tx = await builder.build();
+            const instructions = tx.toJson().instructionsData;
+            instructions.should.have.length(2);
+            instructions[0].type.should.equal('ConfigureConfidentialTransferAccount');
+            instructions[1].type.should.equal('VerifyPubkeyValidity');
+            const rawTx = tx.toBroadcastFormat();
+            src_1.Utils.isValidRawTransaction(rawTx).should.equal(true);
+        });
+    });
+    describe('Raw transaction validity', () => {
+        it('should produce a valid raw transaction', async () => {
+            const builder = ctBuilder();
+            builder.configureAccount({
+                tokenAddress,
+                mintAddress,
+                authorityAddress,
+                elgamalPubkey: '11'.repeat(32),
+                decryptableZeroBalance: zeroBytes36,
+                maximumPendingBalanceCreditCounter: '65536',
+                proofInstructionOffset: 1,
+            });
+            const tx = await builder.build();
+            const rawTx = tx.toBroadcastFormat();
+            src_1.Utils.isValidRawTransaction(rawTx).should.equal(true);
+        });
+    });
+    describe('Validation', () => {
+        it('should reject empty builder', async () => {
+            const builder = ctBuilder();
+            await builder.build().should.be.rejectedWith(/confidential transfer instruction/);
+        });
+        it('should reject missing tokenAddress on configureAccount', () => {
+            const builder = ctBuilder();
+            should_1.default.throws(() => builder.configureAccount({
+                tokenAddress: '',
+                mintAddress,
+                authorityAddress,
+                elgamalPubkey: '11'.repeat(32),
+                decryptableZeroBalance: zeroBytes36,
+                maximumPendingBalanceCreditCounter: '65536',
+                proofInstructionOffset: 1,
+            }));
+        });
+    });
+    // ─── Fix-specific tests ────────────────────────────────────────────────────
+    describe('Fix #1: signed i8 proof instruction offsets', () => {
+        it('should correctly encode negative offset on ConfigureAccount', async () => {
+            const builder = ctBuilder();
+            builder.configureAccount({
+                tokenAddress,
+                mintAddress,
+                authorityAddress,
+                elgamalPubkey: '11'.repeat(32),
+                decryptableZeroBalance: zeroBytes36,
+                maximumPendingBalanceCreditCounter: '65536',
+                proofInstructionOffset: -1, // proof is the previous instruction
+            });
+            const tx = await builder.build();
+            const data = solTx(tx).instructions[0].data;
+            data[78].should.equal(255); // -1 as i8 = 255 as u8 (two's complement)
+        });
+        it('should correctly encode negative offset on Withdraw', async () => {
+            const builder = ctBuilder();
+            builder.confidentialWithdraw({
+                tokenAddress,
+                mintAddress,
+                authorityAddress,
+                equalityProofContextStateAddress: eqCtxAddress,
+                rangeProofContextStateAddress: rangeCtxAddress,
+                amount: '100',
+                decimals: 6,
+                newDecryptableAvailableBalance: zeroBytes36,
+                equalityProofInstructionOffset: -1,
+                rangeProofInstructionOffset: -2,
+            });
+            const tx = await builder.build();
+            const data = solTx(tx).instructions[0].data;
+            data[47].should.equal(255); // -1 as i8
+            data[48].should.equal(254); // -2 as i8
+        });
+        it('should correctly encode negative offsets on Transfer', async () => {
+            const builder = ctBuilder();
+            builder.confidentialTransfer({
+                sourceTokenAddress: tokenAddress,
+                mintAddress,
+                destinationTokenAddress,
+                authorityAddress,
+                equalityProofContextStateAddress: eqCtxAddress,
+                ciphertextValidityProofContextStateAddress: validityCtxAddress,
+                rangeProofContextStateAddress: rangeCtxAddress,
+                newSourceDecryptableAvailableBalance: zeroBytes36,
+                transferAmountAuditorCiphertextLo: zeroBytes64,
+                transferAmountAuditorCiphertextHi: zeroBytes64,
+                equalityProofInstructionOffset: -3,
+                ciphertextValidityProofInstructionOffset: -2,
+                rangeProofInstructionOffset: -1,
+            });
+            const tx = await builder.build();
+            const data = solTx(tx).instructions[0].data;
+            data[166].should.equal(253); // -3 as i8
+            data[167].should.equal(254); // -2 as i8
+            data[168].should.equal(255); // -1 as i8
+        });
+    });
+    describe('Fix #2: instruction order preservation in parser', () => {
+        it('should preserve interleaved CT and custom instruction order', async () => {
+            const builder = ctBuilder();
+            builder
+                .applyPendingBalance({
+                tokenAddress,
+                authorityAddress,
+                expectedPendingBalanceCreditCounter: '1',
+                newDecryptableAvailableBalance: zeroBytes36,
+            })
+                .verifyEqualityProof({ proofData: proofDataHex })
+                .confidentialTransfer({
+                sourceTokenAddress: tokenAddress,
+                mintAddress,
+                destinationTokenAddress,
+                authorityAddress,
+                equalityProofContextStateAddress: eqCtxAddress,
+                ciphertextValidityProofContextStateAddress: validityCtxAddress,
+                rangeProofContextStateAddress: rangeCtxAddress,
+                newSourceDecryptableAvailableBalance: zeroBytes36,
+                transferAmountAuditorCiphertextLo: zeroBytes64,
+                transferAmountAuditorCiphertextHi: zeroBytes64,
+                equalityProofInstructionOffset: 0,
+                ciphertextValidityProofInstructionOffset: 0,
+                rangeProofInstructionOffset: 0,
+            });
+            const tx = await builder.build();
+            const instructions = tx.toJson().instructionsData;
+            // Order should be: ApplyPendingBalance, VerifyEqualityProof, ConfidentialTransfer
+            instructions.should.have.length(3);
+            instructions[0].type.should.equal('ApplyPendingBalance');
+            instructions[1].type.should.equal('VerifyEqualityProof');
+            instructions[2].type.should.equal('ConfidentialTransfer');
+        });
+    });
+    describe('Fix #3: VerifyPubkeyValidity context state mode', () => {
+        it('should not throw when only context state accounts are provided (no proofData)', async () => {
+            const builder = ctBuilder();
+            builder.verifyPubkeyValidity({
+                contextStateAccountAddress: eqCtxAddress,
+                contextStateAuthorityAddress: authorityAddress,
+            });
+            const tx = await builder.build();
+            const rawIx = solTx(tx).instructions[0];
+            // Should produce an offset-based instruction, not throw
+            rawIx.data[0].should.equal(4);
+            rawIx.keys.should.have.length(2);
+        });
+    });
+    describe('Fix #4: context state address required when offset == 0', () => {
+        it('should reject Withdraw with offset 0 but missing equality context state address', async () => {
+            const builder = ctBuilder();
+            builder.confidentialWithdraw({
+                tokenAddress,
+                mintAddress,
+                authorityAddress,
+                rangeProofContextStateAddress: rangeCtxAddress,
+                amount: '100',
+                decimals: 6,
+                newDecryptableAvailableBalance: zeroBytes36,
+                equalityProofInstructionOffset: 0, // context state mode but no address
+                rangeProofInstructionOffset: 0,
+            });
+            await builder.build().should.be.rejectedWith(/equalityProofContextStateAddress is required/);
+        });
+        it('should reject Transfer with offset 0 but missing range context state address', async () => {
+            const builder = ctBuilder();
+            builder.confidentialTransfer({
+                sourceTokenAddress: tokenAddress,
+                mintAddress,
+                destinationTokenAddress,
+                authorityAddress,
+                equalityProofContextStateAddress: eqCtxAddress,
+                ciphertextValidityProofContextStateAddress: validityCtxAddress,
+                newSourceDecryptableAvailableBalance: zeroBytes36,
+                transferAmountAuditorCiphertextLo: zeroBytes64,
+                transferAmountAuditorCiphertextHi: zeroBytes64,
+                equalityProofInstructionOffset: 0,
+                ciphertextValidityProofInstructionOffset: 0,
+                rangeProofInstructionOffset: 0, // context state mode but no address
+            });
+            await builder.build().should.be.rejectedWith(/rangeProofContextStateAddress is required/);
+        });
+    });
+    describe('Fix #5: numeric string validation', () => {
+        it('should reject non-numeric amount on Deposit', async () => {
+            const builder = ctBuilder();
+            builder.confidentialDeposit({
+                tokenAddress,
+                mintAddress,
+                authorityAddress,
+                amount: 'abc',
+                decimals: 6,
+            });
+            await builder.build().should.be.rejectedWith(/Invalid amount: expected non-negative integer string/);
+        });
+        it('should reject negative amount on Deposit', async () => {
+            const builder = ctBuilder();
+            builder.confidentialDeposit({
+                tokenAddress,
+                mintAddress,
+                authorityAddress,
+                amount: '-100',
+                decimals: 6,
+            });
+            await builder.build().should.be.rejectedWith(/Invalid amount: expected non-negative integer string/);
+        });
+        it('should reject non-numeric counter on ApplyPendingBalance', async () => {
+            const builder = ctBuilder();
+            builder.applyPendingBalance({
+                tokenAddress,
+                authorityAddress,
+                expectedPendingBalanceCreditCounter: 'not-a-number',
+                newDecryptableAvailableBalance: zeroBytes36,
+            });
+            await builder.build().should.be.rejectedWith(/Invalid expectedPendingBalanceCreditCounter/);
+        });
+        it('should reject non-numeric counter on ConfigureAccount', async () => {
+            const builder = ctBuilder();
+            builder.configureAccount({
+                tokenAddress,
+                mintAddress,
+                authorityAddress,
+                elgamalPubkey: '11'.repeat(32),
+                decryptableZeroBalance: zeroBytes36,
+                maximumPendingBalanceCreditCounter: 'foo',
+                proofInstructionOffset: 1,
+            });
+            await builder.build().should.be.rejectedWith(/Invalid maximumPendingBalanceCreditCounter/);
+        });
+        it('should accept amount of 0 on Deposit', async () => {
+            const builder = ctBuilder();
+            builder.confidentialDeposit({
+                tokenAddress,
+                mintAddress,
+                authorityAddress,
+                amount: '0',
+                decimals: 6,
+            });
+            const tx = await builder.build();
+            const data = solTx(tx).instructions[0].data;
+            data.readBigUInt64LE(2).toString().should.equal('0');
+        });
+    });
+    describe('Fix #6: canonical ZK proof program ID', () => {
+        it('should use canonical zk-elgamal-proof program id', async () => {
+            const builder = ctBuilder();
+            builder.verifyEqualityProof({ proofData: proofDataHex });
+            const tx = await builder.build();
+            solTx(tx).instructions[0].programId.toString().should.equal('ZkE1Gama1Proof11111111111111111111111111111');
+        });
+        it('should allow overriding ZK proof program id', async () => {
+            const customProgramId = testData.associatedTokenAccounts.accounts[0].pub; // any valid pubkey
+            const builder = ctBuilder();
+            builder.zkProofProgramId(customProgramId);
+            builder.verifyEqualityProof({ proofData: proofDataHex });
+            const tx = await builder.build();
+            solTx(tx).instructions[0].programId.toString().should.equal(customProgramId);
+        });
+    });
+    describe('Fix #8: from() routing for CT transactions', () => {
+        it('should route CT transaction to ConfidentialTransferBuilder on from()', async () => {
+            // Build a CT transaction
+            const builder = ctBuilder();
+            builder.configureAccount({
+                tokenAddress,
+                mintAddress,
+                authorityAddress,
+                elgamalPubkey: '11'.repeat(32),
+                decryptableZeroBalance: zeroBytes36,
+                maximumPendingBalanceCreditCounter: '65536',
+                proofInstructionOffset: 1,
+            });
+            const tx = await builder.build();
+            const rawTx = tx.toBroadcastFormat();
+            // Parse it back via factory.from()
+            const parsedBuilder = factory.from(rawTx);
+            // Should be a ConfidentialTransferBuilder, not CustomInstructionBuilder
+            parsedBuilder.constructor.name.should.equal('ConfidentialTransferBuilder');
+        });
+        it('should route non-CT custom transaction to CustomInstructionBuilder on from()', async () => {
+            // Build a non-CT custom transaction
+            const customBuilder = factory.getCustomInstructionBuilder();
+            customBuilder.nonce(recentBlockHash);
+            customBuilder.sender(account.pub);
+            customBuilder.addCustomInstruction({
+                programId: 'MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr',
+                keys: [],
+                data: 'hello',
+            });
+            const tx = await customBuilder.build();
+            const rawTx = tx.toBroadcastFormat();
+            // Parse it back via factory.from()
+            const parsedBuilder = factory.from(rawTx);
+            parsedBuilder.constructor.name.should.equal('CustomInstructionBuilder');
+        });
+    });
+    describe('Fix #9: range validation for decimals and proof offsets', () => {
+        it('should reject decimals > 255 on Deposit', async () => {
+            const builder = ctBuilder();
+            builder.confidentialDeposit({
+                tokenAddress,
+                mintAddress,
+                authorityAddress,
+                amount: '100',
+                decimals: 256,
+            });
+            await builder.build().should.be.rejectedWith(/Invalid decimals: expected u8 \(0-255\)/);
+        });
+        it('should reject negative decimals on Deposit', async () => {
+            const builder = ctBuilder();
+            builder.confidentialDeposit({
+                tokenAddress,
+                mintAddress,
+                authorityAddress,
+                amount: '100',
+                decimals: -1,
+            });
+            await builder.build().should.be.rejectedWith(/Invalid decimals: expected u8 \(0-255\)/);
+        });
+        it('should reject non-integer decimals on Deposit', async () => {
+            const builder = ctBuilder();
+            builder.confidentialDeposit({
+                tokenAddress,
+                mintAddress,
+                authorityAddress,
+                amount: '100',
+                decimals: 6.5,
+            });
+            await builder.build().should.be.rejectedWith(/Invalid decimals: expected u8 \(0-255\)/);
+        });
+        it('should reject proof offset > 127 on ConfigureAccount', async () => {
+            const builder = ctBuilder();
+            builder.configureAccount({
+                tokenAddress,
+                mintAddress,
+                authorityAddress,
+                elgamalPubkey: '11'.repeat(32),
+                decryptableZeroBalance: zeroBytes36,
+                maximumPendingBalanceCreditCounter: '65536',
+                proofInstructionOffset: 128,
+            });
+            await builder.build().should.be.rejectedWith(/Invalid proofInstructionOffset: expected i8 \(-128 to 127\)/);
+        });
+        it('should reject proof offset < -128 on ConfigureAccount', async () => {
+            const builder = ctBuilder();
+            builder.configureAccount({
+                tokenAddress,
+                mintAddress,
+                authorityAddress,
+                elgamalPubkey: '11'.repeat(32),
+                decryptableZeroBalance: zeroBytes36,
+                maximumPendingBalanceCreditCounter: '65536',
+                proofInstructionOffset: -129,
+            });
+            await builder.build().should.be.rejectedWith(/Invalid proofInstructionOffset: expected i8 \(-128 to 127\)/);
+        });
+        it('should reject equality proof offset > 127 on Withdraw', async () => {
+            const builder = ctBuilder();
+            builder.confidentialWithdraw({
+                tokenAddress,
+                mintAddress,
+                authorityAddress,
+                equalityProofContextStateAddress: eqCtxAddress,
+                rangeProofContextStateAddress: rangeCtxAddress,
+                amount: '100',
+                decimals: 6,
+                newDecryptableAvailableBalance: zeroBytes36,
+                equalityProofInstructionOffset: 200,
+                rangeProofInstructionOffset: 0,
+            });
+            await builder.build().should.be.rejectedWith(/Invalid equalityProofInstructionOffset: expected i8/);
+        });
+        it('should reject range proof offset < -128 on Withdraw', async () => {
+            const builder = ctBuilder();
+            builder.confidentialWithdraw({
+                tokenAddress,
+                mintAddress,
+                authorityAddress,
+                equalityProofContextStateAddress: eqCtxAddress,
+                rangeProofContextStateAddress: rangeCtxAddress,
+                amount: '100',
+                decimals: 6,
+                newDecryptableAvailableBalance: zeroBytes36,
+                equalityProofInstructionOffset: 0,
+                rangeProofInstructionOffset: -200,
+            });
+            await builder.build().should.be.rejectedWith(/Invalid rangeProofInstructionOffset: expected i8/);
+        });
+        it('should reject validity proof offset out of i8 range on Transfer', async () => {
+            const builder = ctBuilder();
+            builder.confidentialTransfer({
+                sourceTokenAddress: tokenAddress,
+                mintAddress,
+                destinationTokenAddress,
+                authorityAddress,
+                equalityProofContextStateAddress: eqCtxAddress,
+                ciphertextValidityProofContextStateAddress: validityCtxAddress,
+                rangeProofContextStateAddress: rangeCtxAddress,
+                newSourceDecryptableAvailableBalance: zeroBytes36,
+                transferAmountAuditorCiphertextLo: zeroBytes64,
+                transferAmountAuditorCiphertextHi: zeroBytes64,
+                equalityProofInstructionOffset: 0,
+                ciphertextValidityProofInstructionOffset: 255,
+                rangeProofInstructionOffset: 0,
+            });
+            await builder.build().should.be.rejectedWith(/Invalid ciphertextValidityProofInstructionOffset: expected i8/);
+        });
+        it('should accept boundary offset values (-128 and 127)', async () => {
+            const builder = ctBuilder();
+            builder.configureAccount({
+                tokenAddress,
+                mintAddress,
+                authorityAddress,
+                elgamalPubkey: '11'.repeat(32),
+                decryptableZeroBalance: zeroBytes36,
+                maximumPendingBalanceCreditCounter: '65536',
+                proofInstructionOffset: 127,
+            });
+            const tx = await builder.build();
+            const data = solTx(tx).instructions[0].data;
+            data[78].should.equal(127);
+        });
+    });
+    describe('Fix #10: u64 overflow validation', () => {
+        it('should reject amount exceeding u64 max on Deposit', async () => {
+            const builder = ctBuilder();
+            builder.confidentialDeposit({
+                tokenAddress,
+                mintAddress,
+                authorityAddress,
+                amount: '18446744073709551616', // 2^64
+                decimals: 6,
+            });
+            await builder.build().should.be.rejectedWith(/Invalid amount: value exceeds u64 max/);
+        });
+        it('should accept amount at u64 max on Deposit', async () => {
+            const builder = ctBuilder();
+            builder.confidentialDeposit({
+                tokenAddress,
+                mintAddress,
+                authorityAddress,
+                amount: '18446744073709551615', // 2^64 - 1
+                decimals: 6,
+            });
+            const tx = await builder.build();
+            const data = solTx(tx).instructions[0].data;
+            data.readBigUInt64LE(2).toString().should.equal('18446744073709551615');
+        });
+        it('should reject counter exceeding u64 max on ConfigureAccount', async () => {
+            const builder = ctBuilder();
+            builder.configureAccount({
+                tokenAddress,
+                mintAddress,
+                authorityAddress,
+                elgamalPubkey: '11'.repeat(32),
+                decryptableZeroBalance: zeroBytes36,
+                maximumPendingBalanceCreditCounter: '18446744073709551616', // 2^64
+                proofInstructionOffset: 1,
+            });
+            await builder.build().should.be.rejectedWith(/Invalid maximumPendingBalanceCreditCounter: value exceeds u64 max/);
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"confidentialTransferBuilder.js","sourceRoot":"","sources":["../../../../../test/unit/transactionBuilder/confidentialTransferBuilder.ts"],"names":[],"mappings":"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","sourcesContent":["import { KeyPair, Utils, Transaction } from '../../../src';\nimport should from 'should';\nimport * as testData from '../../resources/sol';\nimport { getBuilderFactory } from '../getBuilderFactory';\n\ndescribe('Solana Confidential Transfer Builder', () => {\n  const factory = getBuilderFactory('sol');\n  const account = new KeyPair(testData.associatedTokenAccounts.accounts[0]).getKeys();\n  const recentBlockHash = 'GHtXQBsoZHVnNFa9YevAzFr17DJjgHXk3ycTKD5xD3Zi';\n\n  // Test addresses (Token-2022 mint + ATAs)\n  const mintAddress = testData.associatedTokenAccountsForSol2022.mintId;\n  const tokenAddress = testData.associatedTokenAccountsForSol2022.accounts[0].ata;\n  const destinationTokenAddress = 'ENn8a2tGMS9bR5XV7smGHJvNgzkyxJmnD2eUvQxY5jSP';\n  const authorityAddress = account.pub;\n  // Valid base58 addresses for context state accounts (any valid Solana pubkey)\n  const eqCtxAddress = testData.associatedTokenAccounts.accounts[0].ata;\n  const validityCtxAddress = testData.associatedTokenAccounts.accounts[0].pub;\n  const rangeCtxAddress = testData.nonceAccount.pub;\n\n  // Hex test data\n  const zeroBytes36 = '00'.repeat(36);\n  const zeroBytes64 = '00'.repeat(64);\n  const proofDataHex = '00'.repeat(320); // typical equality proof size\n\n  const ctBuilder = () => {\n    const txBuilder = factory.getConfidentialTransferBuilder();\n    txBuilder.nonce(recentBlockHash);\n    txBuilder.sender(account.pub);\n    return txBuilder;\n  };\n\n  /** Access the raw Solana Transaction from the built tx */\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  const solTx = (tx: any): any => (tx as Transaction).solTransaction;\n\n  describe('ConfigureAccount', () => {\n    it('should build a configure account instruction with correct 79-byte layout', async () => {\n      const builder = ctBuilder();\n      builder.configureAccount({\n        tokenAddress,\n        mintAddress,\n        authorityAddress,\n        elgamalPubkey: '11'.repeat(32),\n        decryptableZeroBalance: zeroBytes36,\n        maximumPendingBalanceCreditCounter: '65536',\n        proofInstructionOffset: 1,\n      });\n\n      const tx = await builder.build();\n      const instructions = tx.toJson().instructionsData;\n      instructions.should.have.length(1);\n      instructions[0].type.should.equal('ConfigureConfidentialTransferAccount');\n\n      // Verify raw instruction data\n      const rawInstructions = solTx(tx).instructions;\n      rawInstructions.should.have.length(1);\n      const data = rawInstructions[0].data;\n      data.length.should.equal(79);\n      data[0].should.equal(27); // ConfidentialTransferExtension\n      data[1].should.equal(2); // ConfigureAccount\n      data.slice(2, 34).toString('hex').should.equal('11'.repeat(32)); // new_account_elgamal_pubkey\n      data.slice(34, 70).toString('hex').should.equal(zeroBytes36); // decryptable_zero_balance\n      data.readBigUInt64LE(70).toString().should.equal('65536'); // max pending balance credit counter\n      data[78].should.equal(1); // proof_instruction_offset\n\n      // Verify accounts\n      const keys = rawInstructions[0].keys;\n      keys.should.have.length(4);\n      keys[0].pubkey.toString().should.equal(tokenAddress);\n      keys[0].isWritable.should.be.true();\n      keys[1].pubkey.toString().should.equal(mintAddress);\n      keys[1].isWritable.should.be.false();\n      keys[2].pubkey.toString().should.equal('Sysvar1nstructions1111111111111111111111111'); // instructions sysvar\n      keys[3].pubkey.toString().should.equal(authorityAddress);\n      keys[3].isSigner.should.be.true();\n    });\n\n    it('should use context state address when provided', async () => {\n      const contextStateAddress = testData.associatedTokenAccounts.accounts[0].pub;\n      const builder = ctBuilder();\n      builder.configureAccount({\n        tokenAddress,\n        mintAddress,\n        authorityAddress,\n        elgamalPubkey: '11'.repeat(32),\n        instructionsSysvarOrContextStateAddress: contextStateAddress,\n        decryptableZeroBalance: zeroBytes36,\n        maximumPendingBalanceCreditCounter: '65536',\n        proofInstructionOffset: 0,\n      });\n\n      const tx = await builder.build();\n      const keys = solTx(tx).instructions[0].keys;\n      keys[2].pubkey.toString().should.equal(contextStateAddress);\n      const data = solTx(tx).instructions[0].data;\n      data[78].should.equal(0); // proof_instruction_offset = 0 (context state)\n    });\n  });\n\n  describe('ApplyPendingBalance', () => {\n    it('should build an apply pending balance instruction with correct 46-byte layout', async () => {\n      const builder = ctBuilder();\n      builder.applyPendingBalance({\n        tokenAddress,\n        authorityAddress,\n        expectedPendingBalanceCreditCounter: '3',\n        newDecryptableAvailableBalance: zeroBytes36,\n      });\n\n      const tx = await builder.build();\n      const instructions = tx.toJson().instructionsData;\n      instructions.should.have.length(1);\n      instructions[0].type.should.equal('ApplyPendingBalance');\n\n      const rawInstructions = solTx(tx).instructions;\n      rawInstructions.should.have.length(1);\n      const data = rawInstructions[0].data;\n      data.length.should.equal(46);\n      data[0].should.equal(27); // ConfidentialTransferExtension\n      data[1].should.equal(8); // ApplyPendingBalance\n      data.readBigUInt64LE(2).toString().should.equal('3'); // expected_pending_balance_credit_counter\n      data.slice(10, 46).toString('hex').should.equal(zeroBytes36); // new_decryptable_available_balance\n\n      // Verify accounts: [token(writable), authority(signer)]\n      const keys = rawInstructions[0].keys;\n      keys.should.have.length(2);\n      keys[0].pubkey.toString().should.equal(tokenAddress);\n      keys[0].isWritable.should.be.true();\n      keys[1].pubkey.toString().should.equal(authorityAddress);\n      keys[1].isSigner.should.be.true();\n    });\n  });\n\n  describe('Deposit', () => {\n    it('should build a deposit instruction with correct 11-byte layout', async () => {\n      const builder = ctBuilder();\n      builder.confidentialDeposit({\n        tokenAddress,\n        mintAddress,\n        authorityAddress,\n        amount: '1000000',\n        decimals: 6,\n      });\n\n      const tx = await builder.build();\n      const instructions = tx.toJson().instructionsData;\n      instructions.should.have.length(1);\n      instructions[0].type.should.equal('ConfidentialDeposit');\n\n      const rawInstructions = solTx(tx).instructions;\n      rawInstructions.should.have.length(1);\n      const data = rawInstructions[0].data;\n      data.length.should.equal(11);\n      data[0].should.equal(27); // ConfidentialTransferExtension\n      data[1].should.equal(5); // Deposit\n      data.readBigUInt64LE(2).toString().should.equal('1000000'); // amount\n      data[10].should.equal(6); // decimals\n\n      // Verify accounts: [token(writable), mint, authority(signer)]\n      const keys = rawInstructions[0].keys;\n      keys.should.have.length(3);\n      keys[0].pubkey.toString().should.equal(tokenAddress);\n      keys[0].isWritable.should.be.true();\n      keys[1].pubkey.toString().should.equal(mintAddress);\n      keys[2].pubkey.toString().should.equal(authorityAddress);\n      keys[2].isSigner.should.be.true();\n    });\n  });\n\n  describe('Withdraw', () => {\n    it('should build a withdraw instruction with correct 49-byte layout and inline proofs', async () => {\n      const builder = ctBuilder();\n      builder.confidentialWithdraw({\n        tokenAddress,\n        mintAddress,\n        authorityAddress,\n        amount: '500000',\n        decimals: 6,\n        newDecryptableAvailableBalance: zeroBytes36,\n        equalityProofInstructionOffset: 1,\n        rangeProofInstructionOffset: 2,\n      });\n\n      const tx = await builder.build();\n      const instructions = tx.toJson().instructionsData;\n      instructions.should.have.length(1);\n      instructions[0].type.should.equal('ConfidentialWithdraw');\n\n      const rawInstructions = solTx(tx).instructions;\n      rawInstructions.should.have.length(1);\n      const data = rawInstructions[0].data;\n      data.length.should.equal(49);\n      data[0].should.equal(27); // ConfidentialTransferExtension\n      data[1].should.equal(6); // Withdraw\n      data.readBigUInt64LE(2).toString().should.equal('500000'); // amount\n      data[10].should.equal(6); // decimals\n      data.slice(11, 47).toString('hex').should.equal(zeroBytes36); // new_decryptable\n      data[47].should.equal(1); // equality proof offset\n      data[48].should.equal(2); // range proof offset\n\n      // Verify accounts: [token(writable), mint, sysvar, authority(signer)]\n      const keys = rawInstructions[0].keys;\n      keys.should.have.length(4);\n      keys[0].pubkey.toString().should.equal(tokenAddress);\n      keys[0].isWritable.should.be.true();\n      keys[1].pubkey.toString().should.equal(mintAddress);\n      keys[2].pubkey.toString().should.equal('Sysvar1nstructions1111111111111111111111111');\n      keys[3].pubkey.toString().should.equal(authorityAddress);\n      keys[3].isSigner.should.be.true();\n    });\n\n    it('should build a withdraw instruction with context state accounts', async () => {\n      const builder = ctBuilder();\n      builder.confidentialWithdraw({\n        tokenAddress,\n        mintAddress,\n        authorityAddress,\n        equalityProofContextStateAddress: eqCtxAddress,\n        rangeProofContextStateAddress: rangeCtxAddress,\n        amount: '500000',\n        decimals: 6,\n        newDecryptableAvailableBalance: zeroBytes36,\n        equalityProofInstructionOffset: 0,\n        rangeProofInstructionOffset: 0,\n      });\n\n      const tx = await builder.build();\n      const keys = solTx(tx).instructions[0].keys;\n      // [token, mint, eqCtx, rgCtx, authority] — no sysvar since all proofs use context state\n      keys.should.have.length(5);\n      keys[2].pubkey.toString().should.equal(eqCtxAddress);\n      keys[3].pubkey.toString().should.equal(rangeCtxAddress);\n      keys[4].pubkey.toString().should.equal(authorityAddress);\n      keys[4].isSigner.should.be.true();\n    });\n  });\n\n  describe('ConfidentialTransfer', () => {\n    it('should build a transfer instruction with correct 169-byte layout and inline proofs', async () => {\n      const builder = ctBuilder();\n      builder.confidentialTransfer({\n        sourceTokenAddress: tokenAddress,\n        mintAddress,\n        destinationTokenAddress,\n        authorityAddress,\n        newSourceDecryptableAvailableBalance: zeroBytes36,\n        transferAmountAuditorCiphertextLo: zeroBytes64,\n        transferAmountAuditorCiphertextHi: zeroBytes64,\n        equalityProofInstructionOffset: 1,\n        ciphertextValidityProofInstructionOffset: 2,\n        rangeProofInstructionOffset: 3,\n      });\n\n      const tx = await builder.build();\n      const instructions = tx.toJson().instructionsData;\n      instructions.should.have.length(1);\n      instructions[0].type.should.equal('ConfidentialTransfer');\n\n      const rawInstructions = solTx(tx).instructions;\n      rawInstructions.should.have.length(1);\n      const data = rawInstructions[0].data;\n      data.length.should.equal(169);\n      data[0].should.equal(27); // ConfidentialTransferExtension\n      data[1].should.equal(7); // Transfer\n      data.slice(2, 38).toString('hex').should.equal(zeroBytes36); // new_source_decryptable\n      data.slice(38, 102).toString('hex').should.equal(zeroBytes64); // auditor_ct_lo\n      data.slice(102, 166).toString('hex').should.equal(zeroBytes64); // auditor_ct_hi\n      data[166].should.equal(1); // equality proof offset\n      data[167].should.equal(2); // validity proof offset\n      data[168].should.equal(3); // range proof offset\n\n      // Verify accounts: [source(writable), mint, dest(writable), sysvar, authority(signer)]\n      const keys = rawInstructions[0].keys;\n      keys.should.have.length(5);\n      keys[0].pubkey.toString().should.equal(tokenAddress);\n      keys[0].isWritable.should.be.true();\n      keys[1].pubkey.toString().should.equal(mintAddress);\n      keys[2].pubkey.toString().should.equal(destinationTokenAddress);\n      keys[2].isWritable.should.be.true();\n      keys[3].pubkey.toString().should.equal('Sysvar1nstructions1111111111111111111111111');\n      keys[4].pubkey.toString().should.equal(authorityAddress);\n      keys[4].isSigner.should.be.true();\n    });\n\n    it('should build a transfer instruction with context state accounts', async () => {\n      const builder = ctBuilder();\n      builder.confidentialTransfer({\n        sourceTokenAddress: tokenAddress,\n        mintAddress,\n        destinationTokenAddress,\n        authorityAddress,\n        equalityProofContextStateAddress: eqCtxAddress,\n        ciphertextValidityProofContextStateAddress: validityCtxAddress,\n        rangeProofContextStateAddress: rangeCtxAddress,\n        newSourceDecryptableAvailableBalance: zeroBytes36,\n        transferAmountAuditorCiphertextLo: zeroBytes64,\n        transferAmountAuditorCiphertextHi: zeroBytes64,\n        equalityProofInstructionOffset: 0,\n        ciphertextValidityProofInstructionOffset: 0,\n        rangeProofInstructionOffset: 0,\n      });\n\n      const tx = await builder.build();\n      const keys = solTx(tx).instructions[0].keys;\n      // [source, mint, dest, eqCtx, validityCtx, rangeCtx, authority] — no sysvar\n      keys.should.have.length(7);\n      keys[3].pubkey.toString().should.equal(eqCtxAddress);\n      keys[4].pubkey.toString().should.equal(validityCtxAddress);\n      keys[5].pubkey.toString().should.equal(rangeCtxAddress);\n      keys[6].pubkey.toString().should.equal(authorityAddress);\n      keys[6].isSigner.should.be.true();\n    });\n  });\n\n  describe('VerifyPubkeyValidity', () => {\n    it('should build a verify pubkey validity instruction with inline proof data', async () => {\n      const builder = ctBuilder();\n      builder.verifyPubkeyValidity({ proofData: proofDataHex });\n\n      const tx = await builder.build();\n      const rawInstructions = solTx(tx).instructions;\n      rawInstructions.should.have.length(1);\n      const data = rawInstructions[0].data;\n      data[0].should.equal(4); // VerifyPubkeyValidity discriminator\n      data.length.should.equal(1 + 320); // discriminator + proof data\n      data.slice(1).toString('hex').should.equal(proofDataHex);\n\n      // No accounts for inline proof\n      rawInstructions[0].keys.should.have.length(0);\n\n      // Verify program id (canonical on-chain id)\n      rawInstructions[0].programId.toString().should.equal('ZkE1Gama1Proof11111111111111111111111111111');\n    });\n\n    it('should build with context state account (fix #3)', async () => {\n      const builder = ctBuilder();\n      builder.verifyPubkeyValidity({\n        contextStateAccountAddress: eqCtxAddress,\n        contextStateAuthorityAddress: authorityAddress,\n      });\n\n      const tx = await builder.build();\n      const rawIx = solTx(tx).instructions[0];\n      const data = rawIx.data;\n      data[0].should.equal(4); // VerifyPubkeyValidity discriminator\n      // Context state accounts: [contextState(writable), authority]\n      rawIx.keys.should.have.length(2);\n      rawIx.keys[0].pubkey.toString().should.equal(eqCtxAddress);\n      rawIx.keys[0].isWritable.should.be.true();\n      rawIx.keys[1].pubkey.toString().should.equal(authorityAddress);\n    });\n  });\n\n  describe('VerifyEqualityProof', () => {\n    it('should build with inline proof data', async () => {\n      const builder = ctBuilder();\n      builder.verifyEqualityProof({ proofData: proofDataHex });\n\n      const tx = await builder.build();\n      const data = solTx(tx).instructions[0].data;\n      data[0].should.equal(3); // VerifyCiphertextCommitmentEquality discriminator\n      data.length.should.equal(1 + 320);\n      data.slice(1).toString('hex').should.equal(proofDataHex);\n    });\n\n    it('should build with context state offset', async () => {\n      const builder = ctBuilder();\n      builder.verifyEqualityProof({\n        contextStateAccountAddress: eqCtxAddress,\n        contextStateAuthorityAddress: authorityAddress,\n        offset: 0,\n      });\n\n      const tx = await builder.build();\n      const rawIx = solTx(tx).instructions[0];\n      const data = rawIx.data;\n      data[0].should.equal(3);\n      data.readUInt32LE(1).should.equal(0); // offset as u32\n\n      // Context state accounts: [contextState(writable), authority]\n      rawIx.keys.should.have.length(2);\n      rawIx.keys[0].pubkey.toString().should.equal(eqCtxAddress);\n      rawIx.keys[0].isWritable.should.be.true();\n      rawIx.keys[1].pubkey.toString().should.equal(authorityAddress);\n    });\n  });\n\n  describe('VerifyValidityProof', () => {\n    it('should build with inline proof data', async () => {\n      const builder = ctBuilder();\n      builder.verifyValidityProof({ proofData: proofDataHex });\n\n      const tx = await builder.build();\n      const data = solTx(tx).instructions[0].data;\n      data[0].should.equal(12); // VerifyBatchedGroupedCiphertext3HandlesValidity\n      data.length.should.equal(1 + 320);\n    });\n  });\n\n  describe('VerifyRangeProof', () => {\n    it('should build with inline proof data', async () => {\n      const builder = ctBuilder();\n      builder.verifyRangeProof({ proofData: '00'.repeat(1000) }); // range proof is ~1000 bytes\n\n      const tx = await builder.build();\n      const data = solTx(tx).instructions[0].data;\n      data[0].should.equal(7); // VerifyBatchedRangeProofU128\n      data.length.should.equal(1 + 1000);\n    });\n  });\n\n  describe('Multiple instructions (v1 tx simulation)', () => {\n    it('should build ApplyPendingBalance + 3 proofs + Transfer in correct order', async () => {\n      const builder = ctBuilder();\n      builder\n        .applyPendingBalance({\n          tokenAddress,\n          authorityAddress,\n          expectedPendingBalanceCreditCounter: '2',\n          newDecryptableAvailableBalance: zeroBytes36,\n        })\n        .verifyEqualityProof({ proofData: proofDataHex })\n        .verifyValidityProof({ proofData: proofDataHex })\n        .verifyRangeProof({ proofData: '00'.repeat(1000) })\n        .confidentialTransfer({\n          sourceTokenAddress: tokenAddress,\n          mintAddress,\n          destinationTokenAddress,\n          authorityAddress,\n          newSourceDecryptableAvailableBalance: zeroBytes36,\n          transferAmountAuditorCiphertextLo: zeroBytes64,\n          transferAmountAuditorCiphertextHi: zeroBytes64,\n          equalityProofInstructionOffset: 1,\n          ciphertextValidityProofInstructionOffset: 2,\n          rangeProofInstructionOffset: 3,\n        });\n\n      const tx = await builder.build();\n      const instructions = tx.toJson().instructionsData;\n      instructions.should.have.length(5);\n      instructions[0].type.should.equal('ApplyPendingBalance');\n      instructions[1].type.should.equal('VerifyEqualityProof');\n      instructions[2].type.should.equal('VerifyValidityProof');\n      instructions[3].type.should.equal('VerifyRangeProof');\n      instructions[4].type.should.equal('ConfidentialTransfer');\n\n      // Note: Cannot verify toBroadcastFormat() here because 3 proofs (320+320+1000 bytes)\n      // + transfer (169B) exceeds v0 tx size limit (1232B). These are v1 transactions (4132B).\n      // The instruction data layouts are verified individually in the tests above.\n    });\n\n    it('should build ConfigureAccount + VerifyPubkeyValidity', async () => {\n      const builder = ctBuilder();\n      builder\n        .configureAccount({\n          tokenAddress,\n          mintAddress,\n          authorityAddress,\n          elgamalPubkey: '11'.repeat(32),\n          decryptableZeroBalance: zeroBytes36,\n          maximumPendingBalanceCreditCounter: '65536',\n          proofInstructionOffset: 1,\n        })\n        .verifyPubkeyValidity({ proofData: proofDataHex });\n\n      const tx = await builder.build();\n      const instructions = tx.toJson().instructionsData;\n      instructions.should.have.length(2);\n      instructions[0].type.should.equal('ConfigureConfidentialTransferAccount');\n      instructions[1].type.should.equal('VerifyPubkeyValidity');\n\n      const rawTx = tx.toBroadcastFormat();\n      Utils.isValidRawTransaction(rawTx).should.equal(true);\n    });\n  });\n\n  describe('Raw transaction validity', () => {\n    it('should produce a valid raw transaction', async () => {\n      const builder = ctBuilder();\n      builder.configureAccount({\n        tokenAddress,\n        mintAddress,\n        authorityAddress,\n        elgamalPubkey: '11'.repeat(32),\n        decryptableZeroBalance: zeroBytes36,\n        maximumPendingBalanceCreditCounter: '65536',\n        proofInstructionOffset: 1,\n      });\n\n      const tx = await builder.build();\n      const rawTx = tx.toBroadcastFormat();\n      Utils.isValidRawTransaction(rawTx).should.equal(true);\n    });\n  });\n\n  describe('Validation', () => {\n    it('should reject empty builder', async () => {\n      const builder = ctBuilder();\n      await builder.build().should.be.rejectedWith(/confidential transfer instruction/);\n    });\n\n    it('should reject missing tokenAddress on configureAccount', () => {\n      const builder = ctBuilder();\n      should.throws(() =>\n        builder.configureAccount({\n          tokenAddress: '',\n          mintAddress,\n          authorityAddress,\n          elgamalPubkey: '11'.repeat(32),\n          decryptableZeroBalance: zeroBytes36,\n          maximumPendingBalanceCreditCounter: '65536',\n          proofInstructionOffset: 1,\n        })\n      );\n    });\n  });\n\n  // ─── Fix-specific tests ────────────────────────────────────────────────────\n\n  describe('Fix #1: signed i8 proof instruction offsets', () => {\n    it('should correctly encode negative offset on ConfigureAccount', async () => {\n      const builder = ctBuilder();\n      builder.configureAccount({\n        tokenAddress,\n        mintAddress,\n        authorityAddress,\n        elgamalPubkey: '11'.repeat(32),\n        decryptableZeroBalance: zeroBytes36,\n        maximumPendingBalanceCreditCounter: '65536',\n        proofInstructionOffset: -1, // proof is the previous instruction\n      });\n\n      const tx = await builder.build();\n      const data = solTx(tx).instructions[0].data;\n      data[78].should.equal(255); // -1 as i8 = 255 as u8 (two's complement)\n    });\n\n    it('should correctly encode negative offset on Withdraw', async () => {\n      const builder = ctBuilder();\n      builder.confidentialWithdraw({\n        tokenAddress,\n        mintAddress,\n        authorityAddress,\n        equalityProofContextStateAddress: eqCtxAddress,\n        rangeProofContextStateAddress: rangeCtxAddress,\n        amount: '100',\n        decimals: 6,\n        newDecryptableAvailableBalance: zeroBytes36,\n        equalityProofInstructionOffset: -1,\n        rangeProofInstructionOffset: -2,\n      });\n\n      const tx = await builder.build();\n      const data = solTx(tx).instructions[0].data;\n      data[47].should.equal(255); // -1 as i8\n      data[48].should.equal(254); // -2 as i8\n    });\n\n    it('should correctly encode negative offsets on Transfer', async () => {\n      const builder = ctBuilder();\n      builder.confidentialTransfer({\n        sourceTokenAddress: tokenAddress,\n        mintAddress,\n        destinationTokenAddress,\n        authorityAddress,\n        equalityProofContextStateAddress: eqCtxAddress,\n        ciphertextValidityProofContextStateAddress: validityCtxAddress,\n        rangeProofContextStateAddress: rangeCtxAddress,\n        newSourceDecryptableAvailableBalance: zeroBytes36,\n        transferAmountAuditorCiphertextLo: zeroBytes64,\n        transferAmountAuditorCiphertextHi: zeroBytes64,\n        equalityProofInstructionOffset: -3,\n        ciphertextValidityProofInstructionOffset: -2,\n        rangeProofInstructionOffset: -1,\n      });\n\n      const tx = await builder.build();\n      const data = solTx(tx).instructions[0].data;\n      data[166].should.equal(253); // -3 as i8\n      data[167].should.equal(254); // -2 as i8\n      data[168].should.equal(255); // -1 as i8\n    });\n  });\n\n  describe('Fix #2: instruction order preservation in parser', () => {\n    it('should preserve interleaved CT and custom instruction order', async () => {\n      const builder = ctBuilder();\n      builder\n        .applyPendingBalance({\n          tokenAddress,\n          authorityAddress,\n          expectedPendingBalanceCreditCounter: '1',\n          newDecryptableAvailableBalance: zeroBytes36,\n        })\n        .verifyEqualityProof({ proofData: proofDataHex })\n        .confidentialTransfer({\n          sourceTokenAddress: tokenAddress,\n          mintAddress,\n          destinationTokenAddress,\n          authorityAddress,\n          equalityProofContextStateAddress: eqCtxAddress,\n          ciphertextValidityProofContextStateAddress: validityCtxAddress,\n          rangeProofContextStateAddress: rangeCtxAddress,\n          newSourceDecryptableAvailableBalance: zeroBytes36,\n          transferAmountAuditorCiphertextLo: zeroBytes64,\n          transferAmountAuditorCiphertextHi: zeroBytes64,\n          equalityProofInstructionOffset: 0,\n          ciphertextValidityProofInstructionOffset: 0,\n          rangeProofInstructionOffset: 0,\n        });\n\n      const tx = await builder.build();\n      const instructions = tx.toJson().instructionsData;\n      // Order should be: ApplyPendingBalance, VerifyEqualityProof, ConfidentialTransfer\n      instructions.should.have.length(3);\n      instructions[0].type.should.equal('ApplyPendingBalance');\n      instructions[1].type.should.equal('VerifyEqualityProof');\n      instructions[2].type.should.equal('ConfidentialTransfer');\n    });\n  });\n\n  describe('Fix #3: VerifyPubkeyValidity context state mode', () => {\n    it('should not throw when only context state accounts are provided (no proofData)', async () => {\n      const builder = ctBuilder();\n      builder.verifyPubkeyValidity({\n        contextStateAccountAddress: eqCtxAddress,\n        contextStateAuthorityAddress: authorityAddress,\n      });\n\n      const tx = await builder.build();\n      const rawIx = solTx(tx).instructions[0];\n      // Should produce an offset-based instruction, not throw\n      rawIx.data[0].should.equal(4);\n      rawIx.keys.should.have.length(2);\n    });\n  });\n\n  describe('Fix #4: context state address required when offset == 0', () => {\n    it('should reject Withdraw with offset 0 but missing equality context state address', async () => {\n      const builder = ctBuilder();\n      builder.confidentialWithdraw({\n        tokenAddress,\n        mintAddress,\n        authorityAddress,\n        rangeProofContextStateAddress: rangeCtxAddress,\n        amount: '100',\n        decimals: 6,\n        newDecryptableAvailableBalance: zeroBytes36,\n        equalityProofInstructionOffset: 0, // context state mode but no address\n        rangeProofInstructionOffset: 0,\n      });\n      await builder.build().should.be.rejectedWith(/equalityProofContextStateAddress is required/);\n    });\n\n    it('should reject Transfer with offset 0 but missing range context state address', async () => {\n      const builder = ctBuilder();\n      builder.confidentialTransfer({\n        sourceTokenAddress: tokenAddress,\n        mintAddress,\n        destinationTokenAddress,\n        authorityAddress,\n        equalityProofContextStateAddress: eqCtxAddress,\n        ciphertextValidityProofContextStateAddress: validityCtxAddress,\n        newSourceDecryptableAvailableBalance: zeroBytes36,\n        transferAmountAuditorCiphertextLo: zeroBytes64,\n        transferAmountAuditorCiphertextHi: zeroBytes64,\n        equalityProofInstructionOffset: 0,\n        ciphertextValidityProofInstructionOffset: 0,\n        rangeProofInstructionOffset: 0, // context state mode but no address\n      });\n      await builder.build().should.be.rejectedWith(/rangeProofContextStateAddress is required/);\n    });\n  });\n\n  describe('Fix #5: numeric string validation', () => {\n    it('should reject non-numeric amount on Deposit', async () => {\n      const builder = ctBuilder();\n      builder.confidentialDeposit({\n        tokenAddress,\n        mintAddress,\n        authorityAddress,\n        amount: 'abc',\n        decimals: 6,\n      });\n      await builder.build().should.be.rejectedWith(/Invalid amount: expected non-negative integer string/);\n    });\n\n    it('should reject negative amount on Deposit', async () => {\n      const builder = ctBuilder();\n      builder.confidentialDeposit({\n        tokenAddress,\n        mintAddress,\n        authorityAddress,\n        amount: '-100',\n        decimals: 6,\n      });\n      await builder.build().should.be.rejectedWith(/Invalid amount: expected non-negative integer string/);\n    });\n\n    it('should reject non-numeric counter on ApplyPendingBalance', async () => {\n      const builder = ctBuilder();\n      builder.applyPendingBalance({\n        tokenAddress,\n        authorityAddress,\n        expectedPendingBalanceCreditCounter: 'not-a-number',\n        newDecryptableAvailableBalance: zeroBytes36,\n      });\n      await builder.build().should.be.rejectedWith(/Invalid expectedPendingBalanceCreditCounter/);\n    });\n\n    it('should reject non-numeric counter on ConfigureAccount', async () => {\n      const builder = ctBuilder();\n      builder.configureAccount({\n        tokenAddress,\n        mintAddress,\n        authorityAddress,\n        elgamalPubkey: '11'.repeat(32),\n        decryptableZeroBalance: zeroBytes36,\n        maximumPendingBalanceCreditCounter: 'foo',\n        proofInstructionOffset: 1,\n      });\n      await builder.build().should.be.rejectedWith(/Invalid maximumPendingBalanceCreditCounter/);\n    });\n\n    it('should accept amount of 0 on Deposit', async () => {\n      const builder = ctBuilder();\n      builder.confidentialDeposit({\n        tokenAddress,\n        mintAddress,\n        authorityAddress,\n        amount: '0',\n        decimals: 6,\n      });\n\n      const tx = await builder.build();\n      const data = solTx(tx).instructions[0].data;\n      data.readBigUInt64LE(2).toString().should.equal('0');\n    });\n  });\n\n  describe('Fix #6: canonical ZK proof program ID', () => {\n    it('should use canonical zk-elgamal-proof program id', async () => {\n      const builder = ctBuilder();\n      builder.verifyEqualityProof({ proofData: proofDataHex });\n\n      const tx = await builder.build();\n      solTx(tx).instructions[0].programId.toString().should.equal('ZkE1Gama1Proof11111111111111111111111111111');\n    });\n\n    it('should allow overriding ZK proof program id', async () => {\n      const customProgramId = testData.associatedTokenAccounts.accounts[0].pub; // any valid pubkey\n      const builder = ctBuilder();\n      builder.zkProofProgramId(customProgramId);\n      builder.verifyEqualityProof({ proofData: proofDataHex });\n\n      const tx = await builder.build();\n      solTx(tx).instructions[0].programId.toString().should.equal(customProgramId);\n    });\n  });\n\n  describe('Fix #8: from() routing for CT transactions', () => {\n    it('should route CT transaction to ConfidentialTransferBuilder on from()', async () => {\n      // Build a CT transaction\n      const builder = ctBuilder();\n      builder.configureAccount({\n        tokenAddress,\n        mintAddress,\n        authorityAddress,\n        elgamalPubkey: '11'.repeat(32),\n        decryptableZeroBalance: zeroBytes36,\n        maximumPendingBalanceCreditCounter: '65536',\n        proofInstructionOffset: 1,\n      });\n\n      const tx = await builder.build();\n      const rawTx = tx.toBroadcastFormat();\n\n      // Parse it back via factory.from()\n      const parsedBuilder = factory.from(rawTx);\n      // Should be a ConfidentialTransferBuilder, not CustomInstructionBuilder\n      parsedBuilder.constructor.name.should.equal('ConfidentialTransferBuilder');\n    });\n\n    it('should route non-CT custom transaction to CustomInstructionBuilder on from()', async () => {\n      // Build a non-CT custom transaction\n      const customBuilder = factory.getCustomInstructionBuilder();\n      customBuilder.nonce(recentBlockHash);\n      customBuilder.sender(account.pub);\n      customBuilder.addCustomInstruction({\n        programId: 'MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr',\n        keys: [],\n        data: 'hello',\n      });\n\n      const tx = await customBuilder.build();\n      const rawTx = tx.toBroadcastFormat();\n\n      // Parse it back via factory.from()\n      const parsedBuilder = factory.from(rawTx);\n      parsedBuilder.constructor.name.should.equal('CustomInstructionBuilder');\n    });\n  });\n\n  describe('Fix #9: range validation for decimals and proof offsets', () => {\n    it('should reject decimals > 255 on Deposit', async () => {\n      const builder = ctBuilder();\n      builder.confidentialDeposit({\n        tokenAddress,\n        mintAddress,\n        authorityAddress,\n        amount: '100',\n        decimals: 256,\n      });\n      await builder.build().should.be.rejectedWith(/Invalid decimals: expected u8 \\(0-255\\)/);\n    });\n\n    it('should reject negative decimals on Deposit', async () => {\n      const builder = ctBuilder();\n      builder.confidentialDeposit({\n        tokenAddress,\n        mintAddress,\n        authorityAddress,\n        amount: '100',\n        decimals: -1,\n      });\n      await builder.build().should.be.rejectedWith(/Invalid decimals: expected u8 \\(0-255\\)/);\n    });\n\n    it('should reject non-integer decimals on Deposit', async () => {\n      const builder = ctBuilder();\n      builder.confidentialDeposit({\n        tokenAddress,\n        mintAddress,\n        authorityAddress,\n        amount: '100',\n        decimals: 6.5,\n      });\n      await builder.build().should.be.rejectedWith(/Invalid decimals: expected u8 \\(0-255\\)/);\n    });\n\n    it('should reject proof offset > 127 on ConfigureAccount', async () => {\n      const builder = ctBuilder();\n      builder.configureAccount({\n        tokenAddress,\n        mintAddress,\n        authorityAddress,\n        elgamalPubkey: '11'.repeat(32),\n        decryptableZeroBalance: zeroBytes36,\n        maximumPendingBalanceCreditCounter: '65536',\n        proofInstructionOffset: 128,\n      });\n      await builder.build().should.be.rejectedWith(/Invalid proofInstructionOffset: expected i8 \\(-128 to 127\\)/);\n    });\n\n    it('should reject proof offset < -128 on ConfigureAccount', async () => {\n      const builder = ctBuilder();\n      builder.configureAccount({\n        tokenAddress,\n        mintAddress,\n        authorityAddress,\n        elgamalPubkey: '11'.repeat(32),\n        decryptableZeroBalance: zeroBytes36,\n        maximumPendingBalanceCreditCounter: '65536',\n        proofInstructionOffset: -129,\n      });\n      await builder.build().should.be.rejectedWith(/Invalid proofInstructionOffset: expected i8 \\(-128 to 127\\)/);\n    });\n\n    it('should reject equality proof offset > 127 on Withdraw', async () => {\n      const builder = ctBuilder();\n      builder.confidentialWithdraw({\n        tokenAddress,\n        mintAddress,\n        authorityAddress,\n        equalityProofContextStateAddress: eqCtxAddress,\n        rangeProofContextStateAddress: rangeCtxAddress,\n        amount: '100',\n        decimals: 6,\n        newDecryptableAvailableBalance: zeroBytes36,\n        equalityProofInstructionOffset: 200,\n        rangeProofInstructionOffset: 0,\n      });\n      await builder.build().should.be.rejectedWith(/Invalid equalityProofInstructionOffset: expected i8/);\n    });\n\n    it('should reject range proof offset < -128 on Withdraw', async () => {\n      const builder = ctBuilder();\n      builder.confidentialWithdraw({\n        tokenAddress,\n        mintAddress,\n        authorityAddress,\n        equalityProofContextStateAddress: eqCtxAddress,\n        rangeProofContextStateAddress: rangeCtxAddress,\n        amount: '100',\n        decimals: 6,\n        newDecryptableAvailableBalance: zeroBytes36,\n        equalityProofInstructionOffset: 0,\n        rangeProofInstructionOffset: -200,\n      });\n      await builder.build().should.be.rejectedWith(/Invalid rangeProofInstructionOffset: expected i8/);\n    });\n\n    it('should reject validity proof offset out of i8 range on Transfer', async () => {\n      const builder = ctBuilder();\n      builder.confidentialTransfer({\n        sourceTokenAddress: tokenAddress,\n        mintAddress,\n        destinationTokenAddress,\n        authorityAddress,\n        equalityProofContextStateAddress: eqCtxAddress,\n        ciphertextValidityProofContextStateAddress: validityCtxAddress,\n        rangeProofContextStateAddress: rangeCtxAddress,\n        newSourceDecryptableAvailableBalance: zeroBytes36,\n        transferAmountAuditorCiphertextLo: zeroBytes64,\n        transferAmountAuditorCiphertextHi: zeroBytes64,\n        equalityProofInstructionOffset: 0,\n        ciphertextValidityProofInstructionOffset: 255,\n        rangeProofInstructionOffset: 0,\n      });\n      await builder.build().should.be.rejectedWith(/Invalid ciphertextValidityProofInstructionOffset: expected i8/);\n    });\n\n    it('should accept boundary offset values (-128 and 127)', async () => {\n      const builder = ctBuilder();\n      builder.configureAccount({\n        tokenAddress,\n        mintAddress,\n        authorityAddress,\n        elgamalPubkey: '11'.repeat(32),\n        decryptableZeroBalance: zeroBytes36,\n        maximumPendingBalanceCreditCounter: '65536',\n        proofInstructionOffset: 127,\n      });\n\n      const tx = await builder.build();\n      const data = solTx(tx).instructions[0].data;\n      data[78].should.equal(127);\n    });\n  });\n\n  describe('Fix #10: u64 overflow validation', () => {\n    it('should reject amount exceeding u64 max on Deposit', async () => {\n      const builder = ctBuilder();\n      builder.confidentialDeposit({\n        tokenAddress,\n        mintAddress,\n        authorityAddress,\n        amount: '18446744073709551616', // 2^64\n        decimals: 6,\n      });\n      await builder.build().should.be.rejectedWith(/Invalid amount: value exceeds u64 max/);\n    });\n\n    it('should accept amount at u64 max on Deposit', async () => {\n      const builder = ctBuilder();\n      builder.confidentialDeposit({\n        tokenAddress,\n        mintAddress,\n        authorityAddress,\n        amount: '18446744073709551615', // 2^64 - 1\n        decimals: 6,\n      });\n\n      const tx = await builder.build();\n      const data = solTx(tx).instructions[0].data;\n      data.readBigUInt64LE(2).toString().should.equal('18446744073709551615');\n    });\n\n    it('should reject counter exceeding u64 max on ConfigureAccount', async () => {\n      const builder = ctBuilder();\n      builder.configureAccount({\n        tokenAddress,\n        mintAddress,\n        authorityAddress,\n        elgamalPubkey: '11'.repeat(32),\n        decryptableZeroBalance: zeroBytes36,\n        maximumPendingBalanceCreditCounter: '18446744073709551616', // 2^64\n        proofInstructionOffset: 1,\n      });\n      await builder.build().should.be.rejectedWith(/Invalid maximumPendingBalanceCreditCounter: value exceeds u64 max/);\n    });\n  });\n});\n"]}