@bitgo-beta/sdk-coin-sol 7.6.4-beta.709 → 7.6.4-beta.710

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

@@ -0,0 +1,144 @@
+"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 getBuilderFactory_1 = require("../getBuilderFactory");
+describe('Solana Confidential Transfer Builder - 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 destinationTokenAddress = 'ENn8a2tGMS9bR5XV7smGHJvNgzkyxJmnD2eUvQxY5jSP';
+    const authorityAddress = account.pub;
+    const zeroBytes36 = '00'.repeat(36);
+    const zeroBytes64 = '00'.repeat(64);
+    const proofDataHex = '00'.repeat(320);
+    const v1Config = {
+        computeUnitLimit: 200000,
+        heapSize: 32768,
+        loadedAccountsDataSizeLimit: 65536,
+        priorityFee: 5000,
+    };
+    const ctBuilder = () => {
+        const txBuilder = factory.getConfidentialTransferBuilder();
+        txBuilder.nonce(recentBlockHash);
+        txBuilder.sender(account.pub);
+        txBuilder.sign({ key: account.prv });
+        return txBuilder;
+    };
+    const addTransfer = (builder) => {
+        builder
+            .applyPendingBalance({
+            tokenAddress,
+            authorityAddress,
+            expectedPendingBalanceCreditCounter: '2',
+            newDecryptableAvailableBalance: zeroBytes36,
+        })
+            .verifyEqualityProof({ proofData: proofDataHex })
+            .verifyValidityProof({ proofData: proofDataHex })
+            .verifyRangeProof({ proofData: '00'.repeat(1000) })
+            .confidentialTransfer({
+            sourceTokenAddress: tokenAddress,
+            mintAddress,
+            destinationTokenAddress,
+            authorityAddress,
+            newSourceDecryptableAvailableBalance: zeroBytes36,
+            transferAmountAuditorCiphertextLo: zeroBytes64,
+            transferAmountAuditorCiphertextHi: zeroBytes64,
+            equalityProofInstructionOffset: 1,
+            ciphertextValidityProofInstructionOffset: 2,
+            rangeProofInstructionOffset: 3,
+        });
+    };
+    it('should build a v1 confidential transfer transaction (0x81 prefix, within 4096 bytes)', async () => {
+        const builder = ctBuilder();
+        addTransfer(builder);
+        builder.version(1).transactionConfig(v1Config);
+        const tx = await builder.build();
+        tx.isVersionedTransaction().should.equal(true);
+        tx.v1TransactionBytes.should.be.an.instanceOf(Uint8Array);
+        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);
+        // config preserved in the decoded v1 message
+    });
+    it('should require transactionConfig when version(1) is set', async () => {
+        const builder = ctBuilder();
+        addTransfer(builder);
+        builder.version(1);
+        await builder.build().should.be.rejectedWith(/transactionConfig is required/);
+    });
+    it('should reject v1 transactions that exceed the 4096-byte wire limit at broadcast', async () => {
+        const builder = ctBuilder();
+        addTransfer(builder);
+        builder.version(1).transactionConfig(v1Config);
+        const tx = await builder.build();
+        const rawTx = tx.toBroadcastFormat();
+        // Force an oversized v1 payload by padding the wire bytes past the limit.
+        const wire = Buffer.from(rawTx, 'base64');
+        const oversized = Buffer.concat([wire, Buffer.alloc(4097)]);
+        oversized[0].should.equal(0x81);
+        // Broadcast the oversized v1 tx through Sol.prototype.broadcastTransaction with an RPC
+        // stub that must not be reached - the size guard short-circuits before the RPC call.
+        const coin = { getDataFromNode: () => Promise.reject(new Error('RPC should not be reached')) };
+        await src_1.Sol.prototype.broadcastTransaction
+            .call(coin, { serializedSignedTransaction: oversized.toString('base64') })
+            .should.be.rejectedWith(/exceeds the 4096-byte size limit/);
+    });
+    it('should leave the non-v1 path unchanged (v0/legacy default)', async () => {
+        const builder = ctBuilder();
+        builder.configureAccount({
+            tokenAddress,
+            mintAddress,
+            authorityAddress,
+            decryptableZeroBalance: zeroBytes36,
+            maximumPendingBalanceCreditCounter: '65536',
+            proofInstructionOffset: 1,
+        });
+        const tx = await builder.build();
+        const rawTx = tx.toBroadcastFormat();
+        // legacy transaction does not carry the 0x81 v1 prefix
+        Buffer.from(rawTx, 'base64')[0].should.not.equal(0x81);
+        tx.isVersionedTransaction().should.equal(false);
+        src_1.Utils.isValidRawTransaction(rawTx).should.equal(true);
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"confidentialTransferV1.js","sourceRoot":"","sources":["../../../../../test/unit/transactionBuilder/confidentialTransferV1.ts"],"names":[],"mappings":"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","sourcesContent":["import 'should';\nimport { KeyPair, Sol, Transaction, Utils } from '../../../src';\nimport * as testData from '../../resources/sol';\nimport { getBuilderFactory } from '../getBuilderFactory';\n\ndescribe('Solana Confidential Transfer Builder - 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 destinationTokenAddress = 'ENn8a2tGMS9bR5XV7smGHJvNgzkyxJmnD2eUvQxY5jSP';\n  const authorityAddress = account.pub;\n\n  const zeroBytes36 = '00'.repeat(36);\n  const zeroBytes64 = '00'.repeat(64);\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 ctBuilder = () => {\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 addTransfer = (builder: ReturnType<typeof ctBuilder>) => {\n    builder\n      .applyPendingBalance({\n        tokenAddress,\n        authorityAddress,\n        expectedPendingBalanceCreditCounter: '2',\n        newDecryptableAvailableBalance: zeroBytes36,\n      })\n      .verifyEqualityProof({ proofData: proofDataHex })\n      .verifyValidityProof({ proofData: proofDataHex })\n      .verifyRangeProof({ proofData: '00'.repeat(1000) })\n      .confidentialTransfer({\n        sourceTokenAddress: tokenAddress,\n        mintAddress,\n        destinationTokenAddress,\n        authorityAddress,\n        newSourceDecryptableAvailableBalance: zeroBytes36,\n        transferAmountAuditorCiphertextLo: zeroBytes64,\n        transferAmountAuditorCiphertextHi: zeroBytes64,\n        equalityProofInstructionOffset: 1,\n        ciphertextValidityProofInstructionOffset: 2,\n        rangeProofInstructionOffset: 3,\n      });\n  };\n\n  it('should build a v1 confidential transfer transaction (0x81 prefix, within 4096 bytes)', async () => {\n    const builder = ctBuilder();\n    addTransfer(builder);\n    builder.version(1).transactionConfig(v1Config);\n\n    const tx = await builder.build();\n\n    (tx as Transaction).isVersionedTransaction().should.equal(true);\n    (tx as Transaction).v1TransactionBytes!.should.be.an.instanceOf(Uint8Array);\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    // config preserved in the decoded v1 message\n  });\n\n  it('should require transactionConfig when version(1) is set', async () => {\n    const builder = ctBuilder();\n    addTransfer(builder);\n    builder.version(1);\n\n    await builder.build().should.be.rejectedWith(/transactionConfig is required/);\n  });\n\n  it('should reject v1 transactions that exceed the 4096-byte wire limit at broadcast', async () => {\n    const builder = ctBuilder();\n    addTransfer(builder);\n    builder.version(1).transactionConfig(v1Config);\n\n    const tx = await builder.build();\n    const rawTx = (tx as Transaction).toBroadcastFormat();\n\n    // Force an oversized v1 payload by padding the wire bytes past the limit.\n    const wire = Buffer.from(rawTx, 'base64');\n    const oversized = Buffer.concat([wire, Buffer.alloc(4097)]);\n    oversized[0].should.equal(0x81);\n\n    // Broadcast the oversized v1 tx through Sol.prototype.broadcastTransaction with an RPC\n    // stub that must not be reached - the size guard short-circuits before the RPC call.\n    const coin = { getDataFromNode: () => Promise.reject(new Error('RPC should not be reached')) } as unknown as Sol;\n    await (Sol.prototype.broadcastTransaction as (opts: { serializedSignedTransaction: string }) => Promise<never>)\n      .call(coin, { serializedSignedTransaction: oversized.toString('base64') })\n      .should.be.rejectedWith(/exceeds the 4096-byte size limit/);\n  });\n\n  it('should leave the non-v1 path unchanged (v0/legacy default)', async () => {\n    const builder = ctBuilder();\n    builder.configureAccount({\n      tokenAddress,\n      mintAddress,\n      authorityAddress,\n      decryptableZeroBalance: zeroBytes36,\n      maximumPendingBalanceCreditCounter: '65536',\n      proofInstructionOffset: 1,\n    });\n\n    const tx = await builder.build();\n    const rawTx = (tx as Transaction).toBroadcastFormat();\n    // legacy transaction does not carry the 0x81 v1 prefix\n    Buffer.from(rawTx, 'base64')[0].should.not.equal(0x81);\n    (tx as Transaction).isVersionedTransaction().should.equal(false);\n    Utils.isValidRawTransaction(rawTx).should.equal(true);\n  });\n});\n"]}

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

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

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

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

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

@@ -0,0 +1,167 @@
+"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 getBuilderFactory_1 = require("../getBuilderFactory");
+describe('Solana Confidential Transfer Builder - v1 per-op', () => {
+    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 destinationTokenAddress = 'ENn8a2tGMS9bR5XV7smGHJvNgzkyxJmnD2eUvQxY5jSP';
+    const authorityAddress = account.pub;
+    const zeroBytes36 = '00'.repeat(36);
+    const zeroBytes64 = '00'.repeat(64);
+    const proofDataHex = '00'.repeat(320);
+    const v1Config = {
+        computeUnitLimit: 200000,
+        heapSize: 32768,
+        loadedAccountsDataSizeLimit: 65536,
+        priorityFee: 5000,
+    };
+    const ctBuilder = () => {
+        const b = factory.getConfidentialTransferBuilder();
+        b.nonce(recentBlockHash).sender(account.pub).sign({ key: account.prv });
+        return b;
+    };
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const toV1 = (b) => b.version(1).transactionConfig(v1Config);
+    const assertV1 = (tx) => {
+        const wire = Buffer.from(tx.toBroadcastFormat(), 'base64');
+        wire[0].should.equal(0x81);
+        wire.length.should.be.lessThanOrEqual(4096);
+        tx.v1MessageBytes.should.be.an.instanceOf(Uint8Array);
+    };
+    it('should build a Deposit as a valid v1 transaction', async () => {
+        const b = ctBuilder();
+        b.confidentialDeposit({ tokenAddress, mintAddress, authorityAddress, amount: '1000000', decimals: 6 });
+        const tx = await toV1(b).build();
+        assertV1(tx);
+    });
+    it('should build a Withdraw (with equality + range proofs) as a valid v1 transaction', async () => {
+        const b = ctBuilder();
+        b.confidentialWithdraw({
+            tokenAddress,
+            mintAddress,
+            authorityAddress,
+            amount: '500000',
+            decimals: 6,
+            newDecryptableAvailableBalance: zeroBytes36,
+            equalityProofInstructionOffset: 1,
+            rangeProofInstructionOffset: 2,
+        })
+            .verifyEqualityProof({ proofData: proofDataHex })
+            .verifyRangeProof({ proofData: '00'.repeat(1000) });
+        const tx = await toV1(b).build();
+        assertV1(tx);
+    });
+    it('should force ApplyPendingBalance to instruction #1 even when added last', async () => {
+        const b = ctBuilder();
+        // Deliberately add Deposit first, then ApplyPendingBalance out of order.
+        b.confidentialDeposit({
+            tokenAddress,
+            mintAddress,
+            authorityAddress,
+            amount: '1000000',
+            decimals: 6,
+        }).applyPendingBalance({
+            tokenAddress,
+            authorityAddress,
+            expectedPendingBalanceCreditCounter: '2',
+            newDecryptableAvailableBalance: zeroBytes36,
+        });
+        const tx = await toV1(b).build();
+        assertV1(tx);
+        const instructions = tx.toJson().instructionsData;
+        instructions.should.have.length(2);
+        instructions[0].type.should.equal('ApplyPendingBalance');
+        instructions[1].type.should.equal('ConfidentialDeposit');
+    });
+    it('should build a private Transfer with all proofs as a valid v1 transaction', async () => {
+        const b = ctBuilder();
+        b.applyPendingBalance({
+            tokenAddress,
+            authorityAddress,
+            expectedPendingBalanceCreditCounter: '2',
+            newDecryptableAvailableBalance: zeroBytes36,
+        })
+            .verifyEqualityProof({ proofData: proofDataHex })
+            .verifyValidityProof({ proofData: proofDataHex })
+            .verifyRangeProof({ proofData: '00'.repeat(1000) })
+            .confidentialTransfer({
+            sourceTokenAddress: tokenAddress,
+            mintAddress,
+            destinationTokenAddress,
+            authorityAddress,
+            newSourceDecryptableAvailableBalance: zeroBytes36,
+            transferAmountAuditorCiphertextLo: zeroBytes64,
+            transferAmountAuditorCiphertextHi: zeroBytes64,
+            equalityProofInstructionOffset: 1,
+            ciphertextValidityProofInstructionOffset: 2,
+            rangeProofInstructionOffset: 3,
+        });
+        const tx = await toV1(b).build();
+        assertV1(tx);
+        const instructions = tx.toJson().instructionsData;
+        instructions[0].type.should.equal('ApplyPendingBalance');
+        instructions[4].type.should.equal('ConfidentialTransfer');
+    });
+    it('should build ConfigureAccount + VerifyPubkeyValidity as a valid v1 transaction', async () => {
+        const b = ctBuilder();
+        b.configureAccount({
+            tokenAddress,
+            mintAddress,
+            authorityAddress,
+            decryptableZeroBalance: zeroBytes36,
+            maximumPendingBalanceCreditCounter: '65536',
+            proofInstructionOffset: 1,
+        }).verifyPubkeyValidity({ proofData: proofDataHex });
+        const tx = await toV1(b).build();
+        assertV1(tx);
+    });
+    it('should build each verify-proof instruction through v1', async () => {
+        const b = ctBuilder();
+        b.verifyEqualityProof({ proofData: proofDataHex })
+            .verifyValidityProof({ proofData: proofDataHex })
+            .verifyRangeProof({ proofData: '00'.repeat(1000) })
+            .verifyPubkeyValidity({ proofData: proofDataHex });
+        const tx = await toV1(b).build();
+        assertV1(tx);
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"confidentialTransferV1Ops.js","sourceRoot":"","sources":["../../../../../test/unit/transactionBuilder/confidentialTransferV1Ops.ts"],"names":[],"mappings":"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","sourcesContent":["import 'should';\nimport { KeyPair, Transaction } from '../../../src';\nimport * as testData from '../../resources/sol';\nimport { getBuilderFactory } from '../getBuilderFactory';\n\ndescribe('Solana Confidential Transfer Builder - v1 per-op', () => {\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 destinationTokenAddress = 'ENn8a2tGMS9bR5XV7smGHJvNgzkyxJmnD2eUvQxY5jSP';\n  const authorityAddress = account.pub;\n\n  const zeroBytes36 = '00'.repeat(36);\n  const zeroBytes64 = '00'.repeat(64);\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 ctBuilder = () => {\n    const b = factory.getConfidentialTransferBuilder();\n    b.nonce(recentBlockHash).sender(account.pub).sign({ key: account.prv });\n    return b;\n  };\n\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  const toV1 = (b: any) => b.version(1).transactionConfig(v1Config);\n\n  const assertV1 = (tx: Transaction) => {\n    const wire = Buffer.from((tx as Transaction).toBroadcastFormat(), 'base64');\n    wire[0].should.equal(0x81);\n    wire.length.should.be.lessThanOrEqual(4096);\n    (tx as Transaction).v1MessageBytes!.should.be.an.instanceOf(Uint8Array);\n  };\n\n  it('should build a Deposit as a valid v1 transaction', async () => {\n    const b = ctBuilder();\n    b.confidentialDeposit({ tokenAddress, mintAddress, authorityAddress, amount: '1000000', decimals: 6 });\n    const tx = await toV1(b).build();\n    assertV1(tx);\n  });\n\n  it('should build a Withdraw (with equality + range proofs) as a valid v1 transaction', async () => {\n    const b = ctBuilder();\n    b.confidentialWithdraw({\n      tokenAddress,\n      mintAddress,\n      authorityAddress,\n      amount: '500000',\n      decimals: 6,\n      newDecryptableAvailableBalance: zeroBytes36,\n      equalityProofInstructionOffset: 1,\n      rangeProofInstructionOffset: 2,\n    })\n      .verifyEqualityProof({ proofData: proofDataHex })\n      .verifyRangeProof({ proofData: '00'.repeat(1000) });\n    const tx = await toV1(b).build();\n    assertV1(tx);\n  });\n\n  it('should force ApplyPendingBalance to instruction #1 even when added last', async () => {\n    const b = ctBuilder();\n    // Deliberately add Deposit first, then ApplyPendingBalance out of order.\n    b.confidentialDeposit({\n      tokenAddress,\n      mintAddress,\n      authorityAddress,\n      amount: '1000000',\n      decimals: 6,\n    }).applyPendingBalance({\n      tokenAddress,\n      authorityAddress,\n      expectedPendingBalanceCreditCounter: '2',\n      newDecryptableAvailableBalance: zeroBytes36,\n    });\n    const tx = await toV1(b).build();\n    assertV1(tx);\n    const instructions = tx.toJson().instructionsData;\n    instructions.should.have.length(2);\n    instructions[0].type.should.equal('ApplyPendingBalance');\n    instructions[1].type.should.equal('ConfidentialDeposit');\n  });\n\n  it('should build a private Transfer with all proofs as a valid v1 transaction', async () => {\n    const b = ctBuilder();\n    b.applyPendingBalance({\n      tokenAddress,\n      authorityAddress,\n      expectedPendingBalanceCreditCounter: '2',\n      newDecryptableAvailableBalance: zeroBytes36,\n    })\n      .verifyEqualityProof({ proofData: proofDataHex })\n      .verifyValidityProof({ proofData: proofDataHex })\n      .verifyRangeProof({ proofData: '00'.repeat(1000) })\n      .confidentialTransfer({\n        sourceTokenAddress: tokenAddress,\n        mintAddress,\n        destinationTokenAddress,\n        authorityAddress,\n        newSourceDecryptableAvailableBalance: zeroBytes36,\n        transferAmountAuditorCiphertextLo: zeroBytes64,\n        transferAmountAuditorCiphertextHi: zeroBytes64,\n        equalityProofInstructionOffset: 1,\n        ciphertextValidityProofInstructionOffset: 2,\n        rangeProofInstructionOffset: 3,\n      });\n    const tx = await toV1(b).build();\n    assertV1(tx);\n    const instructions = tx.toJson().instructionsData;\n    instructions[0].type.should.equal('ApplyPendingBalance');\n    instructions[4].type.should.equal('ConfidentialTransfer');\n  });\n\n  it('should build ConfigureAccount + VerifyPubkeyValidity as a valid v1 transaction', async () => {\n    const b = ctBuilder();\n    b.configureAccount({\n      tokenAddress,\n      mintAddress,\n      authorityAddress,\n      decryptableZeroBalance: zeroBytes36,\n      maximumPendingBalanceCreditCounter: '65536',\n      proofInstructionOffset: 1,\n    }).verifyPubkeyValidity({ proofData: proofDataHex });\n    const tx = await toV1(b).build();\n    assertV1(tx);\n  });\n\n  it('should build each verify-proof instruction through v1', async () => {\n    const b = ctBuilder();\n    b.verifyEqualityProof({ proofData: proofDataHex })\n      .verifyValidityProof({ proofData: proofDataHex })\n      .verifyRangeProof({ proofData: '00'.repeat(1000) })\n      .verifyPubkeyValidity({ proofData: proofDataHex });\n    const tx = await toV1(b).build();\n    assertV1(tx);\n  });\n});\n"]}