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

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

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

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

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

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

@@ -0,0 +1,138 @@
+"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 tweetnacl_1 = __importDefault(require("tweetnacl"));
+const statics_1 = require("@bitgo-beta/statics");
+const web3_js_1 = require("@solana/web3.js");
+const src_1 = require("../../../src");
+const parseWireTransaction_1 = require("../../../src/lib/serialization/parseWireTransaction");
+const testData = __importStar(require("../../resources/sol"));
+describe('Solana V1 Payment Builder (SIMD-0296/0385) — server-side construction surface', () => {
+    const coinConfig = statics_1.coins.get('tsol');
+    const user = new src_1.KeyPair(testData.authAccount).getKeys();
+    const gasTank = new src_1.KeyPair({ prv: testData.prvKeys.prvKey1.base58 }).getKeys();
+    const nonceAccount = new src_1.KeyPair(testData.nonceAccount).getKeys();
+    const recipient = 'ENn8a2tGMS9bR5XV7smGHJvNgzkyxJmnD2eUvQxY5jSP';
+    const recentBlockHash = 'GHtXQBsoZHVnNFa9YevAzFr17DJjgHXk3ycTKD5xD3Zi';
+    const amount = '300000';
+    const v1Config = {
+        computeUnitLimit: 200000,
+        heapSize: 32768,
+        loadedAccountsDataSizeLimit: 65536,
+        priorityFee: 5000,
+    };
+    const newBuilder = () => {
+        const builder = new src_1.V1PaymentBuilder(coinConfig);
+        builder.sender(user.pub);
+        builder.send({ address: recipient, amount });
+        builder.nonce(recentBlockHash);
+        builder.transactionConfig(v1Config);
+        return builder;
+    };
+    const signWith = (keyPair, messageBytes) => {
+        const prv = keyPair.prv;
+        if (typeof prv !== 'string') {
+            throw new Error('Missing private key for test signer');
+        }
+        const kp = new src_1.KeyPair({ prv });
+        return tweetnacl_1.default.sign.detached(messageBytes, kp.getKeys(true).prv);
+    };
+    it('exposes the structured send() surface', () => {
+        const builder = newBuilder();
+        builder.send({ address: recipient, amount }).should.equal(builder);
+    });
+    it('builds a v1 transfer message + signed wire and round-trips through parse', async () => {
+        const builder = newBuilder();
+        builder.sign({ key: user.prv });
+        const tx = (await builder.build());
+        tx.v1MessageBytes[0].should.equal(0x81);
+        tx.v1TransactionBytes.length.should.equal(tx.v1MessageBytes.length + 64);
+        tx.signablePayload.equals(Buffer.from(tx.v1MessageBytes)).should.be.true();
+        // the transfer instruction is a SystemProgram transfer (discriminator 2)
+        const decoded = (0, src_1.decodeV1Message)(tx.v1MessageBytes);
+        decoded.compiledInstructions[0].data[0].should.equal(2);
+        decoded.staticAccounts[decoded.compiledInstructions[0].programAddressIndex].should.equal(web3_js_1.SystemProgram.programId.toBase58());
+        const parsed = (0, src_1.parseWireTransaction)(tx.v1TransactionBytes);
+        parsed.signerPublicKeys.should.deepEqual([user.pub]);
+        (0, parseWireTransaction_1.verifyV1Signatures)(parsed.messageBytes, parsed.signatures, parsed.signerPublicKeys);
+    });
+    it('injects the AdvanceNonceAccount instruction and assembles user + gas-tank signatures in signer order', async () => {
+        const builder = newBuilder();
+        builder.nonce(recentBlockHash, {
+            walletNonceAddress: nonceAccount.pub,
+            authWalletAddress: gasTank.pub,
+        });
+        builder.sign({ key: user.prv });
+        const unsigned = (await builder.build());
+        const messageBytes = unsigned.v1MessageBytes;
+        // 2 required signers: user (fee payer) + gas-tank nonce authority
+        messageBytes[1].should.equal(2);
+        const decoded = (0, src_1.decodeV1Message)(messageBytes);
+        // nonce hash occupies the blockhash field
+        decoded.blockhash.should.equal(recentBlockHash);
+        // first instruction is AdvanceNonceAccount (System Program, discriminator 4)
+        decoded.compiledInstructions[0].data[0].should.equal(4);
+        decoded.staticAccounts[decoded.compiledInstructions[0].programAddressIndex].should.equal(web3_js_1.SystemProgram.programId.toBase58());
+        // signer order: fee payer (user) first, then gas tank
+        decoded.staticAccounts.slice(0, 2).should.deepEqual([user.pub, gasTank.pub]);
+        // attach the gas-tank HSM signature over the same message bytes
+        const gasTankSig = signWith(gasTank, messageBytes);
+        builder.addSignature({ pub: gasTank.pub }, Buffer.from(gasTankSig));
+        const signed = (await builder.build());
+        // message byte-identity between build and sign
+        Buffer.from(signed.v1MessageBytes).equals(Buffer.from(messageBytes)).should.be.true();
+        signed.v1TransactionBytes.length.should.equal(messageBytes.length + 2 * 64);
+        const parsed = (0, src_1.parseWireTransaction)(signed.v1TransactionBytes);
+        parsed.signerPublicKeys.should.deepEqual([user.pub, gasTank.pub]);
+        (0, parseWireTransaction_1.verifyV1Signatures)(parsed.messageBytes, parsed.signatures, parsed.signerPublicKeys);
+    });
+    it('throws when transactionConfig is missing', async () => {
+        const builder = new src_1.V1PaymentBuilder(coinConfig);
+        builder.sender(user.pub);
+        builder.send({ address: recipient, amount });
+        builder.nonce(recentBlockHash);
+        await builder.build().should.be.rejectedWith(/transactionConfig is required/);
+    });
+    it('validates recipient address and amount', () => {
+        const builder = new src_1.V1PaymentBuilder(coinConfig);
+        should_1.default.throws(() => builder.send({ address: 'not-an-address', amount }), /address/);
+        should_1.default.throws(() => builder.send({ address: recipient, amount: 'abc' }), /amount/);
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"v1PaymentBuilder.js","sourceRoot":"","sources":["../../../../../test/unit/transactionBuilder/v1PaymentBuilder.ts"],"names":[],"mappings":"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","sourcesContent":["import should from 'should';\nimport nacl from 'tweetnacl';\nimport { coins } from '@bitgo-beta/statics';\nimport { SystemProgram } from '@solana/web3.js';\nimport { decodeV1Message, KeyPair, parseWireTransaction, Transaction, V1PaymentBuilder } from '../../../src';\nimport { verifyV1Signatures } from '../../../src/lib/serialization/parseWireTransaction';\nimport { SolanaKeys } from '../../../src/lib/iface';\nimport * as testData from '../../resources/sol';\n\ndescribe('Solana V1 Payment Builder (SIMD-0296/0385) — server-side construction surface', () => {\n  const coinConfig = coins.get('tsol');\n  const user = new KeyPair(testData.authAccount).getKeys();\n  const gasTank = new KeyPair({ prv: testData.prvKeys.prvKey1.base58 }).getKeys();\n  const nonceAccount = new KeyPair(testData.nonceAccount).getKeys();\n  const recipient = 'ENn8a2tGMS9bR5XV7smGHJvNgzkyxJmnD2eUvQxY5jSP';\n  const recentBlockHash = 'GHtXQBsoZHVnNFa9YevAzFr17DJjgHXk3ycTKD5xD3Zi';\n  const amount = '300000';\n\n  const v1Config = {\n    computeUnitLimit: 200_000,\n    heapSize: 32_768,\n    loadedAccountsDataSizeLimit: 65_536,\n    priorityFee: 5_000,\n  };\n\n  const newBuilder = () => {\n    const builder = new V1PaymentBuilder(coinConfig);\n    builder.sender(user.pub);\n    builder.send({ address: recipient, amount });\n    builder.nonce(recentBlockHash);\n    builder.transactionConfig(v1Config);\n    return builder;\n  };\n\n  const signWith = (keyPair: SolanaKeys, messageBytes: Uint8Array): Uint8Array => {\n    const prv = keyPair.prv;\n    if (typeof prv !== 'string') {\n      throw new Error('Missing private key for test signer');\n    }\n    const kp = new KeyPair({ prv });\n    return nacl.sign.detached(messageBytes, kp.getKeys(true).prv as Uint8Array);\n  };\n\n  it('exposes the structured send() surface', () => {\n    const builder = newBuilder();\n    builder.send({ address: recipient, amount }).should.equal(builder);\n  });\n\n  it('builds a v1 transfer message + signed wire and round-trips through parse', async () => {\n    const builder = newBuilder();\n    builder.sign({ key: user.prv });\n    const tx = (await builder.build()) as Transaction;\n\n    tx.v1MessageBytes![0].should.equal(0x81);\n    tx.v1TransactionBytes!.length.should.equal(tx.v1MessageBytes!.length + 64);\n    tx.signablePayload.equals(Buffer.from(tx.v1MessageBytes!)).should.be.true();\n\n    // the transfer instruction is a SystemProgram transfer (discriminator 2)\n    const decoded = decodeV1Message(tx.v1MessageBytes!);\n    decoded.compiledInstructions[0].data[0].should.equal(2);\n    decoded.staticAccounts[decoded.compiledInstructions[0].programAddressIndex].should.equal(\n      SystemProgram.programId.toBase58()\n    );\n\n    const parsed = parseWireTransaction(tx.v1TransactionBytes!);\n    parsed.signerPublicKeys.should.deepEqual([user.pub]);\n    verifyV1Signatures(parsed.messageBytes, parsed.signatures, parsed.signerPublicKeys);\n  });\n\n  it('injects the AdvanceNonceAccount instruction and assembles user + gas-tank signatures in signer order', async () => {\n    const builder = newBuilder();\n    builder.nonce(recentBlockHash, {\n      walletNonceAddress: nonceAccount.pub,\n      authWalletAddress: gasTank.pub,\n    });\n    builder.sign({ key: user.prv });\n\n    const unsigned = (await builder.build()) as Transaction;\n    const messageBytes = unsigned.v1MessageBytes!;\n\n    // 2 required signers: user (fee payer) + gas-tank nonce authority\n    messageBytes[1].should.equal(2);\n\n    const decoded = decodeV1Message(messageBytes);\n    // nonce hash occupies the blockhash field\n    decoded.blockhash.should.equal(recentBlockHash);\n    // first instruction is AdvanceNonceAccount (System Program, discriminator 4)\n    decoded.compiledInstructions[0].data[0].should.equal(4);\n    decoded.staticAccounts[decoded.compiledInstructions[0].programAddressIndex].should.equal(\n      SystemProgram.programId.toBase58()\n    );\n    // signer order: fee payer (user) first, then gas tank\n    decoded.staticAccounts.slice(0, 2).should.deepEqual([user.pub, gasTank.pub]);\n\n    // attach the gas-tank HSM signature over the same message bytes\n    const gasTankSig = signWith(gasTank, messageBytes);\n    builder.addSignature({ pub: gasTank.pub }, Buffer.from(gasTankSig));\n    const signed = (await builder.build()) as Transaction;\n\n    // message byte-identity between build and sign\n    Buffer.from(signed.v1MessageBytes!).equals(Buffer.from(messageBytes)).should.be.true();\n    signed.v1TransactionBytes!.length.should.equal(messageBytes.length + 2 * 64);\n\n    const parsed = parseWireTransaction(signed.v1TransactionBytes!);\n    parsed.signerPublicKeys.should.deepEqual([user.pub, gasTank.pub]);\n    verifyV1Signatures(parsed.messageBytes, parsed.signatures, parsed.signerPublicKeys);\n  });\n\n  it('throws when transactionConfig is missing', async () => {\n    const builder = new V1PaymentBuilder(coinConfig);\n    builder.sender(user.pub);\n    builder.send({ address: recipient, amount });\n    builder.nonce(recentBlockHash);\n    await builder.build().should.be.rejectedWith(/transactionConfig is required/);\n  });\n\n  it('validates recipient address and amount', () => {\n    const builder = new V1PaymentBuilder(coinConfig);\n    should.throws(() => builder.send({ address: 'not-an-address', amount }), /address/);\n    should.throws(() => builder.send({ address: recipient, amount: 'abc' }), /amount/);\n  });\n});\n"]}

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

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

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

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

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

@@ -0,0 +1,331 @@
+"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 tweetnacl_1 = __importDefault(require("tweetnacl"));
+const statics_1 = require("@bitgo-beta/statics");
+const sdk_core_1 = require("@bitgo-beta/sdk-core");
+const web3_js_1 = require("@solana/web3.js");
+const bs58_1 = __importDefault(require("bs58"));
+const src_1 = require("../../../src");
+const parseWireTransaction_1 = require("../../../src/lib/serialization/parseWireTransaction");
+const constants_1 = require("../../../src/lib/constants");
+const v1CustomInstructionBuilder_1 = require("../../../src/lib/v1CustomInstructionBuilder");
+const testData = __importStar(require("../../resources/sol"));
+class TestV1Builder extends src_1.V1TransactionBuilder {
+    get transactionType() {
+        return sdk_core_1.TransactionType.Send;
+    }
+}
+describe('Solana V1 Transaction Builder (SIMD-0296/0385)', () => {
+    const coinConfig = statics_1.coins.get('tsol');
+    const user = new src_1.KeyPair(testData.authAccount).getKeys();
+    const gasTank = new src_1.KeyPair({ prv: testData.prvKeys.prvKey1.base58 }).getKeys();
+    const nonceAccount = new src_1.KeyPair(testData.nonceAccount).getKeys();
+    const recipient = 'ENn8a2tGMS9bR5XV7smGHJvNgzkyxJmnD2eUvQxY5jSP';
+    const recentBlockHash = 'GHtXQBsoZHVnNFa9YevAzFr17DJjgHXk3ycTKD5xD3Zi';
+    const amount = '300000';
+    const v1Config = {
+        computeUnitLimit: 200000,
+        heapSize: 32768,
+        loadedAccountsDataSizeLimit: 65536,
+        priorityFee: 5000,
+    };
+    const transfer = {
+        type: constants_1.InstructionBuilderTypes.Transfer,
+        params: { fromAddress: user.pub, toAddress: recipient, amount },
+    };
+    const newBuilder = () => {
+        const builder = new TestV1Builder(coinConfig);
+        builder.sender(user.pub);
+        builder.nonce(recentBlockHash);
+        builder.instructions([transfer]);
+        builder.transactionConfig(v1Config);
+        return builder;
+    };
+    const signWith = (keyPair, messageBytes) => {
+        const prv = keyPair.prv;
+        if (typeof prv !== 'string') {
+            throw new Error('Missing private key for test signer');
+        }
+        const kp = new src_1.KeyPair({ prv });
+        return tweetnacl_1.default.sign.detached(messageBytes, kp.getKeys(true).prv);
+    };
+    describe('single signer', () => {
+        it('builds a v1 message + signed wire and round-trips through parse', async () => {
+            const builder = newBuilder();
+            builder.sign({ key: user.prv });
+            const tx = (await builder.build());
+            tx.v1MessageBytes[0].should.equal(0x81);
+            tx.v1TransactionBytes.length.should.equal(tx.v1MessageBytes.length + 64);
+            // signable payload is the message bytes
+            tx.signablePayload.equals(Buffer.from(tx.v1MessageBytes)).should.be.true();
+            const parsed = (0, src_1.parseWireTransaction)(tx.v1TransactionBytes);
+            parsed.signerPublicKeys.should.deepEqual([user.pub]);
+            (0, parseWireTransaction_1.verifyV1Signatures)(parsed.messageBytes, parsed.signatures, parsed.signerPublicKeys);
+            // broadcast format round-trips through from()
+            const raw = tx.toBroadcastFormat();
+            const reparsed = new TestV1Builder(coinConfig);
+            reparsed.from(raw);
+            reparsed.transaction.toBroadcastFormat().should.equal(raw);
+        });
+        it('throws when transactionConfig is missing', async () => {
+            const builder = new TestV1Builder(coinConfig);
+            builder.sender(user.pub);
+            builder.nonce(recentBlockHash);
+            builder.instructions([transfer]);
+            await builder.build().should.be.rejectedWith(/transactionConfig is required/);
+        });
+    });
+    describe('durable nonce (2 signatures)', () => {
+        it('injects the AdvanceNonceAccount instruction and assembles user + gas-tank signatures in signer order', async () => {
+            const builder = newBuilder();
+            builder.nonce(recentBlockHash, {
+                walletNonceAddress: nonceAccount.pub,
+                authWalletAddress: gasTank.pub,
+            });
+            builder.sign({ key: user.prv });
+            const unsigned = (await builder.build());
+            const messageBytes = unsigned.v1MessageBytes;
+            // 2 required signers: user (fee payer) + gas-tank nonce authority
+            messageBytes[1].should.equal(2);
+            const decoded = (0, src_1.decodeV1Message)(messageBytes);
+            // nonce hash occupies the blockhash field
+            decoded.blockhash.should.equal(recentBlockHash);
+            // first instruction is AdvanceNonceAccount (System Program, discriminator 4)
+            decoded.compiledInstructions[0].data[0].should.equal(4);
+            decoded.staticAccounts[decoded.compiledInstructions[0].programAddressIndex].should.equal(web3_js_1.SystemProgram.programId.toBase58());
+            // signer order: fee payer (user) first, then gas tank
+            decoded.staticAccounts.slice(0, 2).should.deepEqual([user.pub, gasTank.pub]);
+            // attach the gas-tank HSM signature over the same message bytes
+            const gasTankSig = signWith(gasTank, messageBytes);
+            builder.addSignature({ pub: gasTank.pub }, Buffer.from(gasTankSig));
+            const signed = (await builder.build());
+            // message byte-identity between build and sign
+            signed.v1MessageBytes.should.deepEqual(messageBytes);
+            const parsed = (0, src_1.parseWireTransaction)(signed.v1TransactionBytes);
+            parsed.signerPublicKeys.should.deepEqual([user.pub, gasTank.pub]);
+            (0, parseWireTransaction_1.verifyV1Signatures)(parsed.messageBytes, parsed.signatures, parsed.signerPublicKeys);
+        });
+        it('orders signatures by the compiled message when the gas tank is the fee payer', async () => {
+            const builder = newBuilder();
+            builder.nonce(recentBlockHash, {
+                walletNonceAddress: nonceAccount.pub,
+                authWalletAddress: gasTank.pub,
+            });
+            builder.feePayer(gasTank.pub);
+            builder.sign({ key: user.prv });
+            const unsigned = (await builder.build());
+            const messageBytes = unsigned.v1MessageBytes;
+            const decoded = (0, src_1.decodeV1Message)(messageBytes);
+            // gas tank (fee payer) is the first signer, user second
+            decoded.staticAccounts.slice(0, 2).should.deepEqual([gasTank.pub, user.pub]);
+            const userSig = signWith(user, messageBytes);
+            const gasTankSig = signWith(gasTank, messageBytes);
+            builder.addSignature({ pub: user.pub }, Buffer.from(userSig));
+            builder.addSignature({ pub: gasTank.pub }, Buffer.from(gasTankSig));
+            const signed = (await builder.build());
+            const parsed = (0, src_1.parseWireTransaction)(signed.v1TransactionBytes);
+            parsed.signerPublicKeys.should.deepEqual([gasTank.pub, user.pub]);
+            (0, parseWireTransaction_1.verifyV1Signatures)(parsed.messageBytes, parsed.signatures, parsed.signerPublicKeys);
+        });
+        it('zero-fills a missing signature slot so the wire shape stays valid', async () => {
+            const builder = newBuilder();
+            builder.nonce(recentBlockHash, {
+                walletNonceAddress: nonceAccount.pub,
+                authWalletAddress: gasTank.pub,
+            });
+            builder.sign({ key: user.prv });
+            const tx = (await builder.build());
+            const parsed = (0, src_1.parseWireTransaction)(tx.v1TransactionBytes);
+            parsed.signerPublicKeys.should.deepEqual([user.pub, gasTank.pub]);
+            parsed.signatures[0].some((b) => b !== 0).should.be.true();
+            parsed.signatures[1].every((b) => b === 0).should.be.true();
+            should_1.default.throws(() => (0, parseWireTransaction_1.verifyV1Signatures)(parsed.messageBytes, parsed.signatures, parsed.signerPublicKeys));
+        });
+    });
+    describe('buildAdvanceNonceAccountInstruction', () => {
+        it('constructs the nonce advance instruction with the authority as signer', () => {
+            const ix = (0, src_1.buildAdvanceNonceAccountInstruction)(nonceAccount.pub, gasTank.pub);
+            ix.programId.toBase58().should.equal(web3_js_1.SystemProgram.programId.toBase58());
+            ix.data[0].should.equal(4);
+            ix.keys[0].pubkey.toBase58().should.equal(nonceAccount.pub);
+            ix.keys[0].isWritable.should.be.true();
+            ix.keys[0].isSigner.should.be.false();
+            // web3.js nonceAdvance includes the recent-blockhashes sysvar as the second key
+            ix.keys[1].pubkey.toBase58().should.equal('SysvarRecentB1ockHashes11111111111111111111');
+            ix.keys[2].pubkey.toBase58().should.equal(gasTank.pub);
+            ix.keys[2].isSigner.should.be.true();
+        });
+    });
+    describe('nonce validation', () => {
+        it('rejects an invalid blockhash', () => {
+            const builder = newBuilder();
+            should_1.default.throws(() => builder.nonce('not-a-blockhash'), /Invalid or missing blockHash/);
+        });
+        it('rejects a nonce whose authority equals the nonce account', () => {
+            const builder = newBuilder();
+            should_1.default.throws(() => builder.nonce(recentBlockHash, { walletNonceAddress: user.pub, authWalletAddress: user.pub }), /walletNonceAddress cannot be equal to authWalletAddress/);
+        });
+    });
+    describe('from()', () => {
+        it('parses a signed v1 wire and exposes toJson via the metadata transaction', async () => {
+            const builder = newBuilder();
+            builder.sign({ key: user.prv });
+            const tx = (await builder.build());
+            const raw = tx.toBroadcastFormat();
+            const reparsed = new TestV1Builder(coinConfig);
+            reparsed.from(raw);
+            const reparsedTx = reparsed.transaction;
+            reparsedTx.toBroadcastFormat().should.equal(raw);
+            const json = reparsedTx.toJson();
+            json.nonce.should.equal(recentBlockHash);
+            json.numSignatures.should.equal(1);
+        });
+    });
+});
+describe('V1CustomInstructionBuilder', function () {
+    const coinConfig = statics_1.coins.get('tsol');
+    const user = new src_1.KeyPair(testData.authAccount).getKeys();
+    const gasTank = new src_1.KeyPair({ prv: testData.prvKeys.prvKey1.base58 }).getKeys();
+    const nonceAccount = new src_1.KeyPair(testData.nonceAccount).getKeys();
+    const recentBlockHash = 'GHtXQBsoZHVnNFa9YevAzFr17DJjgHXk3ycTKD5xD3Zi';
+    const v1Config = {
+        computeUnitLimit: 200000,
+        heapSize: 32768,
+        loadedAccountsDataSizeLimit: 65536,
+        priorityFee: 5000,
+    };
+    const signWith = (keyPair, messageBytes) => {
+        const prv = keyPair.prv;
+        if (typeof prv !== 'string') {
+            throw new Error('Missing private key for test signer');
+        }
+        const kp = new src_1.KeyPair({ prv });
+        return tweetnacl_1.default.sign.detached(messageBytes, kp.getKeys(true).prv);
+    };
+    it('builds a v1 transaction from a custom instruction + 2 signatures in signer order', async function () {
+        const recipient = 'C3sGf4xZb7kP1mQr8tYw9uVx2nD5hJ6aLcE4oRqS7iB';
+        const builder = new v1CustomInstructionBuilder_1.V1CustomInstructionBuilder(coinConfig);
+        builder.sender(user.pub);
+        builder.nonce(recentBlockHash, { walletNonceAddress: nonceAccount.pub, authWalletAddress: gasTank.pub });
+        builder.transactionConfig(v1Config);
+        builder.addInstruction(web3_js_1.SystemProgram.transfer({
+            fromPubkey: new web3_js_1.PublicKey(user.pub),
+            toPubkey: new web3_js_1.PublicKey(recipient),
+            lamports: 1000000,
+        }));
+        builder.sign({ key: user.prv });
+        const unsigned = (await builder.build());
+        const gasTankSig = signWith(gasTank, unsigned.v1MessageBytes);
+        builder.addSignature({ pub: gasTank.pub }, Buffer.from(gasTankSig));
+        const signed = (await builder.build());
+        const parsed = (0, src_1.parseWireTransaction)(signed.v1TransactionBytes);
+        parsed.signerPublicKeys.should.deepEqual([user.pub, gasTank.pub]);
+        (0, parseWireTransaction_1.verifyV1Signatures)(parsed.messageBytes, parsed.signatures, parsed.signerPublicKeys);
+    });
+});
+describe('V1TransactionBuilder envelope surface (fromVersionedData + SDK injector)', function () {
+    const coinConfig = statics_1.coins.get('tsol');
+    const user = new src_1.KeyPair(testData.authAccount).getKeys();
+    const gasTank = new src_1.KeyPair({ prv: testData.prvKeys.prvKey1.base58 }).getKeys();
+    const nonceAccount = new src_1.KeyPair(testData.nonceAccount).getKeys();
+    const recentBlockHash = 'GHtXQBsoZHVnNFa9YevAzFr17DJjgHXk3ycTKD5xD3Zi';
+    const envelope = {
+        version: 1,
+        versionedInstructions: [
+            { programIdIndex: 1, accountKeyIndexes: [0, 1], data: '2UzHM' }, // base58 of 0x01000000
+        ],
+        addressLookupTables: [],
+        staticAccountKeys: [user.pub, 'MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr'],
+        messageHeader: { numRequiredSignatures: 1, numReadonlySignedAccounts: 0, numReadonlyUnsignedAccounts: 1 },
+        transactionConfig: {
+            computeUnitLimit: 200000,
+            heapSize: 32768,
+            loadedAccountsDataSizeLimit: null,
+            priorityFee: null,
+        },
+    };
+    it('fromVersionedData builds the same v1 message as manual addInstruction', async function () {
+        const fromData = new v1CustomInstructionBuilder_1.V1CustomInstructionBuilder(coinConfig);
+        fromData.fromVersionedData(envelope);
+        fromData.nonce(recentBlockHash);
+        fromData.sign({ key: user.prv });
+        const a = (await fromData.build());
+        const manual = new v1CustomInstructionBuilder_1.V1CustomInstructionBuilder(coinConfig);
+        manual.sender(user.pub);
+        manual.nonce(recentBlockHash);
+        manual.transactionConfig({ computeUnitLimit: 200000, heapSize: 32768 });
+        for (const ix of envelope.versionedInstructions) {
+            manual.addInstruction((0, src_1.toV1TransactionInstruction)(ix, envelope));
+        }
+        manual.sign({ key: user.prv });
+        const b = (await manual.build());
+        a.v1MessageBytes.should.deepEqual(b.v1MessageBytes);
+    });
+    it('SDK injectV1NonceAdvanceInstruction grows the header and promotes the authority', function () {
+        const injected = (0, src_1.injectV1NonceAdvanceInstruction)(envelope, {
+            walletNonceAddress: nonceAccount.pub,
+            authWalletAddress: gasTank.pub,
+        });
+        injected.messageHeader.numRequiredSignatures.should.equal(2);
+        injected.messageHeader.numReadonlySignedAccounts.should.equal(1);
+        injected.messageHeader.numReadonlyUnsignedAccounts.should.equal(3);
+        const nonceIx = injected.versionedInstructions[0];
+        injected.staticAccountKeys[nonceIx.programIdIndex].should.equal(web3_js_1.SystemProgram.programId.toBase58());
+        Buffer.from(bs58_1.default.decode(nonceIx.data))
+            .equals(Buffer.from([4, 0, 0, 0]))
+            .should.be.true();
+        // idempotent on a second pass
+        const twice = (0, src_1.injectV1NonceAdvanceInstruction)(injected, {
+            walletNonceAddress: nonceAccount.pub,
+            authWalletAddress: gasTank.pub,
+        });
+        twice.versionedInstructions.length.should.equal(injected.versionedInstructions.length);
+    });
+    it('transactionConfig coerces unset fields to null (SDK serializer contract)', async function () {
+        const builder = new v1CustomInstructionBuilder_1.V1CustomInstructionBuilder(coinConfig);
+        builder.fromVersionedData(envelope);
+        builder.nonce(recentBlockHash);
+        builder.transactionConfig({ computeUnitLimit: 200000 });
+        const tx = (await builder.build());
+        const decoded = (0, src_1.decodeV1Message)(tx.v1MessageBytes);
+        decoded.configValues.some((v) => v.kind === 'u32' && v.value === 200000).should.be.true();
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"v1TransactionBuilder.js","sourceRoot":"","sources":["../../../../../test/unit/transactionBuilder/v1TransactionBuilder.ts"],"names":[],"mappings":"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","sourcesContent":["import should from 'should';\nimport nacl from 'tweetnacl';\nimport { coins } from '@bitgo-beta/statics';\nimport { TransactionType, type SolVersionedTransactionData } from '@bitgo-beta/sdk-core';\nimport { PublicKey, SystemProgram } from '@solana/web3.js';\nimport base58 from 'bs58';\nimport {\n  buildAdvanceNonceAccountInstruction,\n  decodeV1Message,\n  injectV1NonceAdvanceInstruction,\n  KeyPair,\n  parseWireTransaction,\n  Transaction,\n  V1TransactionBuilder,\n  toV1TransactionInstruction,\n} from '../../../src';\nimport { verifyV1Signatures } from '../../../src/lib/serialization/parseWireTransaction';\nimport { InstructionBuilderTypes } from '../../../src/lib/constants';\nimport { V1CustomInstructionBuilder } from '../../../src/lib/v1CustomInstructionBuilder';\nimport { SolanaKeys, Transfer } from '../../../src/lib/iface';\nimport * as testData from '../../resources/sol';\n\nclass TestV1Builder extends V1TransactionBuilder {\n  protected get transactionType(): TransactionType {\n    return TransactionType.Send;\n  }\n}\n\ndescribe('Solana V1 Transaction Builder (SIMD-0296/0385)', () => {\n  const coinConfig = coins.get('tsol');\n  const user = new KeyPair(testData.authAccount).getKeys();\n  const gasTank = new KeyPair({ prv: testData.prvKeys.prvKey1.base58 }).getKeys();\n  const nonceAccount = new KeyPair(testData.nonceAccount).getKeys();\n  const recipient = 'ENn8a2tGMS9bR5XV7smGHJvNgzkyxJmnD2eUvQxY5jSP';\n  const recentBlockHash = 'GHtXQBsoZHVnNFa9YevAzFr17DJjgHXk3ycTKD5xD3Zi';\n  const amount = '300000';\n\n  const v1Config = {\n    computeUnitLimit: 200_000,\n    heapSize: 32_768,\n    loadedAccountsDataSizeLimit: 65_536,\n    priorityFee: 5_000,\n  };\n\n  const transfer: Transfer = {\n    type: InstructionBuilderTypes.Transfer,\n    params: { fromAddress: user.pub, toAddress: recipient, amount },\n  };\n\n  const newBuilder = () => {\n    const builder = new TestV1Builder(coinConfig);\n    builder.sender(user.pub);\n    builder.nonce(recentBlockHash);\n    builder.instructions([transfer]);\n    builder.transactionConfig(v1Config);\n    return builder;\n  };\n\n  const signWith = (keyPair: SolanaKeys, messageBytes: Uint8Array): Uint8Array => {\n    const prv = keyPair.prv;\n    if (typeof prv !== 'string') {\n      throw new Error('Missing private key for test signer');\n    }\n    const kp = new KeyPair({ prv });\n    return nacl.sign.detached(messageBytes, kp.getKeys(true).prv as Uint8Array);\n  };\n\n  describe('single signer', () => {\n    it('builds a v1 message + signed wire and round-trips through parse', async () => {\n      const builder = newBuilder();\n      builder.sign({ key: user.prv });\n      const tx = (await builder.build()) as Transaction;\n\n      tx.v1MessageBytes![0].should.equal(0x81);\n      tx.v1TransactionBytes!.length.should.equal(tx.v1MessageBytes!.length + 64);\n      // signable payload is the message bytes\n      tx.signablePayload.equals(Buffer.from(tx.v1MessageBytes!)).should.be.true();\n\n      const parsed = parseWireTransaction(tx.v1TransactionBytes!);\n      parsed.signerPublicKeys.should.deepEqual([user.pub]);\n      verifyV1Signatures(parsed.messageBytes, parsed.signatures, parsed.signerPublicKeys);\n\n      // broadcast format round-trips through from()\n      const raw = tx.toBroadcastFormat();\n      const reparsed = new TestV1Builder(coinConfig);\n      reparsed.from(raw);\n      (reparsed as unknown as { transaction: Transaction }).transaction.toBroadcastFormat().should.equal(raw);\n    });\n\n    it('throws when transactionConfig is missing', async () => {\n      const builder = new TestV1Builder(coinConfig);\n      builder.sender(user.pub);\n      builder.nonce(recentBlockHash);\n      builder.instructions([transfer]);\n      await builder.build().should.be.rejectedWith(/transactionConfig is required/);\n    });\n  });\n\n  describe('durable nonce (2 signatures)', () => {\n    it('injects the AdvanceNonceAccount instruction and assembles user + gas-tank signatures in signer order', async () => {\n      const builder = newBuilder();\n      builder.nonce(recentBlockHash, {\n        walletNonceAddress: nonceAccount.pub,\n        authWalletAddress: gasTank.pub,\n      });\n      builder.sign({ key: user.prv });\n\n      const unsigned = (await builder.build()) as Transaction;\n      const messageBytes = unsigned.v1MessageBytes!;\n\n      // 2 required signers: user (fee payer) + gas-tank nonce authority\n      messageBytes[1].should.equal(2);\n\n      const decoded = decodeV1Message(messageBytes);\n      // nonce hash occupies the blockhash field\n      decoded.blockhash.should.equal(recentBlockHash);\n      // first instruction is AdvanceNonceAccount (System Program, discriminator 4)\n      decoded.compiledInstructions[0].data[0].should.equal(4);\n      decoded.staticAccounts[decoded.compiledInstructions[0].programAddressIndex].should.equal(\n        SystemProgram.programId.toBase58()\n      );\n      // signer order: fee payer (user) first, then gas tank\n      decoded.staticAccounts.slice(0, 2).should.deepEqual([user.pub, gasTank.pub]);\n\n      // attach the gas-tank HSM signature over the same message bytes\n      const gasTankSig = signWith(gasTank, messageBytes);\n      builder.addSignature({ pub: gasTank.pub }, Buffer.from(gasTankSig));\n      const signed = (await builder.build()) as Transaction;\n\n      // message byte-identity between build and sign\n      signed.v1MessageBytes!.should.deepEqual(messageBytes);\n\n      const parsed = parseWireTransaction(signed.v1TransactionBytes!);\n      parsed.signerPublicKeys.should.deepEqual([user.pub, gasTank.pub]);\n      verifyV1Signatures(parsed.messageBytes, parsed.signatures, parsed.signerPublicKeys);\n    });\n\n    it('orders signatures by the compiled message when the gas tank is the fee payer', async () => {\n      const builder = newBuilder();\n      builder.nonce(recentBlockHash, {\n        walletNonceAddress: nonceAccount.pub,\n        authWalletAddress: gasTank.pub,\n      });\n      builder.feePayer(gasTank.pub);\n      builder.sign({ key: user.prv });\n\n      const unsigned = (await builder.build()) as Transaction;\n      const messageBytes = unsigned.v1MessageBytes!;\n      const decoded = decodeV1Message(messageBytes);\n      // gas tank (fee payer) is the first signer, user second\n      decoded.staticAccounts.slice(0, 2).should.deepEqual([gasTank.pub, user.pub]);\n\n      const userSig = signWith(user, messageBytes);\n      const gasTankSig = signWith(gasTank, messageBytes);\n      builder.addSignature({ pub: user.pub }, Buffer.from(userSig));\n      builder.addSignature({ pub: gasTank.pub }, Buffer.from(gasTankSig));\n      const signed = (await builder.build()) as Transaction;\n\n      const parsed = parseWireTransaction(signed.v1TransactionBytes!);\n      parsed.signerPublicKeys.should.deepEqual([gasTank.pub, user.pub]);\n      verifyV1Signatures(parsed.messageBytes, parsed.signatures, parsed.signerPublicKeys);\n    });\n\n    it('zero-fills a missing signature slot so the wire shape stays valid', async () => {\n      const builder = newBuilder();\n      builder.nonce(recentBlockHash, {\n        walletNonceAddress: nonceAccount.pub,\n        authWalletAddress: gasTank.pub,\n      });\n      builder.sign({ key: user.prv });\n\n      const tx = (await builder.build()) as Transaction;\n      const parsed = parseWireTransaction(tx.v1TransactionBytes!);\n      parsed.signerPublicKeys.should.deepEqual([user.pub, gasTank.pub]);\n      parsed.signatures[0].some((b) => b !== 0).should.be.true();\n      parsed.signatures[1].every((b) => b === 0).should.be.true();\n      should.throws(() => verifyV1Signatures(parsed.messageBytes, parsed.signatures, parsed.signerPublicKeys));\n    });\n  });\n\n  describe('buildAdvanceNonceAccountInstruction', () => {\n    it('constructs the nonce advance instruction with the authority as signer', () => {\n      const ix = buildAdvanceNonceAccountInstruction(nonceAccount.pub, gasTank.pub);\n      ix.programId.toBase58().should.equal(SystemProgram.programId.toBase58());\n      ix.data[0].should.equal(4);\n      ix.keys[0].pubkey.toBase58().should.equal(nonceAccount.pub);\n      ix.keys[0].isWritable.should.be.true();\n      ix.keys[0].isSigner.should.be.false();\n      // web3.js nonceAdvance includes the recent-blockhashes sysvar as the second key\n      ix.keys[1].pubkey.toBase58().should.equal('SysvarRecentB1ockHashes11111111111111111111');\n      ix.keys[2].pubkey.toBase58().should.equal(gasTank.pub);\n      ix.keys[2].isSigner.should.be.true();\n    });\n  });\n\n  describe('nonce validation', () => {\n    it('rejects an invalid blockhash', () => {\n      const builder = newBuilder();\n      should.throws(() => builder.nonce('not-a-blockhash'), /Invalid or missing blockHash/);\n    });\n\n    it('rejects a nonce whose authority equals the nonce account', () => {\n      const builder = newBuilder();\n      should.throws(\n        () => builder.nonce(recentBlockHash, { walletNonceAddress: user.pub, authWalletAddress: user.pub }),\n        /walletNonceAddress cannot be equal to authWalletAddress/\n      );\n    });\n  });\n\n  describe('from()', () => {\n    it('parses a signed v1 wire and exposes toJson via the metadata transaction', async () => {\n      const builder = newBuilder();\n      builder.sign({ key: user.prv });\n      const tx = (await builder.build()) as Transaction;\n      const raw = tx.toBroadcastFormat();\n\n      const reparsed = new TestV1Builder(coinConfig);\n      reparsed.from(raw);\n      const reparsedTx = (reparsed as unknown as { transaction: Transaction }).transaction;\n      reparsedTx.toBroadcastFormat().should.equal(raw);\n\n      const json = reparsedTx.toJson();\n      json.nonce.should.equal(recentBlockHash);\n      json.numSignatures.should.equal(1);\n    });\n  });\n});\n\ndescribe('V1CustomInstructionBuilder', function () {\n  const coinConfig = coins.get('tsol');\n  const user = new KeyPair(testData.authAccount).getKeys();\n  const gasTank = new KeyPair({ prv: testData.prvKeys.prvKey1.base58 }).getKeys();\n  const nonceAccount = new KeyPair(testData.nonceAccount).getKeys();\n  const recentBlockHash = 'GHtXQBsoZHVnNFa9YevAzFr17DJjgHXk3ycTKD5xD3Zi';\n  const v1Config = {\n    computeUnitLimit: 200_000,\n    heapSize: 32_768,\n    loadedAccountsDataSizeLimit: 65_536,\n    priorityFee: 5_000,\n  };\n\n  const signWith = (keyPair: SolanaKeys, messageBytes: Uint8Array): Uint8Array => {\n    const prv = keyPair.prv;\n    if (typeof prv !== 'string') {\n      throw new Error('Missing private key for test signer');\n    }\n    const kp = new KeyPair({ prv });\n    return nacl.sign.detached(messageBytes, kp.getKeys(true).prv as Uint8Array);\n  };\n\n  it('builds a v1 transaction from a custom instruction + 2 signatures in signer order', async function () {\n    const recipient = 'C3sGf4xZb7kP1mQr8tYw9uVx2nD5hJ6aLcE4oRqS7iB';\n    const builder = new V1CustomInstructionBuilder(coinConfig);\n    builder.sender(user.pub);\n    builder.nonce(recentBlockHash, { walletNonceAddress: nonceAccount.pub, authWalletAddress: gasTank.pub });\n    builder.transactionConfig(v1Config);\n    builder.addInstruction(\n      SystemProgram.transfer({\n        fromPubkey: new PublicKey(user.pub),\n        toPubkey: new PublicKey(recipient),\n        lamports: 1_000_000,\n      })\n    );\n    builder.sign({ key: user.prv });\n\n    const unsigned = (await builder.build()) as Transaction;\n    const gasTankSig = signWith(gasTank, unsigned.v1MessageBytes!);\n    builder.addSignature({ pub: gasTank.pub }, Buffer.from(gasTankSig));\n    const signed = (await builder.build()) as Transaction;\n\n    const parsed = parseWireTransaction(signed.v1TransactionBytes!);\n    parsed.signerPublicKeys.should.deepEqual([user.pub, gasTank.pub]);\n    verifyV1Signatures(parsed.messageBytes, parsed.signatures, parsed.signerPublicKeys);\n  });\n});\n\ndescribe('V1TransactionBuilder envelope surface (fromVersionedData + SDK injector)', function () {\n  const coinConfig = coins.get('tsol');\n  const user = new KeyPair(testData.authAccount).getKeys();\n  const gasTank = new KeyPair({ prv: testData.prvKeys.prvKey1.base58 }).getKeys();\n  const nonceAccount = new KeyPair(testData.nonceAccount).getKeys();\n  const recentBlockHash = 'GHtXQBsoZHVnNFa9YevAzFr17DJjgHXk3ycTKD5xD3Zi';\n\n  const envelope: SolVersionedTransactionData = {\n    version: 1,\n    versionedInstructions: [\n      { programIdIndex: 1, accountKeyIndexes: [0, 1], data: '2UzHM' }, // base58 of 0x01000000\n    ],\n    addressLookupTables: [],\n    staticAccountKeys: [user.pub, 'MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr'],\n    messageHeader: { numRequiredSignatures: 1, numReadonlySignedAccounts: 0, numReadonlyUnsignedAccounts: 1 },\n    transactionConfig: {\n      computeUnitLimit: 200_000,\n      heapSize: 32_768,\n      loadedAccountsDataSizeLimit: null,\n      priorityFee: null,\n    },\n  };\n\n  it('fromVersionedData builds the same v1 message as manual addInstruction', async function () {\n    const fromData = new V1CustomInstructionBuilder(coinConfig);\n    fromData.fromVersionedData(envelope);\n    fromData.nonce(recentBlockHash);\n    fromData.sign({ key: user.prv });\n    const a = (await fromData.build()) as Transaction;\n\n    const manual = new V1CustomInstructionBuilder(coinConfig);\n    manual.sender(user.pub);\n    manual.nonce(recentBlockHash);\n    manual.transactionConfig({ computeUnitLimit: 200_000, heapSize: 32_768 });\n    for (const ix of envelope.versionedInstructions) {\n      manual.addInstruction(toV1TransactionInstruction(ix, envelope));\n    }\n    manual.sign({ key: user.prv });\n    const b = (await manual.build()) as Transaction;\n\n    a.v1MessageBytes!.should.deepEqual(b.v1MessageBytes!);\n  });\n\n  it('SDK injectV1NonceAdvanceInstruction grows the header and promotes the authority', function () {\n    const injected = injectV1NonceAdvanceInstruction(envelope, {\n      walletNonceAddress: nonceAccount.pub,\n      authWalletAddress: gasTank.pub,\n    });\n    injected.messageHeader.numRequiredSignatures.should.equal(2);\n    injected.messageHeader.numReadonlySignedAccounts.should.equal(1);\n    injected.messageHeader.numReadonlyUnsignedAccounts.should.equal(3);\n    const nonceIx = injected.versionedInstructions[0];\n    injected.staticAccountKeys[nonceIx.programIdIndex].should.equal(SystemProgram.programId.toBase58());\n    Buffer.from(base58.decode(nonceIx.data))\n      .equals(Buffer.from([4, 0, 0, 0]))\n      .should.be.true();\n\n    // idempotent on a second pass\n    const twice = injectV1NonceAdvanceInstruction(injected, {\n      walletNonceAddress: nonceAccount.pub,\n      authWalletAddress: gasTank.pub,\n    });\n    twice.versionedInstructions.length.should.equal(injected.versionedInstructions.length);\n  });\n\n  it('transactionConfig coerces unset fields to null (SDK serializer contract)', async function () {\n    const builder = new V1CustomInstructionBuilder(coinConfig);\n    builder.fromVersionedData(envelope);\n    builder.nonce(recentBlockHash);\n    builder.transactionConfig({ computeUnitLimit: 200_000 });\n    const tx = (await builder.build()) as Transaction;\n    const decoded = decodeV1Message(tx.v1MessageBytes!);\n    decoded.configValues.some((v) => v.kind === 'u32' && v.value === 200_000).should.be.true();\n  });\n});\n"]}

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

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