@bitgo-beta/sdk-coin-sol 7.6.4-beta.44 → 7.6.4-beta.441

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

@@ -0,0 +1,333 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const src_1 = require("../../../src");
+const should_1 = __importDefault(require("should"));
+const testData = __importStar(require("../../resources/sol"));
+const sdk_core_1 = require("@bitgo-beta/sdk-core");
+const getBuilderFactory_1 = require("../getBuilderFactory");
+const constants_1 = require("../../../src/lib/constants");
+describe('Sol Close ATA Builder', () => {
+    const factory = (0, getBuilderFactory_1.getBuilderFactory)('tsol');
+    const recentBlockHash = 'GHtXQBsoZHVnNFa9YevAzFr17DJjgHXk3ycTKD5xD3Zi';
+    const account = new src_1.KeyPair(testData.authAccount).getKeys();
+    const nonceAccount = new src_1.KeyPair(testData.nonceAccount).getKeys();
+    const account2 = new src_1.KeyPair(testData.authAccount2).getKeys();
+    // ATA addresses (valid Solana addresses from test fixtures)
+    const ataAddress1 = nonceAccount.pub;
+    const ataAddress2 = account2.pub;
+    const destinationAddress = account.pub;
+    const closeAtaBuilder = () => {
+        const txBuilder = factory.getCloseAtaInitializationBuilder();
+        txBuilder.nonce(recentBlockHash);
+        txBuilder.sender(account.pub);
+        return txBuilder;
+    };
+    describe('Single ATA close (backward compatible)', () => {
+        describe('Succeed', () => {
+            it('build a single close ATA tx unsigned', async () => {
+                const txBuilder = closeAtaBuilder();
+                txBuilder.accountAddress(ataAddress1);
+                txBuilder.destinationAddress(destinationAddress);
+                txBuilder.authorityAddress(account.pub);
+                const tx = await txBuilder.build();
+                tx.type.should.equal(sdk_core_1.TransactionType.CloseAssociatedTokenAccount);
+                const rawTx = tx.toBroadcastFormat();
+                should_1.default.equal(src_1.Utils.isValidRawTransaction(rawTx), true);
+                const instructions = tx.toJson().instructionsData;
+                instructions.length.should.equal(1);
+                instructions[0].type.should.equal(constants_1.InstructionBuilderTypes.CloseAssociatedTokenAccount);
+                instructions[0].params.accountAddress.should.equal(ataAddress1);
+                instructions[0].params.destinationAddress.should.equal(destinationAddress);
+                instructions[0].params.authorityAddress.should.equal(account.pub);
+            });
+            it('build a single close ATA tx signed', async () => {
+                const txBuilder = closeAtaBuilder();
+                txBuilder.accountAddress(ataAddress1);
+                txBuilder.destinationAddress(destinationAddress);
+                txBuilder.authorityAddress(account.pub);
+                txBuilder.sign({ key: account.prv });
+                const tx = await txBuilder.build();
+                tx.type.should.equal(sdk_core_1.TransactionType.CloseAssociatedTokenAccount);
+                const rawTx = tx.toBroadcastFormat();
+                should_1.default.equal(src_1.Utils.isValidRawTransaction(rawTx), true);
+            });
+            it('build a single close ATA tx with durable nonce', async () => {
+                const txBuilder = closeAtaBuilder();
+                txBuilder.nonce(recentBlockHash, {
+                    walletNonceAddress: nonceAccount.pub,
+                    authWalletAddress: account.pub,
+                });
+                txBuilder.accountAddress(ataAddress2);
+                txBuilder.destinationAddress(destinationAddress);
+                txBuilder.authorityAddress(account.pub);
+                const tx = await txBuilder.build();
+                tx.type.should.equal(sdk_core_1.TransactionType.CloseAssociatedTokenAccount);
+                const rawTx = tx.toBroadcastFormat();
+                should_1.default.equal(src_1.Utils.isValidRawTransaction(rawTx), true);
+            });
+        });
+        describe('Fail', () => {
+            it('should fail when account address is not set', async () => {
+                const txBuilder = closeAtaBuilder();
+                txBuilder.destinationAddress(destinationAddress);
+                txBuilder.authorityAddress(account.pub);
+                await txBuilder.build().should.rejectedWith('Account Address must be set before building the transaction');
+            });
+            it('should fail when destination address is not set', async () => {
+                const txBuilder = closeAtaBuilder();
+                txBuilder.accountAddress(ataAddress1);
+                txBuilder.authorityAddress(account.pub);
+                await txBuilder.build().should.rejectedWith('Destination Address must be set before building the transaction');
+            });
+            it('should fail when authority address is not set', async () => {
+                const txBuilder = closeAtaBuilder();
+                txBuilder.accountAddress(ataAddress1);
+                txBuilder.destinationAddress(destinationAddress);
+                await txBuilder.build().should.rejectedWith('Authority Address must be set before building the transaction');
+            });
+            it('should fail when account address equals destination address', async () => {
+                const txBuilder = closeAtaBuilder();
+                txBuilder.accountAddress(destinationAddress);
+                txBuilder.destinationAddress(destinationAddress);
+                txBuilder.authorityAddress(account.pub);
+                await txBuilder
+                    .build()
+                    .should.rejectedWith('Account address to close cannot be the same as the destination address');
+            });
+            it('should fail with invalid account address', () => {
+                const txBuilder = closeAtaBuilder();
+                (0, should_1.default)(() => txBuilder.accountAddress('invalidAddress')).throwError();
+            });
+            it('should fail with invalid destination address', () => {
+                const txBuilder = closeAtaBuilder();
+                (0, should_1.default)(() => txBuilder.destinationAddress('invalidAddress')).throwError();
+            });
+            it('should fail with invalid authority address', () => {
+                const txBuilder = closeAtaBuilder();
+                (0, should_1.default)(() => txBuilder.authorityAddress('invalidAddress')).throwError();
+            });
+            it('should fail when nonce is not provided', async () => {
+                const txBuilder = factory.getCloseAtaInitializationBuilder();
+                txBuilder.sender(account.pub);
+                txBuilder.accountAddress(ataAddress1);
+                txBuilder.destinationAddress(destinationAddress);
+                txBuilder.authorityAddress(account.pub);
+                await txBuilder.build().should.rejectedWith('Invalid transaction: missing nonce blockhash');
+            });
+            it('should fail when sender is not provided', async () => {
+                const txBuilder = factory.getCloseAtaInitializationBuilder();
+                txBuilder.nonce(recentBlockHash);
+                txBuilder.accountAddress(ataAddress1);
+                txBuilder.destinationAddress(destinationAddress);
+                txBuilder.authorityAddress(account.pub);
+                await txBuilder.build().should.rejectedWith('Invalid transaction: missing sender');
+            });
+        });
+    });
+    describe('Bulk ATA close (addCloseAtaInstruction)', () => {
+        describe('Succeed', () => {
+            it('build a bulk close ATA tx with multiple ATAs unsigned', async () => {
+                const txBuilder = closeAtaBuilder();
+                txBuilder.addCloseAtaInstruction(ataAddress1, destinationAddress, account.pub);
+                txBuilder.addCloseAtaInstruction(ataAddress2, destinationAddress, account.pub);
+                const tx = await txBuilder.build();
+                tx.type.should.equal(sdk_core_1.TransactionType.CloseAssociatedTokenAccount);
+                const rawTx = tx.toBroadcastFormat();
+                should_1.default.equal(src_1.Utils.isValidRawTransaction(rawTx), true);
+                const instructions = tx.toJson().instructionsData;
+                instructions.length.should.equal(2);
+                instructions[0].type.should.equal(constants_1.InstructionBuilderTypes.CloseAssociatedTokenAccount);
+                instructions[0].params.accountAddress.should.equal(ataAddress1);
+                instructions[0].params.destinationAddress.should.equal(destinationAddress);
+                instructions[0].params.authorityAddress.should.equal(account.pub);
+                instructions[1].type.should.equal(constants_1.InstructionBuilderTypes.CloseAssociatedTokenAccount);
+                instructions[1].params.accountAddress.should.equal(ataAddress2);
+                instructions[1].params.destinationAddress.should.equal(destinationAddress);
+                instructions[1].params.authorityAddress.should.equal(account.pub);
+            });
+            it('build a bulk close ATA tx signed', async () => {
+                const txBuilder = closeAtaBuilder();
+                txBuilder.addCloseAtaInstruction(ataAddress1, destinationAddress, account.pub);
+                txBuilder.addCloseAtaInstruction(ataAddress2, destinationAddress, account.pub);
+                txBuilder.sign({ key: account.prv });
+                const tx = await txBuilder.build();
+                tx.type.should.equal(sdk_core_1.TransactionType.CloseAssociatedTokenAccount);
+                const rawTx = tx.toBroadcastFormat();
+                should_1.default.equal(src_1.Utils.isValidRawTransaction(rawTx), true);
+                const instructions = tx.toJson().instructionsData;
+                instructions.length.should.equal(2);
+            });
+            it('build a single close using addCloseAtaInstruction', async () => {
+                const txBuilder = closeAtaBuilder();
+                txBuilder.addCloseAtaInstruction(ataAddress1, destinationAddress, account.pub);
+                const tx = await txBuilder.build();
+                tx.type.should.equal(sdk_core_1.TransactionType.CloseAssociatedTokenAccount);
+                const instructions = tx.toJson().instructionsData;
+                instructions.length.should.equal(1);
+                instructions[0].params.accountAddress.should.equal(ataAddress1);
+            });
+            it('all close instructions have same destination (root wallet)', async () => {
+                const txBuilder = closeAtaBuilder();
+                txBuilder.addCloseAtaInstruction(ataAddress1, destinationAddress, account.pub);
+                txBuilder.addCloseAtaInstruction(ataAddress2, destinationAddress, account.pub);
+                const tx = await txBuilder.build();
+                const instructions = tx.toJson().instructionsData;
+                for (const instruction of instructions) {
+                    instruction.params.destinationAddress.should.equal(destinationAddress);
+                }
+            });
+        });
+        describe('Fail', () => {
+            it('should fail with duplicate ATA address', () => {
+                const txBuilder = closeAtaBuilder();
+                txBuilder.addCloseAtaInstruction(ataAddress1, destinationAddress, account.pub);
+                (0, should_1.default)(() => txBuilder.addCloseAtaInstruction(ataAddress1, destinationAddress, account.pub)).throwError('Duplicate ATA address: ' + ataAddress1);
+            });
+            it('should fail when account equals destination', () => {
+                const txBuilder = closeAtaBuilder();
+                (0, should_1.default)(() => txBuilder.addCloseAtaInstruction(destinationAddress, destinationAddress, account.pub)).throwError('Account address to close cannot be the same as the destination address');
+            });
+            it('should fail with invalid account address', () => {
+                const txBuilder = closeAtaBuilder();
+                (0, should_1.default)(() => txBuilder.addCloseAtaInstruction('invalid', destinationAddress, account.pub)).throwError();
+            });
+            it('should fail with invalid destination address', () => {
+                const txBuilder = closeAtaBuilder();
+                (0, should_1.default)(() => txBuilder.addCloseAtaInstruction(ataAddress1, 'invalid', account.pub)).throwError();
+            });
+            it('should fail with invalid authority address', () => {
+                const txBuilder = closeAtaBuilder();
+                (0, should_1.default)(() => txBuilder.addCloseAtaInstruction(ataAddress1, destinationAddress, 'invalid')).throwError();
+            });
+        });
+    });
+    describe('Mixing single-ATA and bulk APIs', () => {
+        const mixErrorMessage = /Cannot mix single-ATA API .* with bulk-ATA API/;
+        it('should throw when single-ATA setter is called after addCloseAtaInstruction (accountAddress)', () => {
+            const txBuilder = closeAtaBuilder();
+            txBuilder.addCloseAtaInstruction(ataAddress1, destinationAddress, account.pub);
+            (0, should_1.default)(() => txBuilder.accountAddress(ataAddress2)).throw(mixErrorMessage);
+        });
+        it('should throw when single-ATA setter is called after addCloseAtaInstruction (destinationAddress)', () => {
+            const txBuilder = closeAtaBuilder();
+            txBuilder.addCloseAtaInstruction(ataAddress1, destinationAddress, account.pub);
+            (0, should_1.default)(() => txBuilder.destinationAddress(account2.pub)).throw(mixErrorMessage);
+        });
+        it('should throw when single-ATA setter is called after addCloseAtaInstruction (authorityAddress)', () => {
+            const txBuilder = closeAtaBuilder();
+            txBuilder.addCloseAtaInstruction(ataAddress1, destinationAddress, account.pub);
+            (0, should_1.default)(() => txBuilder.authorityAddress(account2.pub)).throw(mixErrorMessage);
+        });
+        it('should throw when addCloseAtaInstruction is called after single-ATA setter', () => {
+            const txBuilder = closeAtaBuilder();
+            txBuilder.accountAddress(ataAddress1);
+            (0, should_1.default)(() => txBuilder.addCloseAtaInstruction(ataAddress2, destinationAddress, account.pub)).throw(mixErrorMessage);
+        });
+        it('should not corrupt the first bulk entry when bulk-then-single is rejected', () => {
+            const txBuilder = closeAtaBuilder();
+            txBuilder.addCloseAtaInstruction(ataAddress1, destinationAddress, account.pub);
+            try {
+                txBuilder.accountAddress(ataAddress2);
+            }
+            catch {
+                /* expected */
+            }
+            // First entry must still be intact after the rejected mix attempt.
+            const entries = txBuilder
+                ._closeAtaEntries;
+            entries.length.should.equal(1);
+            entries[0].accountAddress.should.equal(ataAddress1);
+        });
+    });
+    describe('From raw transaction', () => {
+        it('should parse a single close ATA tx from raw and rebuild', async () => {
+            // Build a tx first
+            const txBuilder = closeAtaBuilder();
+            txBuilder.accountAddress(ataAddress1);
+            txBuilder.destinationAddress(destinationAddress);
+            txBuilder.authorityAddress(account.pub);
+            const tx = await txBuilder.build();
+            const rawTx = tx.toBroadcastFormat();
+            // Parse from raw
+            const rebuiltBuilder = factory.from(rawTx);
+            const rebuiltTx = await rebuiltBuilder.build();
+            rebuiltTx.type.should.equal(sdk_core_1.TransactionType.CloseAssociatedTokenAccount);
+            const instructions = rebuiltTx.toJson().instructionsData;
+            instructions.length.should.equal(1);
+            instructions[0].type.should.equal(constants_1.InstructionBuilderTypes.CloseAssociatedTokenAccount);
+            instructions[0].params.accountAddress.should.equal(ataAddress1);
+            instructions[0].params.destinationAddress.should.equal(destinationAddress);
+            instructions[0].params.authorityAddress.should.equal(account.pub);
+        });
+        it('should parse a bulk close ATA tx from raw and rebuild', async () => {
+            // Build a bulk tx first
+            const txBuilder = closeAtaBuilder();
+            txBuilder.addCloseAtaInstruction(ataAddress1, destinationAddress, account.pub);
+            txBuilder.addCloseAtaInstruction(ataAddress2, destinationAddress, account.pub);
+            const tx = await txBuilder.build();
+            const rawTx = tx.toBroadcastFormat();
+            // Parse from raw
+            const rebuiltBuilder = factory.from(rawTx);
+            const rebuiltTx = await rebuiltBuilder.build();
+            rebuiltTx.type.should.equal(sdk_core_1.TransactionType.CloseAssociatedTokenAccount);
+            const instructions = rebuiltTx.toJson().instructionsData;
+            instructions.length.should.equal(2);
+            instructions[0].params.accountAddress.should.equal(ataAddress1);
+            instructions[1].params.accountAddress.should.equal(ataAddress2);
+        });
+        it('should reject legacy single-ATA setters on a parsed bulk close tx', async () => {
+            const txBuilder = closeAtaBuilder();
+            txBuilder.addCloseAtaInstruction(ataAddress1, destinationAddress, account.pub);
+            txBuilder.addCloseAtaInstruction(ataAddress2, destinationAddress, account.pub);
+            const rawTx = (await txBuilder.build()).toBroadcastFormat();
+            const parsed = factory.from(rawTx);
+            const mixErrorMessage = /Cannot mix single-ATA API .* with bulk-ATA API/;
+            (0, should_1.default)(() => parsed.accountAddress(ataAddress1)).throw(mixErrorMessage);
+            (0, should_1.default)(() => parsed.destinationAddress(destinationAddress)).throw(mixErrorMessage);
+            (0, should_1.default)(() => parsed.authorityAddress(account.pub)).throw(mixErrorMessage);
+        });
+        it('should parse existing close ATA raw tx from test resources', async () => {
+            const txnBuilder = factory.from(testData.TRANSFER_UNSIGNED_TX_CLOSE_ATA);
+            should_1.default.exist(txnBuilder);
+            const tx = await txnBuilder.build();
+            tx.type.should.equal(sdk_core_1.TransactionType.CloseAssociatedTokenAccount);
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"closeAtaBuilder.js","sourceRoot":"","sources":["../../../../../test/unit/transactionBuilder/closeAtaBuilder.ts"],"names":[],"mappings":"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","sourcesContent":["import { KeyPair, Utils } from '../../../src';\nimport { CloseAtaBuilder } from '../../../src/lib/closeAtaBuilder';\nimport should from 'should';\nimport * as testData from '../../resources/sol';\nimport { TransactionType } from '@bitgo-beta/sdk-core';\nimport { getBuilderFactory } from '../getBuilderFactory';\nimport { InstructionBuilderTypes } from '../../../src/lib/constants';\n\ndescribe('Sol Close ATA Builder', () => {\n  const factory = getBuilderFactory('tsol');\n  const recentBlockHash = 'GHtXQBsoZHVnNFa9YevAzFr17DJjgHXk3ycTKD5xD3Zi';\n\n  const account = new KeyPair(testData.authAccount).getKeys();\n  const nonceAccount = new KeyPair(testData.nonceAccount).getKeys();\n  const account2 = new KeyPair(testData.authAccount2).getKeys();\n\n  // ATA addresses (valid Solana addresses from test fixtures)\n  const ataAddress1 = nonceAccount.pub;\n  const ataAddress2 = account2.pub;\n  const destinationAddress = account.pub;\n\n  const closeAtaBuilder = () => {\n    const txBuilder = factory.getCloseAtaInitializationBuilder();\n    txBuilder.nonce(recentBlockHash);\n    txBuilder.sender(account.pub);\n    return txBuilder;\n  };\n\n  describe('Single ATA close (backward compatible)', () => {\n    describe('Succeed', () => {\n      it('build a single close ATA tx unsigned', async () => {\n        const txBuilder = closeAtaBuilder();\n        txBuilder.accountAddress(ataAddress1);\n        txBuilder.destinationAddress(destinationAddress);\n        txBuilder.authorityAddress(account.pub);\n\n        const tx = await txBuilder.build();\n        tx.type.should.equal(TransactionType.CloseAssociatedTokenAccount);\n\n        const rawTx = tx.toBroadcastFormat();\n        should.equal(Utils.isValidRawTransaction(rawTx), true);\n\n        const instructions = tx.toJson().instructionsData;\n        instructions.length.should.equal(1);\n        instructions[0].type.should.equal(InstructionBuilderTypes.CloseAssociatedTokenAccount);\n        instructions[0].params.accountAddress.should.equal(ataAddress1);\n        instructions[0].params.destinationAddress.should.equal(destinationAddress);\n        instructions[0].params.authorityAddress.should.equal(account.pub);\n      });\n\n      it('build a single close ATA tx signed', async () => {\n        const txBuilder = closeAtaBuilder();\n        txBuilder.accountAddress(ataAddress1);\n        txBuilder.destinationAddress(destinationAddress);\n        txBuilder.authorityAddress(account.pub);\n        txBuilder.sign({ key: account.prv });\n\n        const tx = await txBuilder.build();\n        tx.type.should.equal(TransactionType.CloseAssociatedTokenAccount);\n\n        const rawTx = tx.toBroadcastFormat();\n        should.equal(Utils.isValidRawTransaction(rawTx), true);\n      });\n\n      it('build a single close ATA tx with durable nonce', async () => {\n        const txBuilder = closeAtaBuilder();\n        txBuilder.nonce(recentBlockHash, {\n          walletNonceAddress: nonceAccount.pub,\n          authWalletAddress: account.pub,\n        });\n        txBuilder.accountAddress(ataAddress2);\n        txBuilder.destinationAddress(destinationAddress);\n        txBuilder.authorityAddress(account.pub);\n\n        const tx = await txBuilder.build();\n        tx.type.should.equal(TransactionType.CloseAssociatedTokenAccount);\n\n        const rawTx = tx.toBroadcastFormat();\n        should.equal(Utils.isValidRawTransaction(rawTx), true);\n      });\n    });\n\n    describe('Fail', () => {\n      it('should fail when account address is not set', async () => {\n        const txBuilder = closeAtaBuilder();\n        txBuilder.destinationAddress(destinationAddress);\n        txBuilder.authorityAddress(account.pub);\n\n        await txBuilder.build().should.rejectedWith('Account Address must be set before building the transaction');\n      });\n\n      it('should fail when destination address is not set', async () => {\n        const txBuilder = closeAtaBuilder();\n        txBuilder.accountAddress(ataAddress1);\n        txBuilder.authorityAddress(account.pub);\n\n        await txBuilder.build().should.rejectedWith('Destination Address must be set before building the transaction');\n      });\n\n      it('should fail when authority address is not set', async () => {\n        const txBuilder = closeAtaBuilder();\n        txBuilder.accountAddress(ataAddress1);\n        txBuilder.destinationAddress(destinationAddress);\n\n        await txBuilder.build().should.rejectedWith('Authority Address must be set before building the transaction');\n      });\n\n      it('should fail when account address equals destination address', async () => {\n        const txBuilder = closeAtaBuilder();\n        txBuilder.accountAddress(destinationAddress);\n        txBuilder.destinationAddress(destinationAddress);\n        txBuilder.authorityAddress(account.pub);\n\n        await txBuilder\n          .build()\n          .should.rejectedWith('Account address to close cannot be the same as the destination address');\n      });\n\n      it('should fail with invalid account address', () => {\n        const txBuilder = closeAtaBuilder();\n        should(() => txBuilder.accountAddress('invalidAddress')).throwError();\n      });\n\n      it('should fail with invalid destination address', () => {\n        const txBuilder = closeAtaBuilder();\n        should(() => txBuilder.destinationAddress('invalidAddress')).throwError();\n      });\n\n      it('should fail with invalid authority address', () => {\n        const txBuilder = closeAtaBuilder();\n        should(() => txBuilder.authorityAddress('invalidAddress')).throwError();\n      });\n\n      it('should fail when nonce is not provided', async () => {\n        const txBuilder = factory.getCloseAtaInitializationBuilder();\n        txBuilder.sender(account.pub);\n        txBuilder.accountAddress(ataAddress1);\n        txBuilder.destinationAddress(destinationAddress);\n        txBuilder.authorityAddress(account.pub);\n\n        await txBuilder.build().should.rejectedWith('Invalid transaction: missing nonce blockhash');\n      });\n\n      it('should fail when sender is not provided', async () => {\n        const txBuilder = factory.getCloseAtaInitializationBuilder();\n        txBuilder.nonce(recentBlockHash);\n        txBuilder.accountAddress(ataAddress1);\n        txBuilder.destinationAddress(destinationAddress);\n        txBuilder.authorityAddress(account.pub);\n\n        await txBuilder.build().should.rejectedWith('Invalid transaction: missing sender');\n      });\n    });\n  });\n\n  describe('Bulk ATA close (addCloseAtaInstruction)', () => {\n    describe('Succeed', () => {\n      it('build a bulk close ATA tx with multiple ATAs unsigned', async () => {\n        const txBuilder = closeAtaBuilder();\n        txBuilder.addCloseAtaInstruction(ataAddress1, destinationAddress, account.pub);\n        txBuilder.addCloseAtaInstruction(ataAddress2, destinationAddress, account.pub);\n\n        const tx = await txBuilder.build();\n        tx.type.should.equal(TransactionType.CloseAssociatedTokenAccount);\n\n        const rawTx = tx.toBroadcastFormat();\n        should.equal(Utils.isValidRawTransaction(rawTx), true);\n\n        const instructions = tx.toJson().instructionsData;\n        instructions.length.should.equal(2);\n\n        instructions[0].type.should.equal(InstructionBuilderTypes.CloseAssociatedTokenAccount);\n        instructions[0].params.accountAddress.should.equal(ataAddress1);\n        instructions[0].params.destinationAddress.should.equal(destinationAddress);\n        instructions[0].params.authorityAddress.should.equal(account.pub);\n\n        instructions[1].type.should.equal(InstructionBuilderTypes.CloseAssociatedTokenAccount);\n        instructions[1].params.accountAddress.should.equal(ataAddress2);\n        instructions[1].params.destinationAddress.should.equal(destinationAddress);\n        instructions[1].params.authorityAddress.should.equal(account.pub);\n      });\n\n      it('build a bulk close ATA tx signed', async () => {\n        const txBuilder = closeAtaBuilder();\n        txBuilder.addCloseAtaInstruction(ataAddress1, destinationAddress, account.pub);\n        txBuilder.addCloseAtaInstruction(ataAddress2, destinationAddress, account.pub);\n        txBuilder.sign({ key: account.prv });\n\n        const tx = await txBuilder.build();\n        tx.type.should.equal(TransactionType.CloseAssociatedTokenAccount);\n\n        const rawTx = tx.toBroadcastFormat();\n        should.equal(Utils.isValidRawTransaction(rawTx), true);\n\n        const instructions = tx.toJson().instructionsData;\n        instructions.length.should.equal(2);\n      });\n\n      it('build a single close using addCloseAtaInstruction', async () => {\n        const txBuilder = closeAtaBuilder();\n        txBuilder.addCloseAtaInstruction(ataAddress1, destinationAddress, account.pub);\n\n        const tx = await txBuilder.build();\n        tx.type.should.equal(TransactionType.CloseAssociatedTokenAccount);\n\n        const instructions = tx.toJson().instructionsData;\n        instructions.length.should.equal(1);\n        instructions[0].params.accountAddress.should.equal(ataAddress1);\n      });\n\n      it('all close instructions have same destination (root wallet)', async () => {\n        const txBuilder = closeAtaBuilder();\n        txBuilder.addCloseAtaInstruction(ataAddress1, destinationAddress, account.pub);\n        txBuilder.addCloseAtaInstruction(ataAddress2, destinationAddress, account.pub);\n\n        const tx = await txBuilder.build();\n        const instructions = tx.toJson().instructionsData;\n\n        for (const instruction of instructions) {\n          instruction.params.destinationAddress.should.equal(destinationAddress);\n        }\n      });\n    });\n\n    describe('Fail', () => {\n      it('should fail with duplicate ATA address', () => {\n        const txBuilder = closeAtaBuilder();\n        txBuilder.addCloseAtaInstruction(ataAddress1, destinationAddress, account.pub);\n\n        should(() => txBuilder.addCloseAtaInstruction(ataAddress1, destinationAddress, account.pub)).throwError(\n          'Duplicate ATA address: ' + ataAddress1\n        );\n      });\n\n      it('should fail when account equals destination', () => {\n        const txBuilder = closeAtaBuilder();\n\n        should(() => txBuilder.addCloseAtaInstruction(destinationAddress, destinationAddress, account.pub)).throwError(\n          'Account address to close cannot be the same as the destination address'\n        );\n      });\n\n      it('should fail with invalid account address', () => {\n        const txBuilder = closeAtaBuilder();\n        should(() => txBuilder.addCloseAtaInstruction('invalid', destinationAddress, account.pub)).throwError();\n      });\n\n      it('should fail with invalid destination address', () => {\n        const txBuilder = closeAtaBuilder();\n        should(() => txBuilder.addCloseAtaInstruction(ataAddress1, 'invalid', account.pub)).throwError();\n      });\n\n      it('should fail with invalid authority address', () => {\n        const txBuilder = closeAtaBuilder();\n        should(() => txBuilder.addCloseAtaInstruction(ataAddress1, destinationAddress, 'invalid')).throwError();\n      });\n    });\n  });\n\n  describe('Mixing single-ATA and bulk APIs', () => {\n    const mixErrorMessage = /Cannot mix single-ATA API .* with bulk-ATA API/;\n\n    it('should throw when single-ATA setter is called after addCloseAtaInstruction (accountAddress)', () => {\n      const txBuilder = closeAtaBuilder();\n      txBuilder.addCloseAtaInstruction(ataAddress1, destinationAddress, account.pub);\n      should(() => txBuilder.accountAddress(ataAddress2)).throw(mixErrorMessage);\n    });\n\n    it('should throw when single-ATA setter is called after addCloseAtaInstruction (destinationAddress)', () => {\n      const txBuilder = closeAtaBuilder();\n      txBuilder.addCloseAtaInstruction(ataAddress1, destinationAddress, account.pub);\n      should(() => txBuilder.destinationAddress(account2.pub)).throw(mixErrorMessage);\n    });\n\n    it('should throw when single-ATA setter is called after addCloseAtaInstruction (authorityAddress)', () => {\n      const txBuilder = closeAtaBuilder();\n      txBuilder.addCloseAtaInstruction(ataAddress1, destinationAddress, account.pub);\n      should(() => txBuilder.authorityAddress(account2.pub)).throw(mixErrorMessage);\n    });\n\n    it('should throw when addCloseAtaInstruction is called after single-ATA setter', () => {\n      const txBuilder = closeAtaBuilder();\n      txBuilder.accountAddress(ataAddress1);\n      should(() => txBuilder.addCloseAtaInstruction(ataAddress2, destinationAddress, account.pub)).throw(\n        mixErrorMessage\n      );\n    });\n\n    it('should not corrupt the first bulk entry when bulk-then-single is rejected', () => {\n      const txBuilder = closeAtaBuilder();\n      txBuilder.addCloseAtaInstruction(ataAddress1, destinationAddress, account.pub);\n      try {\n        txBuilder.accountAddress(ataAddress2);\n      } catch {\n        /* expected */\n      }\n      // First entry must still be intact after the rejected mix attempt.\n      const entries = (txBuilder as unknown as { _closeAtaEntries: Array<{ accountAddress: string }> })\n        ._closeAtaEntries;\n      entries.length.should.equal(1);\n      entries[0].accountAddress.should.equal(ataAddress1);\n    });\n  });\n\n  describe('From raw transaction', () => {\n    it('should parse a single close ATA tx from raw and rebuild', async () => {\n      // Build a tx first\n      const txBuilder = closeAtaBuilder();\n      txBuilder.accountAddress(ataAddress1);\n      txBuilder.destinationAddress(destinationAddress);\n      txBuilder.authorityAddress(account.pub);\n\n      const tx = await txBuilder.build();\n      const rawTx = tx.toBroadcastFormat();\n\n      // Parse from raw\n      const rebuiltBuilder = factory.from(rawTx);\n      const rebuiltTx = await rebuiltBuilder.build();\n\n      rebuiltTx.type.should.equal(TransactionType.CloseAssociatedTokenAccount);\n\n      const instructions = rebuiltTx.toJson().instructionsData;\n      instructions.length.should.equal(1);\n      instructions[0].type.should.equal(InstructionBuilderTypes.CloseAssociatedTokenAccount);\n      instructions[0].params.accountAddress.should.equal(ataAddress1);\n      instructions[0].params.destinationAddress.should.equal(destinationAddress);\n      instructions[0].params.authorityAddress.should.equal(account.pub);\n    });\n\n    it('should parse a bulk close ATA tx from raw and rebuild', async () => {\n      // Build a bulk tx first\n      const txBuilder = closeAtaBuilder();\n      txBuilder.addCloseAtaInstruction(ataAddress1, destinationAddress, account.pub);\n      txBuilder.addCloseAtaInstruction(ataAddress2, destinationAddress, account.pub);\n\n      const tx = await txBuilder.build();\n      const rawTx = tx.toBroadcastFormat();\n\n      // Parse from raw\n      const rebuiltBuilder = factory.from(rawTx);\n      const rebuiltTx = await rebuiltBuilder.build();\n\n      rebuiltTx.type.should.equal(TransactionType.CloseAssociatedTokenAccount);\n\n      const instructions = rebuiltTx.toJson().instructionsData;\n      instructions.length.should.equal(2);\n      instructions[0].params.accountAddress.should.equal(ataAddress1);\n      instructions[1].params.accountAddress.should.equal(ataAddress2);\n    });\n\n    it('should reject legacy single-ATA setters on a parsed bulk close tx', async () => {\n      const txBuilder = closeAtaBuilder();\n      txBuilder.addCloseAtaInstruction(ataAddress1, destinationAddress, account.pub);\n      txBuilder.addCloseAtaInstruction(ataAddress2, destinationAddress, account.pub);\n      const rawTx = (await txBuilder.build()).toBroadcastFormat();\n\n      const parsed = factory.from(rawTx) as CloseAtaBuilder;\n      const mixErrorMessage = /Cannot mix single-ATA API .* with bulk-ATA API/;\n      should(() => parsed.accountAddress(ataAddress1)).throw(mixErrorMessage);\n      should(() => parsed.destinationAddress(destinationAddress)).throw(mixErrorMessage);\n      should(() => parsed.authorityAddress(account.pub)).throw(mixErrorMessage);\n    });\n\n    it('should parse existing close ATA raw tx from test resources', async () => {\n      const txnBuilder = factory.from(testData.TRANSFER_UNSIGNED_TX_CLOSE_ATA);\n      should.exist(txnBuilder);\n\n      const tx = await txnBuilder.build();\n      tx.type.should.equal(TransactionType.CloseAssociatedTokenAccount);\n    });\n  });\n});\n"]}

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

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