@bitgo-beta/sdk-coin-sol 7.6.4-beta.76 → 7.6.4-beta.760

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

@@ -0,0 +1,346 @@
+"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 bs58 = __importStar(require("bs58"));
+const getBuilderFactory_1 = require("../getBuilderFactory");
+const src_1 = require("../../../src");
+const testData = __importStar(require("../../resources/sol"));
+const web3_js_1 = require("@solana/web3.js");
+const COMPUTE_BUDGET_PROGRAM_ID = 'ComputeBudget111111111111111111111111111111';
+/**
+ * Returns the on-chain instruction types of a built transaction in the order they appear
+ * in the compiled message, which is what the network executes. The compiled message
+ * includes the durable-nonce AdvanceNonceAccount instruction that web3.js serializes
+ * first, so a sponsored transaction with a compute unit limit, priority fee and durable
+ * nonce starts with [AdvanceNonceAccount, SetComputeUnitLimit, SetPriorityFee, ...].
+ */
+function compiledInstructionTypes(tx) {
+    const message = tx.solTransaction.compileMessage();
+    return message.instructions.map((compiledInstruction) => {
+        const instruction = new web3_js_1.TransactionInstruction({
+            programId: message.accountKeys[compiledInstruction.programIdIndex],
+            keys: compiledInstruction.accounts.map((accountKeyIndex) => ({
+                pubkey: message.accountKeys[accountKeyIndex],
+                isSigner: message.isAccountSigner(accountKeyIndex),
+                isWritable: message.isAccountWritable(accountKeyIndex),
+            })),
+            data: Buffer.from(bs58.decode(compiledInstruction.data)),
+        });
+        return src_1.Utils.getInstructionType(instruction);
+    });
+}
+/**
+ * Returns the compute-unit limits requested by the SetComputeUnitLimit instructions of
+ * the built transaction.
+ */
+function computeUnitLimits(tx) {
+    return tx.solTransaction.instructions
+        .filter((instruction) => instruction.programId.toString() === COMPUTE_BUDGET_PROGRAM_ID &&
+        src_1.Utils.getInstructionType(instruction) === 'SetComputeUnitLimit')
+        .map((instruction) => web3_js_1.ComputeBudgetInstruction.decodeSetComputeUnitLimit(instruction).units);
+}
+/**
+ * Raw transaction bytes of each builder intent below when no compute unit limit is set.
+ * Captured from the builders before the compute-unit-limit work, so any change to the
+ * no-limit build path (which must stay byte-identical) fails these comparisons.
+ */
+const RAW_TX_WITHOUT_COMPUTE_UNIT_LIMIT = {
+    'transfer builder': 'AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAQHReV5vPklPPaLR9/x+zo6XCwhusWyPAmuEqbgVWvwi0Fv+hKJ+pxZaLwHGEyk2Svp5PfAC5ZEi/wYI1tPTHHhbqkYG1L37ZDq6w2tS3G+tFODYWdhMXF+kwlYEF+3o4nVAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADBkZv5SEXMv/srbpyw5vnvIzlu8X3EmssQ5s6QAAAAAVKU1qZKSEGTSTocWDaOHx8NbXdvJK7geQfqEBBBUSNBqfVFxksVo7gioRfc9KXiM8DXDFFshqzRNgGLqlAAADjMtr5L6vs6LY/96RABeX9/Zr6FYdWthxalfkEs7jQgQQDAwEGAAQEAAAABAAJAxAnAAAAAAAAAwIAAgwCAAAA4JMEAAAAAAAFAAl0ZXN0IG1lbW8=',
+    'transfer builder v2': 'AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAMGReV5vPklPPaLR9/x+zo6XCwhusWyPAmuEqbgVWvwi0Fv+hKJ+pxZaLwHGEyk2Svp5PfAC5ZEi/wYI1tPTHHhbqkYG1L37ZDq6w2tS3G+tFODYWdhMXF+kwlYEF+3o4nVAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADBkZv5SEXMv/srbpyw5vnvIzlu8X3EmssQ5s6QAAAAAan1RcZLFaO4IqEX3PSl4jPA1wxRbIas0TYBi6pQAAA4zLa+S+r7Oi2P/ekQAXl/f2a+hWHVrYcWpX5BLO40IEDAwMBBQAEBAAAAAQACQMQJwAAAAAAAAMCAAIMAgAAAOCTBAAAAAAA',
+    'token transfer builder': 'AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAUJAGymKVqOJEQemBHH67uu8ISJV4rtwTejLrjw7VSeW6dv+hKJ+pxZaLwHGEyk2Svp5PfAC5ZEi/wYI1tPTHHhbpXS8VwMObd6fTnfCKrnxvwQ5LFhipVbiG+aiTNM1eFsqRgbUvftkOrrDa1Lcb60U4NhZ2ExcX6TCVgQX7ejidUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMGRm/lIRcy/+ytunLDm+e8jOW7xfcSayxDmzpAAAAA0QOJ+87lKPIIYR3MxzSzEJJUDLK41Y0QDy6qLO202l4Gp9UXGSxWjuCKhF9z0peIzwNcMUWyGrNE2AYuqUAAAAbd9uHXZaGT2cvhRs7reawctIXtX1s3kTqM9YV+/wCp4zLa+S+r7Oi2P/ekQAXl/f2a+hWHVrYcWpX5BLO40IEDBAMBBwAEBAAAAAUACQMQJwAAAAAAAAgEAgYDAAoM4JMEAAAAAAAJ',
+    'ata initialization builder': 'AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAYJReV5vPklPPaLR9/x+zo6XCwhusWyPAmuEqbgVWvwi0EAxPE0fqi8zYGKbihafYdJgknwg8wIfK86jxD3ILOvGW/6Eon6nFlovAcYTKTZK+nk98ALlkSL/BgjW09MceFuAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACMlyWPTiSJ8bs9ECkUjg2DC1oTmdr/EIQEjnvY2+n4WQMGRm/lIRcy/+ytunLDm+e8jOW7xfcSayxDmzpAAAAA0QOJ+87lKPIIYR3MxzSzEJJUDLK41Y0QDy6qLO202l4Gp9UXGSxWjuCKhF9z0peIzwNcMUWyGrNE2AYuqUAAAAbd9uHXZaGT2cvhRs7reawctIXtX1s3kTqM9YV+/wCp4zLa+S+r7Oi2P/ekQAXl/f2a+hWHVrYcWpX5BLO40IEDAwMCBwAEBAAAAAUACQMQJwAAAAAAAAQGAAEABgMIAQE=',
+    'close ata builder': 'AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAMFReV5vPklPPaLR9/x+zo6XCwhusWyPAmuEqbgVWvwi0Fv+hKJ+pxZaLwHGEyk2Svp5PfAC5ZEi/wYI1tPTHHhbgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABqfVFxksVo7gioRfc9KXiM8DXDFFshqzRNgGLqlAAAAG3fbh12Whk9nL4UbO63msHLSF7V9bN5E6jPWFfv8AqeMy2vkvq+zotj/3pEAF5f39mvoVh1a2HFqV+QSzuNCBAgIDAQMABAQAAAAEAwEAAAEJ',
+    'staking activate builder': 'AgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAJDEXlebz5JTz2i0ff8fs6OlwsIbrFsjwJrhKm4FVr8ItBYnsvugEnYfm5Gbz5TLtMncgFHZ8JMpkxTTlJIzJovelv+hKJ+pxZaLwHGEyk2Svp5PfAC5ZEi/wYI1tPTHHhbgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwZGb+UhFzL/7K26csOb57yM5bvF9xJrLEObOkAAAACx+Xl4mhxH0TxI2HovJxcQ63+TJglRFzFikL1sKdr12Qah2BeRN1QqmDQ3vf4qerJVf1NcinhyK2ikncAAAAAABqHYF6UCBQtoB5Hmzm24jh5bcVD2H8Z5Ck600QAAAAAGp9UXGMd0yShWY5hpHV62i164o5tLbVxzVVshAAAAAAan1RcZLFaO4IqEX3PSl4jPA1wxRbIas0TYBi6pQAAABqfVFxksXFEhjMlMPUrxf1ja7gibof1E49vZigAAAAAGp9UXGTWE0P7tm7NDHRMga+VEKBtXuFZsxTdf9AAAAOMy2vkvq+zotj/3pEAF5f39mvoVh1a2HFqV+QSzuNCBBQMDAgkABAQAAAAEAAkDECcAAAAAAAADAgABNAAAAADgkwQAAAAAAMgAAAAAAAAABqHYF5E3VCqYNDe9/ip6slV/U1yKeHIraKSdwAAAAAAGAgEKdAAAAABF5Xm8+SU89otH3/H7OjpcLCG6xbI8Ca4SpuBVa/CLQUXlebz5JTz2i0ff8fs6OlwsIbrFsjwJrhKm4FVr8ItBAAAAAAAAAAAAAAAAAAAAAEXlebz5JTz2i0ff8fs6OlwsIbrFsjwJrhKm4FVr8ItBBgYBBQgLBwAEAgAAAA==',
+    'staking deactivate builder': 'AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAUIReV5vPklPPaLR9/x+zo6XCwhusWyPAmuEqbgVWvwi0Fiey+6ASdh+bkZvPlMu0ydyAUdnwkymTFNOUkjMmi96W/6Eon6nFlovAcYTKTZK+nk98ALlkSL/BgjW09MceFuAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADBkZv5SEXMv/srbpyw5vnvIzlu8X3EmssQ5s6QAAAAAah2BeRN1QqmDQ3vf4qerJVf1NcinhyK2ikncAAAAAABqfVFxjHdMkoVmOYaR1etoteuKObS21cc1VbIQAAAAAGp9UXGSxWjuCKhF9z0peIzwNcMUWyGrNE2AYuqUAAAOMy2vkvq+zotj/3pEAF5f39mvoVh1a2HFqV+QSzuNCBAwMDAgcABAQAAAAEAAkDECcAAAAAAAAFAwEGAAQFAAAA',
+    'staking delegate builder': 'AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAgLReV5vPklPPaLR9/x+zo6XCwhusWyPAmuEqbgVWvwi0Fiey+6ASdh+bkZvPlMu0ydyAUdnwkymTFNOUkjMmi96W/6Eon6nFlovAcYTKTZK+nk98ALlkSL/BgjW09MceFuAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADBkZv5SEXMv/srbpyw5vnvIzlu8X3EmssQ5s6QAAAALH5eXiaHEfRPEjYei8nFxDrf5MmCVEXMWKQvWwp2vXZBqHYF5E3VCqYNDe9/ip6slV/U1yKeHIraKSdwAAAAAAGodgXpQIFC2gHkebObbiOHltxUPYfxnkKTrTRAAAAAAan1RcYx3TJKFZjmGkdXraLXrijm0ttXHNVWyEAAAAABqfVFxksVo7gioRfc9KXiM8DXDFFshqzRNgGLqlAAAAGp9UXGTWE0P7tm7NDHRMga+VEKBtXuFZsxTdf9AAAAOMy2vkvq+zotj/3pEAF5f39mvoVh1a2HFqV+QSzuNCBAwMDAgkABAQAAAAEAAkDECcAAAAAAAAGBgEFCAoHAAQCAAAA',
+    'staking withdraw builder': 'AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAYJReV5vPklPPaLR9/x+zo6XCwhusWyPAmuEqbgVWvwi0Fiey+6ASdh+bkZvPlMu0ydyAUdnwkymTFNOUkjMmi96W/6Eon6nFlovAcYTKTZK+nk98ALlkSL/BgjW09MceFuAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADBkZv5SEXMv/srbpyw5vnvIzlu8X3EmssQ5s6QAAAAAah2BeRN1QqmDQ3vf4qerJVf1NcinhyK2ikncAAAAAABqfVFxjHdMkoVmOYaR1etoteuKObS21cc1VbIQAAAAAGp9UXGSxWjuCKhF9z0peIzwNcMUWyGrNE2AYuqUAAAAan1RcZNYTQ/u2bs0MdEyBr5UQoG1e4VmzFN1/0AAAA4zLa+S+r7Oi2P/ekQAXl/f2a+hWHVrYcWpX5BLO40IEDAwMCBwAEBAAAAAQACQMQJwAAAAAAAAUFAQAGCAAMBAAAAOCTBAAAAAAA',
+    'wallet initialization builder': 'AgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgADBUXlebz5JTz2i0ff8fs6OlwsIbrFsjwJrhKm4FVr8ItBb/oSifqcWWi8BxhMpNkr6eT3wAuWRIv8GCNbT0xx4W4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAan1RcZLFaO4IqEX3PSl4jPA1wxRbIas0TYBi6pQAAABqfVFxksXFEhjMlMPUrxf1ja7gibof1E49vZigAAAADjMtr5L6vs6LY/96RABeX9/Zr6FYdWthxalfkEs7jQgQICAgABNAAAAADgkwQAAAAAAFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAwEDBCQGAAAAReV5vPklPPaLR9/x+zo6XCwhusWyPAmuEqbgVWvwi0E=',
+};
+describe('Sol Transaction Builder compute unit limit', () => {
+    const factory = (0, getBuilderFactory_1.getBuilderFactory)('tsol');
+    const authAccount = new src_1.KeyPair(testData.authAccount).getKeys();
+    const nonceAccount = new src_1.KeyPair(testData.nonceAccount).getKeys();
+    const stakeAccount = new src_1.KeyPair(testData.stakeAccount).getKeys();
+    const otherAccount = new src_1.KeyPair({ prv: testData.prvKeys.prvKey1.base58 }).getKeys();
+    const validator = testData.validator;
+    const walletPK = testData.associatedTokenAccounts.accounts[0].pub;
+    const recentBlockHash = 'GHtXQBsoZHVnNFa9YevAzFr17DJjgHXk3ycTKD5xD3Zi';
+    const amount = '300000';
+    const tokenAmount = testData.tokenTransfers.amount.toString();
+    const nameUSDC = testData.tokenTransfers.nameUSDC;
+    const durableNonce = { walletNonceAddress: nonceAccount.pub, authWalletAddress: authAccount.pub };
+    const priorityFee = { amount: 10000 };
+    const computeUnitLimit = 200000;
+    const builderCases = [
+        {
+            name: 'transfer builder',
+            expectedTypes: ['AdvanceNonceAccount', 'SetComputeUnitLimit', 'SetPriorityFee', 'Transfer', 'Memo'],
+            makeBuilder: () => {
+                const txBuilder = factory.getTransferBuilder();
+                txBuilder.nonce(recentBlockHash, durableNonce);
+                txBuilder.sender(authAccount.pub);
+                txBuilder.send({ address: otherAccount.pub, amount });
+                txBuilder.setPriorityFee(priorityFee);
+                txBuilder.memo('test memo');
+                return txBuilder;
+            },
+        },
+        {
+            name: 'transfer builder v2',
+            expectedTypes: ['AdvanceNonceAccount', 'SetComputeUnitLimit', 'SetPriorityFee', 'Transfer'],
+            makeBuilder: () => {
+                const txBuilder = factory.getTransferBuilderV2();
+                txBuilder.nonce(recentBlockHash, durableNonce);
+                txBuilder.sender(authAccount.pub);
+                txBuilder.send({ address: otherAccount.pub, amount });
+                txBuilder.setPriorityFee(priorityFee);
+                return txBuilder;
+            },
+        },
+        {
+            name: 'token transfer builder',
+            expectedTypes: ['AdvanceNonceAccount', 'SetComputeUnitLimit', 'SetPriorityFee', 'TokenTransfer'],
+            makeBuilder: () => {
+                const txBuilder = factory.getTokenTransferBuilder();
+                txBuilder.nonce(recentBlockHash, { walletNonceAddress: nonceAccount.pub, authWalletAddress: walletPK });
+                txBuilder.sender(walletPK);
+                txBuilder.send({ address: otherAccount.pub, amount: tokenAmount, tokenName: nameUSDC });
+                txBuilder.setPriorityFee(priorityFee);
+                return txBuilder;
+            },
+        },
+        {
+            name: 'ata initialization builder',
+            expectedTypes: [
+                'AdvanceNonceAccount',
+                'SetComputeUnitLimit',
+                'SetPriorityFee',
+                'InitializeAssociatedTokenAccount',
+            ],
+            makeBuilder: () => {
+                const txBuilder = factory.getAtaInitializationBuilder();
+                txBuilder.nonce(recentBlockHash, durableNonce);
+                txBuilder.sender(authAccount.pub);
+                txBuilder.mint('tsol:usdc');
+                txBuilder.owner(authAccount.pub);
+                txBuilder.setPriorityFee(priorityFee);
+                return txBuilder;
+            },
+        },
+        {
+            // the close ATA builder does not emit a priority fee instruction
+            name: 'close ata builder',
+            expectedTypes: ['AdvanceNonceAccount', 'SetComputeUnitLimit', 'CloseAssociatedTokenAccount'],
+            makeBuilder: () => {
+                const txBuilder = factory.getCloseAtaInitializationBuilder();
+                txBuilder.nonce(recentBlockHash, durableNonce);
+                txBuilder.sender(authAccount.pub);
+                txBuilder.accountAddress(nonceAccount.pub);
+                txBuilder.destinationAddress(authAccount.pub);
+                txBuilder.authorityAddress(authAccount.pub);
+                return txBuilder;
+            },
+        },
+        {
+            name: 'staking activate builder',
+            expectedTypes: [
+                'AdvanceNonceAccount',
+                'SetComputeUnitLimit',
+                'SetPriorityFee',
+                'Create',
+                'Initialize',
+                'Delegate',
+            ],
+            makeBuilder: () => {
+                const txBuilder = factory.getStakingActivateBuilder();
+                txBuilder.nonce(recentBlockHash, durableNonce);
+                txBuilder.sender(authAccount.pub);
+                txBuilder.stakingAddress(stakeAccount.pub);
+                txBuilder.amount(amount);
+                txBuilder.validator(validator.pub);
+                txBuilder.setPriorityFee(priorityFee);
+                return txBuilder;
+            },
+        },
+        {
+            name: 'staking deactivate builder',
+            expectedTypes: ['AdvanceNonceAccount', 'SetComputeUnitLimit', 'SetPriorityFee', 'Deactivate'],
+            makeBuilder: () => {
+                const txBuilder = factory.getStakingDeactivateBuilder();
+                txBuilder.nonce(recentBlockHash, durableNonce);
+                txBuilder.sender(authAccount.pub);
+                txBuilder.stakingAddress(stakeAccount.pub);
+                txBuilder.setPriorityFee(priorityFee);
+                return txBuilder;
+            },
+        },
+        {
+            name: 'staking delegate builder',
+            expectedTypes: ['AdvanceNonceAccount', 'SetComputeUnitLimit', 'SetPriorityFee', 'Delegate'],
+            makeBuilder: () => {
+                const txBuilder = factory.getStakingDelegateBuilder();
+                txBuilder.nonce(recentBlockHash, durableNonce);
+                txBuilder.sender(authAccount.pub);
+                txBuilder.stakingAddress(stakeAccount.pub);
+                txBuilder.validator(validator.pub);
+                txBuilder.setPriorityFee(priorityFee);
+                return txBuilder;
+            },
+        },
+        {
+            name: 'staking withdraw builder',
+            expectedTypes: ['AdvanceNonceAccount', 'SetComputeUnitLimit', 'SetPriorityFee', 'Withdraw'],
+            makeBuilder: () => {
+                const txBuilder = factory.getStakingWithdrawBuilder();
+                txBuilder.nonce(recentBlockHash, durableNonce);
+                txBuilder.sender(authAccount.pub);
+                txBuilder.stakingAddress(stakeAccount.pub);
+                txBuilder.amount(amount);
+                txBuilder.setPriorityFee(priorityFee);
+                return txBuilder;
+            },
+        },
+        {
+            // the wallet initialization builder is not a sponsored intent, but its parser
+            // accepts leading compute-budget instructions so the tx still classifies and
+            // round trips when a caller sets a limit
+            name: 'wallet initialization builder',
+            expectedTypes: ['SetComputeUnitLimit', 'Create', 'InitializeNonceAccount'],
+            makeBuilder: () => {
+                const txBuilder = factory.getWalletInitializationBuilder();
+                txBuilder.nonce(recentBlockHash);
+                txBuilder.sender(authAccount.pub);
+                txBuilder.address(nonceAccount.pub);
+                txBuilder.amount('300000');
+                return txBuilder;
+            },
+        },
+    ];
+    describe('setComputeUnitLimit validation', () => {
+        it('rejects limits that are not integers between 1 and 1,400,000', () => {
+            const txBuilder = factory.getTransferBuilder();
+            for (const invalid of [0, -1, 1.5, 1400001, NaN]) {
+                (0, should_1.default)(() => txBuilder.setComputeUnitLimit(invalid)).throwError(`Invalid compute unit limit, expected an integer between 1 and 1400000, got: ${invalid}`);
+            }
+        });
+        it('accepts the boundary limits 1 and 1,400,000', () => {
+            const txBuilder = factory.getTransferBuilder();
+            should_1.default.doesNotThrow(() => txBuilder.setComputeUnitLimit(1));
+            should_1.default.doesNotThrow(() => txBuilder.setComputeUnitLimit(1400000));
+        });
+    });
+    for (const { name, expectedTypes, makeBuilder } of builderCases) {
+        describe(name, () => {
+            it('builds [AdvanceNonce, SetComputeUnitLimit, SetComputeUnitPrice, ...] with a limit', async () => {
+                const tx = (await makeBuilder().setComputeUnitLimit(computeUnitLimit).build());
+                compiledInstructionTypes(tx).should.deepEqual(expectedTypes);
+                computeUnitLimits(tx).should.deepEqual([computeUnitLimit]);
+                // the instruction is recorded for explain and parsing, exactly once
+                tx.toJson()
+                    .instructionsData.filter((instruction) => instruction.type === 'SetComputeUnitLimit')
+                    .should.deepEqual([{ type: 'SetComputeUnitLimit', params: { units: computeUnitLimit } }]);
+            });
+            it('rebuilds byte-identically from raw and preserves the limit', async () => {
+                const tx = (await makeBuilder().setComputeUnitLimit(computeUnitLimit).build());
+                const rawTx = tx.toBroadcastFormat();
+                const rebuiltBuilder = factory.from(rawTx);
+                const restoredLimit = rebuiltBuilder._computeUnitLimit;
+                should_1.default.equal(restoredLimit, computeUnitLimit);
+                const rebuiltTx = (await rebuiltBuilder.build());
+                // the signing-phase rebuild must be byte-identical and keep exactly one
+                // SetComputeUnitLimit instruction with the original limit
+                rebuiltTx.toBroadcastFormat().should.equal(rawTx);
+                computeUnitLimits(rebuiltTx).should.deepEqual([computeUnitLimit]);
+            });
+            it('does not duplicate the instruction when the same builder builds twice', async () => {
+                const txBuilder = makeBuilder().setComputeUnitLimit(computeUnitLimit);
+                await txBuilder.build();
+                const rebuiltTx = (await txBuilder.build());
+                computeUnitLimits(rebuiltTx).should.deepEqual([computeUnitLimit]);
+                rebuiltTx
+                    .toJson()
+                    .instructionsData.filter((instruction) => instruction.type === 'SetComputeUnitLimit')
+                    .should.deepEqual([{ type: 'SetComputeUnitLimit', params: { units: computeUnitLimit } }]);
+            });
+            it('leaves the transaction bytes unchanged without a limit', async () => {
+                const tx = (await makeBuilder().build());
+                tx.toBroadcastFormat().should.equal(RAW_TX_WITHOUT_COMPUTE_UNIT_LIMIT[name]);
+            });
+        });
+    }
+    describe('instruction order variants', () => {
+        it('places the limit first when no durable nonce is used', async () => {
+            const txBuilder = factory.getTransferBuilder();
+            txBuilder.nonce(recentBlockHash);
+            txBuilder.sender(authAccount.pub);
+            txBuilder.send({ address: otherAccount.pub, amount });
+            txBuilder.setPriorityFee(priorityFee);
+            txBuilder.setComputeUnitLimit(computeUnitLimit);
+            const tx = (await txBuilder.build());
+            compiledInstructionTypes(tx).should.deepEqual(['SetComputeUnitLimit', 'SetPriorityFee', 'Transfer']);
+        });
+        it('places the limit before the transfer when no priority fee is used', async () => {
+            const txBuilder = factory.getTransferBuilder();
+            txBuilder.nonce(recentBlockHash, durableNonce);
+            txBuilder.sender(authAccount.pub);
+            txBuilder.send({ address: otherAccount.pub, amount });
+            txBuilder.setComputeUnitLimit(computeUnitLimit);
+            const tx = (await txBuilder.build());
+            compiledInstructionTypes(tx).should.deepEqual(['AdvanceNonceAccount', 'SetComputeUnitLimit', 'Transfer']);
+        });
+    });
+    describe('signed rebuild', () => {
+        it('rebuilds a signed transaction byte-identically from raw with the limit', async () => {
+            const txBuilder = factory.getTransferBuilder();
+            txBuilder.nonce(recentBlockHash, durableNonce);
+            txBuilder.sender(authAccount.pub);
+            txBuilder.send({ address: otherAccount.pub, amount });
+            txBuilder.setPriorityFee(priorityFee);
+            txBuilder.setComputeUnitLimit(computeUnitLimit);
+            txBuilder.sign({ key: authAccount.prv });
+            const tx = (await txBuilder.build());
+            const rawTx = tx.toBroadcastFormat();
+            const rebuiltTx = (await factory.from(rawTx).build());
+            rebuiltTx.toBroadcastFormat().should.equal(rawTx);
+            computeUnitLimits(rebuiltTx).should.deepEqual([computeUnitLimit]);
+            rebuiltTx.signature.should.deepEqual(tx.signature);
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"computeUnitLimit.js","sourceRoot":"","sources":["../../../../../test/unit/transactionBuilder/computeUnitLimit.ts"],"names":[],"mappings":"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","sourcesContent":["import should from 'should';\nimport * as bs58 from 'bs58';\nimport { getBuilderFactory } from '../getBuilderFactory';\nimport { KeyPair, Utils, Transaction } from '../../../src';\nimport * as testData from '../../resources/sol';\nimport { ComputeBudgetInstruction, TransactionInstruction } from '@solana/web3.js';\nimport { TransactionBuilder } from '../../../src/lib/transactionBuilder';\n\nconst COMPUTE_BUDGET_PROGRAM_ID = 'ComputeBudget111111111111111111111111111111';\n\n/**\n * Returns the on-chain instruction types of a built transaction in the order they appear\n * in the compiled message, which is what the network executes. The compiled message\n * includes the durable-nonce AdvanceNonceAccount instruction that web3.js serializes\n * first, so a sponsored transaction with a compute unit limit, priority fee and durable\n * nonce starts with [AdvanceNonceAccount, SetComputeUnitLimit, SetPriorityFee, ...].\n */\nfunction compiledInstructionTypes(tx: Transaction): string[] {\n  const message = tx.solTransaction.compileMessage();\n  return message.instructions.map((compiledInstruction) => {\n    const instruction = new TransactionInstruction({\n      programId: message.accountKeys[compiledInstruction.programIdIndex],\n      keys: compiledInstruction.accounts.map((accountKeyIndex) => ({\n        pubkey: message.accountKeys[accountKeyIndex],\n        isSigner: message.isAccountSigner(accountKeyIndex),\n        isWritable: message.isAccountWritable(accountKeyIndex),\n      })),\n      data: Buffer.from(bs58.decode(compiledInstruction.data)),\n    });\n    return Utils.getInstructionType(instruction) as string;\n  });\n}\n\n/**\n * Returns the compute-unit limits requested by the SetComputeUnitLimit instructions of\n * the built transaction.\n */\nfunction computeUnitLimits(tx: Transaction): number[] {\n  return tx.solTransaction.instructions\n    .filter(\n      (instruction) =>\n        instruction.programId.toString() === COMPUTE_BUDGET_PROGRAM_ID &&\n        Utils.getInstructionType(instruction) === 'SetComputeUnitLimit'\n    )\n    .map((instruction) => ComputeBudgetInstruction.decodeSetComputeUnitLimit(instruction).units);\n}\n\n/**\n * Raw transaction bytes of each builder intent below when no compute unit limit is set.\n * Captured from the builders before the compute-unit-limit work, so any change to the\n * no-limit build path (which must stay byte-identical) fails these comparisons.\n */\nconst RAW_TX_WITHOUT_COMPUTE_UNIT_LIMIT: Record<string, string> = {\n  'transfer builder':\n    'AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAQHReV5vPklPPaLR9/x+zo6XCwhusWyPAmuEqbgVWvwi0Fv+hKJ+pxZaLwHGEyk2Svp5PfAC5ZEi/wYI1tPTHHhbqkYG1L37ZDq6w2tS3G+tFODYWdhMXF+kwlYEF+3o4nVAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADBkZv5SEXMv/srbpyw5vnvIzlu8X3EmssQ5s6QAAAAAVKU1qZKSEGTSTocWDaOHx8NbXdvJK7geQfqEBBBUSNBqfVFxksVo7gioRfc9KXiM8DXDFFshqzRNgGLqlAAADjMtr5L6vs6LY/96RABeX9/Zr6FYdWthxalfkEs7jQgQQDAwEGAAQEAAAABAAJAxAnAAAAAAAAAwIAAgwCAAAA4JMEAAAAAAAFAAl0ZXN0IG1lbW8=',\n  'transfer builder v2':\n    'AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAMGReV5vPklPPaLR9/x+zo6XCwhusWyPAmuEqbgVWvwi0Fv+hKJ+pxZaLwHGEyk2Svp5PfAC5ZEi/wYI1tPTHHhbqkYG1L37ZDq6w2tS3G+tFODYWdhMXF+kwlYEF+3o4nVAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADBkZv5SEXMv/srbpyw5vnvIzlu8X3EmssQ5s6QAAAAAan1RcZLFaO4IqEX3PSl4jPA1wxRbIas0TYBi6pQAAA4zLa+S+r7Oi2P/ekQAXl/f2a+hWHVrYcWpX5BLO40IEDAwMBBQAEBAAAAAQACQMQJwAAAAAAAAMCAAIMAgAAAOCTBAAAAAAA',\n  'token transfer builder':\n    'AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAUJAGymKVqOJEQemBHH67uu8ISJV4rtwTejLrjw7VSeW6dv+hKJ+pxZaLwHGEyk2Svp5PfAC5ZEi/wYI1tPTHHhbpXS8VwMObd6fTnfCKrnxvwQ5LFhipVbiG+aiTNM1eFsqRgbUvftkOrrDa1Lcb60U4NhZ2ExcX6TCVgQX7ejidUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMGRm/lIRcy/+ytunLDm+e8jOW7xfcSayxDmzpAAAAA0QOJ+87lKPIIYR3MxzSzEJJUDLK41Y0QDy6qLO202l4Gp9UXGSxWjuCKhF9z0peIzwNcMUWyGrNE2AYuqUAAAAbd9uHXZaGT2cvhRs7reawctIXtX1s3kTqM9YV+/wCp4zLa+S+r7Oi2P/ekQAXl/f2a+hWHVrYcWpX5BLO40IEDBAMBBwAEBAAAAAUACQMQJwAAAAAAAAgEAgYDAAoM4JMEAAAAAAAJ',\n  'ata initialization builder':\n    'AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAYJReV5vPklPPaLR9/x+zo6XCwhusWyPAmuEqbgVWvwi0EAxPE0fqi8zYGKbihafYdJgknwg8wIfK86jxD3ILOvGW/6Eon6nFlovAcYTKTZK+nk98ALlkSL/BgjW09MceFuAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACMlyWPTiSJ8bs9ECkUjg2DC1oTmdr/EIQEjnvY2+n4WQMGRm/lIRcy/+ytunLDm+e8jOW7xfcSayxDmzpAAAAA0QOJ+87lKPIIYR3MxzSzEJJUDLK41Y0QDy6qLO202l4Gp9UXGSxWjuCKhF9z0peIzwNcMUWyGrNE2AYuqUAAAAbd9uHXZaGT2cvhRs7reawctIXtX1s3kTqM9YV+/wCp4zLa+S+r7Oi2P/ekQAXl/f2a+hWHVrYcWpX5BLO40IEDAwMCBwAEBAAAAAUACQMQJwAAAAAAAAQGAAEABgMIAQE=',\n  'close ata builder':\n    'AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAMFReV5vPklPPaLR9/x+zo6XCwhusWyPAmuEqbgVWvwi0Fv+hKJ+pxZaLwHGEyk2Svp5PfAC5ZEi/wYI1tPTHHhbgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABqfVFxksVo7gioRfc9KXiM8DXDFFshqzRNgGLqlAAAAG3fbh12Whk9nL4UbO63msHLSF7V9bN5E6jPWFfv8AqeMy2vkvq+zotj/3pEAF5f39mvoVh1a2HFqV+QSzuNCBAgIDAQMABAQAAAAEAwEAAAEJ',\n  'staking activate builder':\n    'AgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAJDEXlebz5JTz2i0ff8fs6OlwsIbrFsjwJrhKm4FVr8ItBYnsvugEnYfm5Gbz5TLtMncgFHZ8JMpkxTTlJIzJovelv+hKJ+pxZaLwHGEyk2Svp5PfAC5ZEi/wYI1tPTHHhbgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwZGb+UhFzL/7K26csOb57yM5bvF9xJrLEObOkAAAACx+Xl4mhxH0TxI2HovJxcQ63+TJglRFzFikL1sKdr12Qah2BeRN1QqmDQ3vf4qerJVf1NcinhyK2ikncAAAAAABqHYF6UCBQtoB5Hmzm24jh5bcVD2H8Z5Ck600QAAAAAGp9UXGMd0yShWY5hpHV62i164o5tLbVxzVVshAAAAAAan1RcZLFaO4IqEX3PSl4jPA1wxRbIas0TYBi6pQAAABqfVFxksXFEhjMlMPUrxf1ja7gibof1E49vZigAAAAAGp9UXGTWE0P7tm7NDHRMga+VEKBtXuFZsxTdf9AAAAOMy2vkvq+zotj/3pEAF5f39mvoVh1a2HFqV+QSzuNCBBQMDAgkABAQAAAAEAAkDECcAAAAAAAADAgABNAAAAADgkwQAAAAAAMgAAAAAAAAABqHYF5E3VCqYNDe9/ip6slV/U1yKeHIraKSdwAAAAAAGAgEKdAAAAABF5Xm8+SU89otH3/H7OjpcLCG6xbI8Ca4SpuBVa/CLQUXlebz5JTz2i0ff8fs6OlwsIbrFsjwJrhKm4FVr8ItBAAAAAAAAAAAAAAAAAAAAAEXlebz5JTz2i0ff8fs6OlwsIbrFsjwJrhKm4FVr8ItBBgYBBQgLBwAEAgAAAA==',\n  'staking deactivate builder':\n    'AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAUIReV5vPklPPaLR9/x+zo6XCwhusWyPAmuEqbgVWvwi0Fiey+6ASdh+bkZvPlMu0ydyAUdnwkymTFNOUkjMmi96W/6Eon6nFlovAcYTKTZK+nk98ALlkSL/BgjW09MceFuAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADBkZv5SEXMv/srbpyw5vnvIzlu8X3EmssQ5s6QAAAAAah2BeRN1QqmDQ3vf4qerJVf1NcinhyK2ikncAAAAAABqfVFxjHdMkoVmOYaR1etoteuKObS21cc1VbIQAAAAAGp9UXGSxWjuCKhF9z0peIzwNcMUWyGrNE2AYuqUAAAOMy2vkvq+zotj/3pEAF5f39mvoVh1a2HFqV+QSzuNCBAwMDAgcABAQAAAAEAAkDECcAAAAAAAAFAwEGAAQFAAAA',\n  'staking delegate builder':\n    'AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAgLReV5vPklPPaLR9/x+zo6XCwhusWyPAmuEqbgVWvwi0Fiey+6ASdh+bkZvPlMu0ydyAUdnwkymTFNOUkjMmi96W/6Eon6nFlovAcYTKTZK+nk98ALlkSL/BgjW09MceFuAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADBkZv5SEXMv/srbpyw5vnvIzlu8X3EmssQ5s6QAAAALH5eXiaHEfRPEjYei8nFxDrf5MmCVEXMWKQvWwp2vXZBqHYF5E3VCqYNDe9/ip6slV/U1yKeHIraKSdwAAAAAAGodgXpQIFC2gHkebObbiOHltxUPYfxnkKTrTRAAAAAAan1RcYx3TJKFZjmGkdXraLXrijm0ttXHNVWyEAAAAABqfVFxksVo7gioRfc9KXiM8DXDFFshqzRNgGLqlAAAAGp9UXGTWE0P7tm7NDHRMga+VEKBtXuFZsxTdf9AAAAOMy2vkvq+zotj/3pEAF5f39mvoVh1a2HFqV+QSzuNCBAwMDAgkABAQAAAAEAAkDECcAAAAAAAAGBgEFCAoHAAQCAAAA',\n  'staking withdraw builder':\n    'AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAYJReV5vPklPPaLR9/x+zo6XCwhusWyPAmuEqbgVWvwi0Fiey+6ASdh+bkZvPlMu0ydyAUdnwkymTFNOUkjMmi96W/6Eon6nFlovAcYTKTZK+nk98ALlkSL/BgjW09MceFuAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADBkZv5SEXMv/srbpyw5vnvIzlu8X3EmssQ5s6QAAAAAah2BeRN1QqmDQ3vf4qerJVf1NcinhyK2ikncAAAAAABqfVFxjHdMkoVmOYaR1etoteuKObS21cc1VbIQAAAAAGp9UXGSxWjuCKhF9z0peIzwNcMUWyGrNE2AYuqUAAAAan1RcZNYTQ/u2bs0MdEyBr5UQoG1e4VmzFN1/0AAAA4zLa+S+r7Oi2P/ekQAXl/f2a+hWHVrYcWpX5BLO40IEDAwMCBwAEBAAAAAQACQMQJwAAAAAAAAUFAQAGCAAMBAAAAOCTBAAAAAAA',\n  'wallet initialization builder':\n    'AgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgADBUXlebz5JTz2i0ff8fs6OlwsIbrFsjwJrhKm4FVr8ItBb/oSifqcWWi8BxhMpNkr6eT3wAuWRIv8GCNbT0xx4W4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAan1RcZLFaO4IqEX3PSl4jPA1wxRbIas0TYBi6pQAAABqfVFxksXFEhjMlMPUrxf1ja7gibof1E49vZigAAAADjMtr5L6vs6LY/96RABeX9/Zr6FYdWthxalfkEs7jQgQICAgABNAAAAADgkwQAAAAAAFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAwEDBCQGAAAAReV5vPklPPaLR9/x+zo6XCwhusWyPAmuEqbgVWvwi0E=',\n};\n\ndescribe('Sol Transaction Builder compute unit limit', () => {\n  const factory = getBuilderFactory('tsol');\n  const authAccount = new KeyPair(testData.authAccount).getKeys();\n  const nonceAccount = new KeyPair(testData.nonceAccount).getKeys();\n  const stakeAccount = new KeyPair(testData.stakeAccount).getKeys();\n  const otherAccount = new KeyPair({ prv: testData.prvKeys.prvKey1.base58 }).getKeys();\n  const validator = testData.validator;\n  const walletPK = testData.associatedTokenAccounts.accounts[0].pub;\n  const recentBlockHash = 'GHtXQBsoZHVnNFa9YevAzFr17DJjgHXk3ycTKD5xD3Zi';\n  const amount = '300000';\n  const tokenAmount = testData.tokenTransfers.amount.toString();\n  const nameUSDC = testData.tokenTransfers.nameUSDC;\n  const durableNonce = { walletNonceAddress: nonceAccount.pub, authWalletAddress: authAccount.pub };\n  const priorityFee = { amount: 10000 };\n  const computeUnitLimit = 200000;\n\n  interface BuilderCase {\n    name: string;\n    /** expected compiled instruction types of the built transaction, in order */\n    expectedTypes: string[];\n    makeBuilder: () => TransactionBuilder;\n  }\n\n  const builderCases: BuilderCase[] = [\n    {\n      name: 'transfer builder',\n      expectedTypes: ['AdvanceNonceAccount', 'SetComputeUnitLimit', 'SetPriorityFee', 'Transfer', 'Memo'],\n      makeBuilder: () => {\n        const txBuilder = factory.getTransferBuilder();\n        txBuilder.nonce(recentBlockHash, durableNonce);\n        txBuilder.sender(authAccount.pub);\n        txBuilder.send({ address: otherAccount.pub, amount });\n        txBuilder.setPriorityFee(priorityFee);\n        txBuilder.memo('test memo');\n        return txBuilder;\n      },\n    },\n    {\n      name: 'transfer builder v2',\n      expectedTypes: ['AdvanceNonceAccount', 'SetComputeUnitLimit', 'SetPriorityFee', 'Transfer'],\n      makeBuilder: () => {\n        const txBuilder = factory.getTransferBuilderV2();\n        txBuilder.nonce(recentBlockHash, durableNonce);\n        txBuilder.sender(authAccount.pub);\n        txBuilder.send({ address: otherAccount.pub, amount });\n        txBuilder.setPriorityFee(priorityFee);\n        return txBuilder;\n      },\n    },\n    {\n      name: 'token transfer builder',\n      expectedTypes: ['AdvanceNonceAccount', 'SetComputeUnitLimit', 'SetPriorityFee', 'TokenTransfer'],\n      makeBuilder: () => {\n        const txBuilder = factory.getTokenTransferBuilder();\n        txBuilder.nonce(recentBlockHash, { walletNonceAddress: nonceAccount.pub, authWalletAddress: walletPK });\n        txBuilder.sender(walletPK);\n        txBuilder.send({ address: otherAccount.pub, amount: tokenAmount, tokenName: nameUSDC });\n        txBuilder.setPriorityFee(priorityFee);\n        return txBuilder;\n      },\n    },\n    {\n      name: 'ata initialization builder',\n      expectedTypes: [\n        'AdvanceNonceAccount',\n        'SetComputeUnitLimit',\n        'SetPriorityFee',\n        'InitializeAssociatedTokenAccount',\n      ],\n      makeBuilder: () => {\n        const txBuilder = factory.getAtaInitializationBuilder();\n        txBuilder.nonce(recentBlockHash, durableNonce);\n        txBuilder.sender(authAccount.pub);\n        txBuilder.mint('tsol:usdc');\n        txBuilder.owner(authAccount.pub);\n        txBuilder.setPriorityFee(priorityFee);\n        return txBuilder;\n      },\n    },\n    {\n      // the close ATA builder does not emit a priority fee instruction\n      name: 'close ata builder',\n      expectedTypes: ['AdvanceNonceAccount', 'SetComputeUnitLimit', 'CloseAssociatedTokenAccount'],\n      makeBuilder: () => {\n        const txBuilder = factory.getCloseAtaInitializationBuilder();\n        txBuilder.nonce(recentBlockHash, durableNonce);\n        txBuilder.sender(authAccount.pub);\n        txBuilder.accountAddress(nonceAccount.pub);\n        txBuilder.destinationAddress(authAccount.pub);\n        txBuilder.authorityAddress(authAccount.pub);\n        return txBuilder;\n      },\n    },\n    {\n      name: 'staking activate builder',\n      expectedTypes: [\n        'AdvanceNonceAccount',\n        'SetComputeUnitLimit',\n        'SetPriorityFee',\n        'Create',\n        'Initialize',\n        'Delegate',\n      ],\n      makeBuilder: () => {\n        const txBuilder = factory.getStakingActivateBuilder();\n        txBuilder.nonce(recentBlockHash, durableNonce);\n        txBuilder.sender(authAccount.pub);\n        txBuilder.stakingAddress(stakeAccount.pub);\n        txBuilder.amount(amount);\n        txBuilder.validator(validator.pub);\n        txBuilder.setPriorityFee(priorityFee);\n        return txBuilder;\n      },\n    },\n    {\n      name: 'staking deactivate builder',\n      expectedTypes: ['AdvanceNonceAccount', 'SetComputeUnitLimit', 'SetPriorityFee', 'Deactivate'],\n      makeBuilder: () => {\n        const txBuilder = factory.getStakingDeactivateBuilder();\n        txBuilder.nonce(recentBlockHash, durableNonce);\n        txBuilder.sender(authAccount.pub);\n        txBuilder.stakingAddress(stakeAccount.pub);\n        txBuilder.setPriorityFee(priorityFee);\n        return txBuilder;\n      },\n    },\n    {\n      name: 'staking delegate builder',\n      expectedTypes: ['AdvanceNonceAccount', 'SetComputeUnitLimit', 'SetPriorityFee', 'Delegate'],\n      makeBuilder: () => {\n        const txBuilder = factory.getStakingDelegateBuilder();\n        txBuilder.nonce(recentBlockHash, durableNonce);\n        txBuilder.sender(authAccount.pub);\n        txBuilder.stakingAddress(stakeAccount.pub);\n        txBuilder.validator(validator.pub);\n        txBuilder.setPriorityFee(priorityFee);\n        return txBuilder;\n      },\n    },\n    {\n      name: 'staking withdraw builder',\n      expectedTypes: ['AdvanceNonceAccount', 'SetComputeUnitLimit', 'SetPriorityFee', 'Withdraw'],\n      makeBuilder: () => {\n        const txBuilder = factory.getStakingWithdrawBuilder();\n        txBuilder.nonce(recentBlockHash, durableNonce);\n        txBuilder.sender(authAccount.pub);\n        txBuilder.stakingAddress(stakeAccount.pub);\n        txBuilder.amount(amount);\n        txBuilder.setPriorityFee(priorityFee);\n        return txBuilder;\n      },\n    },\n    {\n      // the wallet initialization builder is not a sponsored intent, but its parser\n      // accepts leading compute-budget instructions so the tx still classifies and\n      // round trips when a caller sets a limit\n      name: 'wallet initialization builder',\n      expectedTypes: ['SetComputeUnitLimit', 'Create', 'InitializeNonceAccount'],\n      makeBuilder: () => {\n        const txBuilder = factory.getWalletInitializationBuilder();\n        txBuilder.nonce(recentBlockHash);\n        txBuilder.sender(authAccount.pub);\n        txBuilder.address(nonceAccount.pub);\n        txBuilder.amount('300000');\n        return txBuilder;\n      },\n    },\n  ];\n\n  describe('setComputeUnitLimit validation', () => {\n    it('rejects limits that are not integers between 1 and 1,400,000', () => {\n      const txBuilder = factory.getTransferBuilder();\n      for (const invalid of [0, -1, 1.5, 1400001, NaN]) {\n        should(() => txBuilder.setComputeUnitLimit(invalid)).throwError(\n          `Invalid compute unit limit, expected an integer between 1 and 1400000, got: ${invalid}`\n        );\n      }\n    });\n\n    it('accepts the boundary limits 1 and 1,400,000', () => {\n      const txBuilder = factory.getTransferBuilder();\n      should.doesNotThrow(() => txBuilder.setComputeUnitLimit(1));\n      should.doesNotThrow(() => txBuilder.setComputeUnitLimit(1400000));\n    });\n  });\n\n  for (const { name, expectedTypes, makeBuilder } of builderCases) {\n    describe(name, () => {\n      it('builds [AdvanceNonce, SetComputeUnitLimit, SetComputeUnitPrice, ...] with a limit', async () => {\n        const tx = (await makeBuilder().setComputeUnitLimit(computeUnitLimit).build()) as Transaction;\n\n        compiledInstructionTypes(tx).should.deepEqual(expectedTypes);\n        computeUnitLimits(tx).should.deepEqual([computeUnitLimit]);\n        // the instruction is recorded for explain and parsing, exactly once\n        tx.toJson()\n          .instructionsData.filter((instruction) => instruction.type === 'SetComputeUnitLimit')\n          .should.deepEqual([{ type: 'SetComputeUnitLimit', params: { units: computeUnitLimit } }]);\n      });\n\n      it('rebuilds byte-identically from raw and preserves the limit', async () => {\n        const tx = (await makeBuilder().setComputeUnitLimit(computeUnitLimit).build()) as Transaction;\n        const rawTx = tx.toBroadcastFormat();\n\n        const rebuiltBuilder = factory.from(rawTx);\n        const restoredLimit = (rebuiltBuilder as unknown as { _computeUnitLimit?: number })._computeUnitLimit;\n        should.equal(restoredLimit, computeUnitLimit);\n\n        const rebuiltTx = (await rebuiltBuilder.build()) as Transaction;\n        // the signing-phase rebuild must be byte-identical and keep exactly one\n        // SetComputeUnitLimit instruction with the original limit\n        rebuiltTx.toBroadcastFormat().should.equal(rawTx);\n        computeUnitLimits(rebuiltTx).should.deepEqual([computeUnitLimit]);\n      });\n\n      it('does not duplicate the instruction when the same builder builds twice', async () => {\n        const txBuilder = makeBuilder().setComputeUnitLimit(computeUnitLimit);\n        await txBuilder.build();\n        const rebuiltTx = (await txBuilder.build()) as Transaction;\n\n        computeUnitLimits(rebuiltTx).should.deepEqual([computeUnitLimit]);\n        rebuiltTx\n          .toJson()\n          .instructionsData.filter((instruction) => instruction.type === 'SetComputeUnitLimit')\n          .should.deepEqual([{ type: 'SetComputeUnitLimit', params: { units: computeUnitLimit } }]);\n      });\n\n      it('leaves the transaction bytes unchanged without a limit', async () => {\n        const tx = (await makeBuilder().build()) as Transaction;\n        tx.toBroadcastFormat().should.equal(RAW_TX_WITHOUT_COMPUTE_UNIT_LIMIT[name]);\n      });\n    });\n  }\n\n  describe('instruction order variants', () => {\n    it('places the limit first when no durable nonce is used', async () => {\n      const txBuilder = factory.getTransferBuilder();\n      txBuilder.nonce(recentBlockHash);\n      txBuilder.sender(authAccount.pub);\n      txBuilder.send({ address: otherAccount.pub, amount });\n      txBuilder.setPriorityFee(priorityFee);\n      txBuilder.setComputeUnitLimit(computeUnitLimit);\n      const tx = (await txBuilder.build()) as Transaction;\n\n      compiledInstructionTypes(tx).should.deepEqual(['SetComputeUnitLimit', 'SetPriorityFee', 'Transfer']);\n    });\n\n    it('places the limit before the transfer when no priority fee is used', async () => {\n      const txBuilder = factory.getTransferBuilder();\n      txBuilder.nonce(recentBlockHash, durableNonce);\n      txBuilder.sender(authAccount.pub);\n      txBuilder.send({ address: otherAccount.pub, amount });\n      txBuilder.setComputeUnitLimit(computeUnitLimit);\n      const tx = (await txBuilder.build()) as Transaction;\n\n      compiledInstructionTypes(tx).should.deepEqual(['AdvanceNonceAccount', 'SetComputeUnitLimit', 'Transfer']);\n    });\n  });\n\n  describe('signed rebuild', () => {\n    it('rebuilds a signed transaction byte-identically from raw with the limit', async () => {\n      const txBuilder = factory.getTransferBuilder();\n      txBuilder.nonce(recentBlockHash, durableNonce);\n      txBuilder.sender(authAccount.pub);\n      txBuilder.send({ address: otherAccount.pub, amount });\n      txBuilder.setPriorityFee(priorityFee);\n      txBuilder.setComputeUnitLimit(computeUnitLimit);\n      txBuilder.sign({ key: authAccount.prv });\n      const tx = (await txBuilder.build()) as Transaction;\n      const rawTx = tx.toBroadcastFormat();\n\n      const rebuiltTx = (await factory.from(rawTx).build()) as Transaction;\n      rebuiltTx.toBroadcastFormat().should.equal(rawTx);\n      computeUnitLimits(rebuiltTx).should.deepEqual([computeUnitLimit]);\n      rebuiltTx.signature.should.deepEqual(tx.signature);\n    });\n  });\n});\n"]}

package/dist/cjs/test/unit/transactionBuilder/confidentialEnablementV1.d.ts

@@ -0,0 +1,2 @@
+import 'should';
+//# sourceMappingURL=confidentialEnablementV1.d.ts.map

package/dist/cjs/test/unit/transactionBuilder/confidentialEnablementV1.d.ts.map

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

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

@@ -0,0 +1,124 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+require("should");
+const src_1 = require("../../../src");
+const testData = __importStar(require("../../resources/sol"));
+const spl_token_1 = require("@solana/spl-token");
+const getBuilderFactory_1 = require("../getBuilderFactory");
+describe('Solana Confidential Transfer Builder - CT account enablement (v1)', () => {
+    const factory = (0, getBuilderFactory_1.getBuilderFactory)('sol');
+    const account = new src_1.KeyPair(testData.associatedTokenAccounts.accounts[0]).getKeys();
+    const recentBlockHash = 'GHtXQBsoZHVnNFa9YevAzFr17DJjgHXk3ycTKD5xD3Zi';
+    const mintAddress = testData.associatedTokenAccountsForSol2022.mintId;
+    const tokenAddress = testData.associatedTokenAccountsForSol2022.accounts[0].ata;
+    const authorityAddress = account.pub;
+    const zeroBytes36 = '00'.repeat(36);
+    const proofDataHex = '00'.repeat(320);
+    const v1Config = {
+        computeUnitLimit: 200000,
+        heapSize: 32768,
+        loadedAccountsDataSizeLimit: 65536,
+        priorityFee: 5000,
+    };
+    const ctEnablementBuilder = () => {
+        const txBuilder = factory.getConfidentialTransferBuilder();
+        txBuilder.nonce(recentBlockHash);
+        txBuilder.sender(account.pub);
+        txBuilder.sign({ key: account.prv });
+        return txBuilder;
+    };
+    const addEnablementInstructions = (builder) => {
+        builder
+            .createAta({
+            mintAddress,
+            ataAddress: tokenAddress,
+            ownerAddress: authorityAddress,
+            payerAddress: account.pub,
+            tokenName: 'tsol:ray',
+            // CT mints are Token-2022 — the ATA must be created under the Token-2022 program
+            programId: 'TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb',
+        })
+            .configureAccount({
+            tokenAddress,
+            mintAddress,
+            authorityAddress,
+            elgamalPubkey: '11'.repeat(32),
+            decryptableZeroBalance: zeroBytes36,
+            maximumPendingBalanceCreditCounter: '18446744073709551615',
+            proofInstructionOffset: 1,
+        })
+            .verifyPubkeyValidity({ proofData: proofDataHex });
+    };
+    it('should build a v1 CT enablement transaction (CreateATA + ConfigureAccount + VerifyPubkeyValidity)', async function () {
+        const builder = ctEnablementBuilder();
+        addEnablementInstructions(builder);
+        builder.version(1).transactionConfig(v1Config);
+        const tx = await builder.build();
+        tx.isVersionedTransaction().should.equal(true);
+        const rawTx = tx.toBroadcastFormat();
+        const wire = Buffer.from(rawTx, 'base64');
+        // v1 version byte prefix
+        wire[0].should.equal(0x81);
+        // within the v1 wire size limit
+        wire.length.should.be.lessThanOrEqual(4096);
+        // metadata transaction carries all four instructions in order:
+        // CreateATA -> Reallocate (ConfidentialTransferAccount) -> ConfigureAccount -> Verify
+        const solTx = tx.solTransaction;
+        solTx.instructions.length.should.equal(4);
+        solTx.instructions[0].data[0].should.equal(1 /* ATA program CreateIdempotent discriminator */);
+        solTx.instructions[1].programId.toString().should.equal(spl_token_1.TOKEN_2022_PROGRAM_ID.toString());
+        solTx.instructions[1].data[0].should.equal(spl_token_1.TokenInstruction.Reallocate);
+        solTx.instructions[2].programId.toString().should.equal(spl_token_1.TOKEN_2022_PROGRAM_ID.toString());
+    });
+    it('should keep instruction order stable (no ApplyPendingBalance reordering concern)', async function () {
+        const builder = ctEnablementBuilder();
+        addEnablementInstructions(builder);
+        builder.version(1).transactionConfig(v1Config);
+        const tx = await builder.build();
+        const json = tx.toJson();
+        json.instructionsData.length.should.equal(4);
+        json.instructionsData[0].type.should.equal('CreateAssociatedTokenAccount');
+        // Reallocate is a Token-2022 extension instruction, surfaced as a custom instruction
+        json.instructionsData[1].type.should.equal('ReallocateConfidentialTransferAccount');
+        json.instructionsData[2].type.should.equal('ConfigureConfidentialTransferAccount');
+    });
+    it('should require at least one CT/ATA instruction', async function () {
+        const builder = ctEnablementBuilder();
+        builder.version(1).transactionConfig(v1Config);
+        await builder.build().should.be.rejectedWith(/At least one confidential transfer instruction/);
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"confidentialEnablementV1.js","sourceRoot":"","sources":["../../../../../test/unit/transactionBuilder/confidentialEnablementV1.ts"],"names":[],"mappings":"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","sourcesContent":["import 'should';\nimport { ConfidentialTransferBuilder, KeyPair, Transaction } from '../../../src';\nimport * as testData from '../../resources/sol';\nimport { TOKEN_2022_PROGRAM_ID, TokenInstruction } from '@solana/spl-token';\nimport { getBuilderFactory } from '../getBuilderFactory';\n\ndescribe('Solana Confidential Transfer Builder - CT account enablement (v1)', () => {\n  const factory = getBuilderFactory('sol');\n  const account = new KeyPair(testData.associatedTokenAccounts.accounts[0]).getKeys();\n  const recentBlockHash = 'GHtXQBsoZHVnNFa9YevAzFr17DJjgHXk3ycTKD5xD3Zi';\n\n  const mintAddress = testData.associatedTokenAccountsForSol2022.mintId;\n  const tokenAddress = testData.associatedTokenAccountsForSol2022.accounts[0].ata;\n  const authorityAddress = account.pub;\n\n  const zeroBytes36 = '00'.repeat(36);\n  const proofDataHex = '00'.repeat(320);\n\n  const v1Config = {\n    computeUnitLimit: 200_000,\n    heapSize: 32_768,\n    loadedAccountsDataSizeLimit: 65_536,\n    priorityFee: 5_000,\n  };\n\n  const ctEnablementBuilder = () => {\n    const txBuilder = factory.getConfidentialTransferBuilder();\n    txBuilder.nonce(recentBlockHash);\n    txBuilder.sender(account.pub);\n    txBuilder.sign({ key: account.prv });\n    return txBuilder;\n  };\n\n  const addEnablementInstructions = (builder: ConfidentialTransferBuilder) => {\n    builder\n      .createAta({\n        mintAddress,\n        ataAddress: tokenAddress,\n        ownerAddress: authorityAddress,\n        payerAddress: account.pub,\n        tokenName: 'tsol:ray',\n        // CT mints are Token-2022 — the ATA must be created under the Token-2022 program\n        programId: 'TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb',\n      })\n      .configureAccount({\n        tokenAddress,\n        mintAddress,\n        authorityAddress,\n        elgamalPubkey: '11'.repeat(32),\n        decryptableZeroBalance: zeroBytes36,\n        maximumPendingBalanceCreditCounter: '18446744073709551615',\n        proofInstructionOffset: 1,\n      })\n      .verifyPubkeyValidity({ proofData: proofDataHex });\n  };\n\n  it('should build a v1 CT enablement transaction (CreateATA + ConfigureAccount + VerifyPubkeyValidity)', async function () {\n    const builder = ctEnablementBuilder();\n    addEnablementInstructions(builder);\n    builder.version(1).transactionConfig(v1Config);\n\n    const tx = await builder.build();\n\n    (tx as Transaction).isVersionedTransaction().should.equal(true);\n\n    const rawTx = tx.toBroadcastFormat();\n    const wire = Buffer.from(rawTx, 'base64');\n\n    // v1 version byte prefix\n    wire[0].should.equal(0x81);\n    // within the v1 wire size limit\n    wire.length.should.be.lessThanOrEqual(4096);\n\n    // metadata transaction carries all four instructions in order:\n    // CreateATA -> Reallocate (ConfidentialTransferAccount) -> ConfigureAccount -> Verify\n    const solTx = (tx as Transaction).solTransaction!;\n    solTx.instructions.length.should.equal(4);\n    solTx.instructions[0].data[0].should.equal(1 /* ATA program CreateIdempotent discriminator */);\n    solTx.instructions[1].programId.toString().should.equal(TOKEN_2022_PROGRAM_ID.toString());\n    solTx.instructions[1].data[0].should.equal(TokenInstruction.Reallocate);\n    solTx.instructions[2].programId.toString().should.equal(TOKEN_2022_PROGRAM_ID.toString());\n  });\n\n  it('should keep instruction order stable (no ApplyPendingBalance reordering concern)', async function () {\n    const builder = ctEnablementBuilder();\n    addEnablementInstructions(builder);\n    builder.version(1).transactionConfig(v1Config);\n\n    const tx = await builder.build();\n    const json = (tx as Transaction).toJson();\n    json.instructionsData.length.should.equal(4);\n    json.instructionsData[0].type.should.equal('CreateAssociatedTokenAccount');\n    // Reallocate is a Token-2022 extension instruction, surfaced as a custom instruction\n    json.instructionsData[1].type.should.equal('ReallocateConfidentialTransferAccount');\n    json.instructionsData[2].type.should.equal('ConfigureConfidentialTransferAccount');\n  });\n\n  it('should require at least one CT/ATA instruction', async function () {\n    const builder = ctEnablementBuilder();\n    builder.version(1).transactionConfig(v1Config);\n    await builder.build().should.be.rejectedWith(/At least one confidential transfer instruction/);\n  });\n});\n"]}

package/dist/cjs/test/unit/transactionBuilder/confidentialTransferBuilder.d.ts

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

package/dist/cjs/test/unit/transactionBuilder/confidentialTransferBuilder.d.ts.map

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