@bitgo-beta/sdk-coin-ada 2.3.14-beta.162 → 2.3.14-beta.1621

package/dist/test/unit/tokenWithdrawal.js

@@ -0,0 +1,842 @@
+"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 sdk_core_1 = require("@bitgo-beta/sdk-core");
+const testData = __importStar(require("../resources"));
+const src_1 = require("../../src");
+const statics_1 = require("@bitgo-beta/statics");
+const CardanoWasm = __importStar(require("@emurgo/cardano-serialization-lib-nodejs"));
+const sdk_test_1 = require("@bitgo-beta/sdk-test");
+const sdk_api_1 = require("@bitgo-beta/sdk-api");
+describe('ADA Token Operations', async () => {
+    const factory = new src_1.TransactionBuilderFactory(statics_1.coins.get('tada'));
+    const receiverAddress = testData.rawTx.outputAddress2.address;
+    const senderAddress = testData.rawTx.outputAddress1.address;
+    const policyId = 'e16c2dc8ae937e8d3790c7fd7168d7b994621ba14ca11415f39fed72';
+    const policyScriptHash = CardanoWasm.ScriptHash.from_hex(policyId);
+    const assetName = 'tada:water';
+    const name = 'WATER';
+    const asciiEncodedName = Buffer.from(name, 'ascii').toString('hex');
+    const fingerprint = 'asset1n69xf60d0760xvn8v2ffd5frvsm0cl2r8hfjf6';
+    const unsupportedPolicyId = '279c909f348e533da5808898f87f9a14bb2c3dfbbacccd631d927a3f';
+    const unsupportedPolicyScriptHash = CardanoWasm.ScriptHash.from_hex(unsupportedPolicyId);
+    const unsupportedName = 'BITGO';
+    const unsupportedAsciiEncodedName = Buffer.from(unsupportedName, 'ascii').toString('hex');
+    const unsupportedFingerprint = 'asset1m8h0gk7f6x5j5qg0x5m4q5f5j5qg0x5m4q5f5j';
+    it(`should build a transaction with token ${assetName} - ada + ${assetName}`, async () => {
+        const quantity = '20';
+        const totalInput = 20000000;
+        const totalAssetList = {
+            [fingerprint]: {
+                quantity: '100',
+                policy_id: policyId,
+                asset_name: asciiEncodedName,
+            },
+        };
+        const expectedChangeAda = (totalInput -
+            1500000 /* min ada for change token utxo */ -
+            1500000 /* min ada for recipient token utxo*/ -
+            173597) /* fee */
+            .toString();
+        const expectedChangeToken = '80';
+        const txBuilder = factory.getTransferBuilder();
+        txBuilder.input({
+            transaction_id: '3677e75c7ba699bfdc6cd57d42f246f86f63aefd76025006ac78313fad2bba21',
+            transaction_index: 1,
+        });
+        txBuilder.output({
+            address: receiverAddress,
+            amount: '0', // Set ADA amount to 0 for token transfer (min ADA is handled in sdk build)
+            multiAssets: {
+                asset_name: asciiEncodedName,
+                policy_id: policyId,
+                quantity,
+                fingerprint,
+            },
+        });
+        txBuilder.changeAddress(senderAddress, totalInput.toString(), totalAssetList);
+        txBuilder.ttl(800000000);
+        txBuilder.isTokenTransaction();
+        const tx = (await txBuilder.build());
+        should_1.default.equal(tx.type, sdk_core_1.TransactionType.Send);
+        const txData = tx.toJson();
+        // Check outputs (should include multi-asset and regular change)
+        txData.outputs.length.should.equal(3);
+        txData.inputs.length.should.equal(1);
+        // One output should have the multi-asset change and the other for the transfer
+        const assetOutput = txData.outputs.filter((output) => output.multiAssets !== undefined);
+        assetOutput.length.should.equal(2);
+        // Verify inputs and outputs
+        const input = txData.inputs[0];
+        input.transaction_id.should.equal('3677e75c7ba699bfdc6cd57d42f246f86f63aefd76025006ac78313fad2bba21');
+        input.transaction_index.should.equal(1);
+        // Validate receiver output
+        const receiverOutput = txData.outputs.filter((output) => output.address === receiverAddress);
+        receiverOutput.length.should.equal(1);
+        receiverOutput[0].amount.should.equal('1500000'); // Minimum ADA for asset output
+        receiverOutput[0].multiAssets
+            .get_asset(policyScriptHash, CardanoWasm.AssetName.new(Buffer.from(asciiEncodedName, 'hex')))
+            .to_str()
+            .should.equal(quantity);
+        // Validate change outputs (one with asset and one without)
+        const changeOutput = txData.outputs.filter((output) => output.address === senderAddress);
+        changeOutput.length.should.equal(2);
+        const changeWithAsset = changeOutput.find((output) => output.multiAssets !== undefined);
+        should_1.default.exist(changeWithAsset);
+        changeWithAsset.amount.should.equal('1500000'); // Minimum ADA for asset output
+        changeWithAsset.multiAssets
+            .get_asset(policyScriptHash, CardanoWasm.AssetName.new(Buffer.from(asciiEncodedName, 'hex')))
+            .to_str()
+            .should.equal(expectedChangeToken);
+        const changeWithoutAsset = changeOutput.find((output) => output.multiAssets === undefined);
+        should_1.default.exist(changeWithoutAsset);
+        changeWithoutAsset.amount.should.equal(expectedChangeAda); // Remaining ADA after fees and min ADAs
+    });
+    it(`should build a transaction with token ${assetName} - ada + ${assetName} + unsupported token`, async () => {
+        const quantity = '20';
+        const totalInput = 20000000;
+        const totalAssetList = {
+            [fingerprint]: {
+                quantity: '100',
+                policy_id: policyId,
+                asset_name: asciiEncodedName,
+            },
+            [unsupportedFingerprint]: {
+                quantity: '10000',
+                policy_id: unsupportedPolicyId,
+                asset_name: unsupportedAsciiEncodedName,
+            },
+        };
+        const expectedChangeAda = (totalInput -
+            1500000 /* min ada for change token utxo */ -
+            1500000 /* min ada for recipient token utxo*/ -
+            1500000 /* min ada for unsupported token change utxo */ -
+            179889) /* fee */
+            .toString();
+        const expectedChangeToken = '80';
+        const txBuilder = factory.getTransferBuilder();
+        txBuilder.input({
+            transaction_id: '3677e75c7ba699bfdc6cd57d42f246f86f63aefd76025006ac78313fad2bba21',
+            transaction_index: 1,
+        });
+        txBuilder.input({
+            transaction_id: '3677e75c7ba699bfdc6cd57d42f246f86f63aefd76025006ac78313fad2bba22',
+            transaction_index: 1,
+        });
+        txBuilder.output({
+            address: receiverAddress,
+            amount: '0', // Set ADA amount to 0 for token transfer (min ADA is handled in sdk build)
+            multiAssets: {
+                asset_name: asciiEncodedName,
+                policy_id: policyId,
+                quantity,
+                fingerprint,
+            },
+        });
+        txBuilder.changeAddress(senderAddress, totalInput.toString(), totalAssetList);
+        txBuilder.ttl(800000000);
+        txBuilder.isTokenTransaction();
+        const tx = (await txBuilder.build());
+        should_1.default.equal(tx.type, sdk_core_1.TransactionType.Send);
+        const txData = tx.toJson();
+        // Check outputs (should include multi-asset and regular change)
+        txData.outputs.length.should.equal(4);
+        txData.inputs.length.should.equal(2);
+        // One output should have the multi-asset change and the other for the transfer
+        const assetOutput = txData.outputs.filter((output) => output.multiAssets !== undefined);
+        assetOutput.length.should.equal(3);
+        // Verify inputs and outputs
+        txData.inputs[0].transaction_id.should.equal('3677e75c7ba699bfdc6cd57d42f246f86f63aefd76025006ac78313fad2bba21');
+        txData.inputs[0].transaction_index.should.equal(1);
+        txData.inputs[1].transaction_id.should.equal('3677e75c7ba699bfdc6cd57d42f246f86f63aefd76025006ac78313fad2bba22');
+        txData.inputs[1].transaction_index.should.equal(1);
+        // Validate receiver output
+        const receiverOutput = txData.outputs.filter((output) => output.address === receiverAddress);
+        receiverOutput.length.should.equal(1);
+        receiverOutput[0].amount.should.equal('1500000'); // Minimum ADA for asset output
+        receiverOutput[0].multiAssets
+            .get_asset(policyScriptHash, CardanoWasm.AssetName.new(Buffer.from(asciiEncodedName, 'hex')))
+            .to_str()
+            .should.equal(quantity);
+        // Validate change outputs (one with supported token, one with unsupported token and one for pure ada)
+        const changeOutput = txData.outputs.filter((output) => output.address === senderAddress);
+        changeOutput.length.should.equal(3);
+        const changeWithAsset = changeOutput.filter((output) => output.multiAssets !== undefined);
+        changeWithAsset.length.should.equal(2);
+        let tokens = 0;
+        changeWithAsset.forEach((output) => {
+            output.amount.should.equal('1500000'); // Minimum ADA for asset output
+            const supportedTokenChangeQty = output.multiAssets
+                .get_asset(policyScriptHash, CardanoWasm.AssetName.new(Buffer.from(asciiEncodedName, 'hex')))
+                .to_str();
+            const unsupportedTokenChangeQty = output.multiAssets
+                .get_asset(unsupportedPolicyScriptHash, CardanoWasm.AssetName.new(Buffer.from(unsupportedAsciiEncodedName, 'hex')))
+                .to_str();
+            if (supportedTokenChangeQty !== '0') {
+                supportedTokenChangeQty.should.equal(expectedChangeToken);
+                tokens++;
+            }
+            else {
+                unsupportedTokenChangeQty.should.equal('10000');
+                tokens++;
+            }
+        });
+        tokens.should.equal(2);
+        const changeWithoutAsset = changeOutput.find((output) => output.multiAssets === undefined);
+        should_1.default.exist(changeWithoutAsset);
+        changeWithoutAsset.amount.should.equal(expectedChangeAda); // Remaining ADA after fees and min ADAs
+    });
+    it(`should fail to build a transaction with ${assetName} token and insufficient minimum ADA`, async () => {
+        const quantity = '20';
+        const totalInput = 2000000;
+        const totalAssetList = {
+            [fingerprint]: {
+                quantity: '100',
+                policy_id: policyId,
+                asset_name: asciiEncodedName,
+            },
+        };
+        const txBuilder = factory.getTransferBuilder();
+        txBuilder.input({
+            transaction_id: '3677e75c7ba699bfdc6cd57d42f246f86f63aefd76025006ac78313fad2bba21',
+            transaction_index: 1,
+        });
+        txBuilder.output({
+            address: receiverAddress,
+            amount: '0', // Set ADA amount to 0 for token transfer (min ADA is handled in sdk build)
+            multiAssets: {
+                asset_name: asciiEncodedName,
+                policy_id: policyId,
+                quantity,
+                fingerprint,
+            },
+        });
+        txBuilder.changeAddress(senderAddress, totalInput.toString(), totalAssetList);
+        txBuilder.ttl(800000000);
+        txBuilder.isTokenTransaction();
+        await txBuilder
+            .build()
+            .should.rejectedWith('Insufficient funds: need a minimum of 1500000 lovelace per output to construct token transactions');
+    });
+    it(`should fail to build a transaction with ${assetName} and insufficient token qty`, async () => {
+        const quantity = '20';
+        const totalInput = 20000000;
+        const totalAssetList = {
+            [fingerprint]: {
+                quantity: '5',
+                policy_id: policyId,
+                asset_name: asciiEncodedName,
+            },
+        };
+        const txBuilder = factory.getTransferBuilder();
+        txBuilder.input({
+            transaction_id: '3677e75c7ba699bfdc6cd57d42f246f86f63aefd76025006ac78313fad2bba21',
+            transaction_index: 1,
+        });
+        txBuilder.output({
+            address: receiverAddress,
+            amount: '0', // Set ADA amount to 0 for token transfer (min ADA is handled in sdk build)
+            multiAssets: {
+                asset_name: asciiEncodedName,
+                policy_id: policyId,
+                quantity,
+                fingerprint,
+            },
+        });
+        txBuilder.changeAddress(senderAddress, totalInput.toString(), totalAssetList);
+        txBuilder.ttl(800000000);
+        txBuilder.isTokenTransaction();
+        await txBuilder.build().should.rejectedWith('Insufficient qty: not enough token qty to cover receiver output');
+    });
+    it(`should build a transaction with ${assetName} when the token qty is exactly the qty in withdrawal`, async () => {
+        const quantity = '1';
+        const totalInput = 20000000;
+        const totalAssetList = {
+            [fingerprint]: {
+                quantity: '1',
+                policy_id: policyId,
+                asset_name: asciiEncodedName,
+            },
+        };
+        const txBuilder = factory.getTransferBuilder();
+        txBuilder.input({
+            transaction_id: '3677e75c7ba699bfdc6cd57d42f246f86f63aefd76025006ac78313fad2bba21',
+            transaction_index: 1,
+        });
+        txBuilder.output({
+            address: receiverAddress,
+            amount: '0', // Set ADA amount to 0 for token transfer (min ADA is handled in sdk build)
+            multiAssets: {
+                asset_name: asciiEncodedName,
+                policy_id: policyId,
+                quantity,
+                fingerprint,
+            },
+        });
+        txBuilder.changeAddress(senderAddress, totalInput.toString(), totalAssetList);
+        txBuilder.ttl(800000000);
+        txBuilder.isTokenTransaction();
+        await txBuilder.build().should.not.be.rejected();
+    });
+    it(`should build a sponsored token transaction where fee address sponsors min ADA for receiver`, async () => {
+        const feeAddress = 'addr_test1qz2fxv2umyhttkxyxp8x0dlpdt3k6cwng5pxj3jhsydzer3jcu5d8ps7zex2k2xt3uqxgjqnnj83ws8lhrn648jjxtwq2ytjqp';
+        const quantity = '20';
+        const senderInputBalance = 5000000;
+        const feeAddressInputBalance = 20000000; // Fee address has enough ADA to sponsor
+        const totalAssetList = {
+            [fingerprint]: {
+                quantity: '100',
+                policy_id: policyId,
+                asset_name: asciiEncodedName,
+            },
+        };
+        const txBuilder = factory.getTransferBuilder();
+        // Sender input (has tokens)
+        txBuilder.input({
+            transaction_id: '3677e75c7ba699bfdc6cd57d42f246f86f63aefd76025006ac78313fad2bba21',
+            transaction_index: 1,
+        });
+        // Fee address input (sponsors fees and min ADA)
+        txBuilder.input({
+            transaction_id: '3677e75c7ba699bfdc6cd57d42f246f86f63aefd76025006ac78313fad2bba22',
+            transaction_index: 0,
+        });
+        txBuilder.output({
+            address: receiverAddress,
+            amount: '0', // Set ADA amount to 0 for token transfer (min ADA is handled by fee address)
+            multiAssets: {
+                asset_name: asciiEncodedName,
+                policy_id: policyId,
+                quantity,
+                fingerprint,
+            },
+        });
+        txBuilder.changeAddress(senderAddress, senderInputBalance.toString(), totalAssetList);
+        txBuilder.sponsorshipInfo({
+            feeAddress: feeAddress,
+            feeAddressInputBalance: feeAddressInputBalance.toString(),
+        });
+        txBuilder.ttl(800000000);
+        txBuilder.isTokenTransaction();
+        const tx = (await txBuilder.build());
+        should_1.default.equal(tx.type, sdk_core_1.TransactionType.Send);
+        const txData = tx.toJson();
+        txData.inputs.length.should.equal(2);
+        txData.outputs.length.should.equal(4);
+        // Validate receiver output - min ADA should be sponsored by fee address
+        const receiverOutput = txData.outputs.filter((output) => output.address === receiverAddress);
+        receiverOutput.length.should.equal(1);
+        receiverOutput[0].amount.should.equal('1500000'); // Minimum ADA for asset output (sponsored by fee address)
+        receiverOutput[0].multiAssets
+            .get_asset(policyScriptHash, CardanoWasm.AssetName.new(Buffer.from(asciiEncodedName, 'hex')))
+            .to_str()
+            .should.equal(quantity);
+        // Validate sender change output - should have full sender balance (tokens only, no ADA deduction for receiver)
+        const senderChangeOutput = txData.outputs.filter((output) => output.address === senderAddress);
+        senderChangeOutput.length.should.be.equal(2);
+        // Validate fee address change output - should have remaining ADA after fees and min ADA for receiver
+        const feeAddressChangeOutput = txData.outputs.filter((output) => output.address === feeAddress);
+        feeAddressChangeOutput.length.should.equal(1);
+        // Fee address change should not have any tokens
+        should_1.default.not.exist(feeAddressChangeOutput[0].multiAssets);
+        tx.getFee.should.equal('182485'); // Fee with two witnesses
+    });
+    it(`should rebuild a sponsored transaction from hex with isRebuild flag`, async () => {
+        const feeAddress = 'addr_test1qz2fxv2umyhttkxyxp8x0dlpdt3k6cwng5pxj3jhsydzer3jcu5d8ps7zex2k2xt3uqxgjqnnj83ws8lhrn648jjxtwq2ytjqp';
+        const quantity = '20';
+        const senderInputBalance = 5000000;
+        const feeAddressInputBalance = 20000000;
+        const totalAssetList = {
+            [fingerprint]: {
+                quantity: '100',
+                policy_id: policyId,
+                asset_name: asciiEncodedName,
+            },
+        };
+        // Step 1: Build the initial sponsored transaction
+        const txBuilder = factory.getTransferBuilder();
+        txBuilder.input({
+            transaction_id: '3677e75c7ba699bfdc6cd57d42f246f86f63aefd76025006ac78313fad2bba21',
+            transaction_index: 1,
+        });
+        txBuilder.input({
+            transaction_id: '3677e75c7ba699bfdc6cd57d42f246f86f63aefd76025006ac78313fad2bba22',
+            transaction_index: 0,
+        });
+        txBuilder.output({
+            address: receiverAddress,
+            amount: '0',
+            multiAssets: {
+                asset_name: asciiEncodedName,
+                policy_id: policyId,
+                quantity,
+                fingerprint,
+            },
+        });
+        txBuilder.changeAddress(senderAddress, senderInputBalance.toString(), totalAssetList);
+        txBuilder.sponsorshipInfo({
+            feeAddress: feeAddress,
+            feeAddressInputBalance: feeAddressInputBalance.toString(),
+        });
+        txBuilder.ttl(800000000);
+        txBuilder.isTokenTransaction();
+        const initialTx = (await txBuilder.build());
+        const initialFee = initialTx.getFee;
+        const initialTxData = initialTx.toJson();
+        // Step 2: Rebuild with isRebuild = true
+        // This simulates rebuilding from scratch but with isRebuild flag to add sponsor witness
+        const rebuildTxBuilder = factory.getTransferBuilder();
+        rebuildTxBuilder.input({
+            transaction_id: '3677e75c7ba699bfdc6cd57d42f246f86f63aefd76025006ac78313fad2bba21',
+            transaction_index: 1,
+        });
+        rebuildTxBuilder.input({
+            transaction_id: '3677e75c7ba699bfdc6cd57d42f246f86f63aefd76025006ac78313fad2bba22',
+            transaction_index: 0,
+        });
+        rebuildTxBuilder.output({
+            address: receiverAddress,
+            amount: '0',
+            multiAssets: {
+                asset_name: asciiEncodedName,
+                policy_id: policyId,
+                quantity,
+                fingerprint,
+            },
+        });
+        rebuildTxBuilder.changeAddress(senderAddress, senderInputBalance.toString(), totalAssetList);
+        rebuildTxBuilder.sponsorshipInfo({
+            feeAddress: feeAddress,
+            feeAddressInputBalance: feeAddressInputBalance.toString(),
+            isRebuild: true,
+        });
+        rebuildTxBuilder.ttl(800000000);
+        rebuildTxBuilder.isTokenTransaction();
+        const rebuiltTx = (await rebuildTxBuilder.build());
+        const rebuiltTxData = rebuiltTx.toJson();
+        // Verify the rebuilt transaction preserves the same structure
+        rebuiltTxData.inputs.length.should.equal(initialTxData.inputs.length);
+        rebuiltTxData.outputs.length.should.equal(initialTxData.outputs.length);
+        // Fee should be preserved from the original transaction
+        rebuiltTx.getFee.should.equal(initialFee);
+        // Verify receiver output is preserved
+        const receiverOutput = rebuiltTxData.outputs.filter((output) => output.address === receiverAddress);
+        receiverOutput.length.should.equal(1);
+        receiverOutput[0].amount.should.equal('1500000');
+    });
+    describe('AdaToken verifyTransaction', () => {
+        let bitgo;
+        let adaToken;
+        before(function () {
+            bitgo = sdk_test_1.TestBitGo.decorate(sdk_api_1.BitGoAPI, { env: 'mock' });
+            bitgo.initializeTestVars();
+            const tokenConfig = {
+                type: 'tada:water',
+                coin: 'tada',
+                network: 'Testnet',
+                name: 'WATER',
+                decimalPlaces: 0,
+                policyId: policyId,
+                assetName: name, // ASCII 'WATER', not hex-encoded
+                contractAddress: `${policyId}:${asciiEncodedName}`,
+            };
+            adaToken = new src_1.AdaToken(bitgo, tokenConfig);
+        });
+        it('should verify a token transaction with correct token amount', async () => {
+            const quantity = '20';
+            const totalInput = 20000000;
+            const totalAssetList = {
+                [fingerprint]: {
+                    quantity: '100',
+                    policy_id: policyId,
+                    asset_name: asciiEncodedName,
+                },
+            };
+            const txBuilder = factory.getTransferBuilder();
+            txBuilder.input({
+                transaction_id: '3677e75c7ba699bfdc6cd57d42f246f86f63aefd76025006ac78313fad2bba21',
+                transaction_index: 1,
+            });
+            txBuilder.output({
+                address: receiverAddress,
+                amount: '0',
+                multiAssets: {
+                    asset_name: asciiEncodedName,
+                    policy_id: policyId,
+                    quantity,
+                    fingerprint,
+                },
+            });
+            txBuilder.changeAddress(senderAddress, totalInput.toString(), totalAssetList);
+            txBuilder.ttl(800000000);
+            txBuilder.isTokenTransaction();
+            const tx = (await txBuilder.build());
+            const txHex = tx.toBroadcastFormat();
+            // Verify transaction with correct token amount
+            const txParams = {
+                recipients: [
+                    {
+                        address: receiverAddress,
+                        amount: quantity, // Token amount, not ADA amount
+                    },
+                ],
+            };
+            const txPrebuild = { txHex };
+            const mockWallet = { coinSpecific: () => ({ baseAddress: senderAddress }) };
+            const isVerified = await adaToken.verifyTransaction({ txParams, txPrebuild, wallet: mockWallet });
+            isVerified.should.equal(true);
+        });
+        it('should fail to verify a token transaction with incorrect token amount', async () => {
+            const quantity = '20';
+            const totalInput = 20000000;
+            const totalAssetList = {
+                [fingerprint]: {
+                    quantity: '100',
+                    policy_id: policyId,
+                    asset_name: asciiEncodedName,
+                },
+            };
+            const txBuilder = factory.getTransferBuilder();
+            txBuilder.input({
+                transaction_id: '3677e75c7ba699bfdc6cd57d42f246f86f63aefd76025006ac78313fad2bba21',
+                transaction_index: 1,
+            });
+            txBuilder.output({
+                address: receiverAddress,
+                amount: '0',
+                multiAssets: {
+                    asset_name: asciiEncodedName,
+                    policy_id: policyId,
+                    quantity,
+                    fingerprint,
+                },
+            });
+            txBuilder.changeAddress(senderAddress, totalInput.toString(), totalAssetList);
+            txBuilder.ttl(800000000);
+            txBuilder.isTokenTransaction();
+            const tx = (await txBuilder.build());
+            const txHex = tx.toBroadcastFormat();
+            // Verify transaction with WRONG token amount (should fail)
+            const txParams = {
+                recipients: [
+                    {
+                        address: receiverAddress,
+                        amount: '999', // Wrong amount
+                    },
+                ],
+            };
+            const txPrebuild = { txHex };
+            const mockWallet = { coinSpecific: () => ({ baseAddress: senderAddress }) };
+            await adaToken
+                .verifyTransaction({ txParams, txPrebuild, wallet: mockWallet })
+                .should.be.rejectedWith('cannot find recipient in expected output');
+        });
+        it('should fail to verify when address does not match', async () => {
+            const quantity = '20';
+            const totalInput = 20000000;
+            const totalAssetList = {
+                [fingerprint]: {
+                    quantity: '100',
+                    policy_id: policyId,
+                    asset_name: asciiEncodedName,
+                },
+            };
+            const txBuilder = factory.getTransferBuilder();
+            txBuilder.input({
+                transaction_id: '3677e75c7ba699bfdc6cd57d42f246f86f63aefd76025006ac78313fad2bba21',
+                transaction_index: 1,
+            });
+            txBuilder.output({
+                address: receiverAddress,
+                amount: '0',
+                multiAssets: {
+                    asset_name: asciiEncodedName,
+                    policy_id: policyId,
+                    quantity,
+                    fingerprint,
+                },
+            });
+            txBuilder.changeAddress(senderAddress, totalInput.toString(), totalAssetList);
+            txBuilder.ttl(800000000);
+            txBuilder.isTokenTransaction();
+            const tx = (await txBuilder.build());
+            const txHex = tx.toBroadcastFormat();
+            // Verify with wrong address (should fail)
+            const txParams = {
+                recipients: [
+                    {
+                        address: 'addr_test1qqa86e3d7lfpwu0k2rhjz76ecmfxdr74s9kf9yfcp5hj5vmnh6xccjcclrk8jtaw9jgeuy99p2n8smtdpylmy45qjjfsfmp3g6',
+                        amount: quantity,
+                    },
+                ],
+            };
+            const txPrebuild = { txHex };
+            const mockWallet = { coinSpecific: () => ({ baseAddress: senderAddress }) };
+            await adaToken
+                .verifyTransaction({ txParams, txPrebuild, wallet: mockWallet })
+                .should.be.rejectedWith('cannot find recipient in expected output');
+        });
+        it('should verify transaction when policyId has concatenated assetName (crypto compare format)', async () => {
+            // This tests the case where policyId in tokenConfig contains policyId + asciiEncodedAssetName
+            // which is consistent with crypto compare format
+            const concatenatedPolicyId = policyId + asciiEncodedName; // e.g., 'e16c2dc8ae937e8d3790c7fd7168d7b994621ba14ca11415f39fed725741544552'
+            const tokenConfigWithConcatenatedPolicyId = {
+                type: 'tada:water',
+                coin: 'tada',
+                network: 'Testnet',
+                name: 'WATER',
+                decimalPlaces: 0,
+                policyId: concatenatedPolicyId, // policyId + assetName hex
+                assetName: name, // ASCII name 'WATER' (not hex encoded)
+                contractAddress: `${policyId}:${asciiEncodedName}`,
+            };
+            const adaTokenWithConcatenatedPolicyId = new src_1.AdaToken(bitgo, tokenConfigWithConcatenatedPolicyId);
+            const quantity = '20';
+            const totalInput = 20000000;
+            const totalAssetList = {
+                [fingerprint]: {
+                    quantity: '100',
+                    policy_id: policyId,
+                    asset_name: asciiEncodedName,
+                },
+            };
+            const txBuilder = factory.getTransferBuilder();
+            txBuilder.input({
+                transaction_id: '3677e75c7ba699bfdc6cd57d42f246f86f63aefd76025006ac78313fad2bba21',
+                transaction_index: 1,
+            });
+            txBuilder.output({
+                address: receiverAddress,
+                amount: '0',
+                multiAssets: {
+                    asset_name: asciiEncodedName,
+                    policy_id: policyId,
+                    quantity,
+                    fingerprint,
+                },
+            });
+            txBuilder.changeAddress(senderAddress, totalInput.toString(), totalAssetList);
+            txBuilder.ttl(800000000);
+            txBuilder.isTokenTransaction();
+            const tx = (await txBuilder.build());
+            const txHex = tx.toBroadcastFormat();
+            // Verify transaction - the verifyTransaction should strip the assetName from policyId
+            const txParams = {
+                recipients: [
+                    {
+                        address: receiverAddress,
+                        amount: quantity,
+                    },
+                ],
+            };
+            const txPrebuild = { txHex };
+            const mockWallet = { coinSpecific: () => ({ baseAddress: senderAddress }) };
+            const isVerified = await adaTokenWithConcatenatedPolicyId.verifyTransaction({
+                txParams,
+                txPrebuild,
+                wallet: mockWallet,
+            });
+            isVerified.should.equal(true);
+        });
+        it('should verify transaction with policyId that does not have concatenated assetName', async () => {
+            // This tests the case where policyId is just the 28-byte policy ID (no assetName appended)
+            const tokenConfigWithPlainPolicyId = {
+                type: 'tada:water',
+                coin: 'tada',
+                network: 'Testnet',
+                name: 'WATER',
+                decimalPlaces: 0,
+                policyId: policyId, // Just the policy ID without assetName
+                assetName: name, // ASCII name 'WATER'
+                contractAddress: `${policyId}:${asciiEncodedName}`,
+            };
+            const adaTokenWithPlainPolicyId = new src_1.AdaToken(bitgo, tokenConfigWithPlainPolicyId);
+            const quantity = '20';
+            const totalInput = 20000000;
+            const totalAssetList = {
+                [fingerprint]: {
+                    quantity: '100',
+                    policy_id: policyId,
+                    asset_name: asciiEncodedName,
+                },
+            };
+            const txBuilder = factory.getTransferBuilder();
+            txBuilder.input({
+                transaction_id: '3677e75c7ba699bfdc6cd57d42f246f86f63aefd76025006ac78313fad2bba21',
+                transaction_index: 1,
+            });
+            txBuilder.output({
+                address: receiverAddress,
+                amount: '0',
+                multiAssets: {
+                    asset_name: asciiEncodedName,
+                    policy_id: policyId,
+                    quantity,
+                    fingerprint,
+                },
+            });
+            txBuilder.changeAddress(senderAddress, totalInput.toString(), totalAssetList);
+            txBuilder.ttl(800000000);
+            txBuilder.isTokenTransaction();
+            const tx = (await txBuilder.build());
+            const txHex = tx.toBroadcastFormat();
+            // Verify transaction - should work with plain policyId as well
+            const txParams = {
+                recipients: [
+                    {
+                        address: receiverAddress,
+                        amount: quantity,
+                    },
+                ],
+            };
+            const txPrebuild = { txHex };
+            const mockWallet = { coinSpecific: () => ({ baseAddress: senderAddress }) };
+            const isVerified = await adaTokenWithPlainPolicyId.verifyTransaction({
+                txParams,
+                txPrebuild,
+                wallet: mockWallet,
+            });
+            isVerified.should.equal(true);
+        });
+        it('should verify token consolidation transaction when all outputs go to base address', async () => {
+            const quantity = '100';
+            const totalInput = 20000000;
+            const totalAssetList = {
+                [fingerprint]: {
+                    quantity: '100',
+                    policy_id: policyId,
+                    asset_name: asciiEncodedName,
+                },
+            };
+            // Build a consolidation transaction - all outputs go to sender (base) address
+            const txBuilder = factory.getTransferBuilder();
+            txBuilder.input({
+                transaction_id: '3677e75c7ba699bfdc6cd57d42f246f86f63aefd76025006ac78313fad2bba21',
+                transaction_index: 1,
+            });
+            // For consolidation, tokens go back to the sender's base address
+            txBuilder.output({
+                address: senderAddress,
+                amount: '0',
+                multiAssets: {
+                    asset_name: asciiEncodedName,
+                    policy_id: policyId,
+                    quantity,
+                    fingerprint,
+                },
+            });
+            txBuilder.changeAddress(senderAddress, totalInput.toString(), totalAssetList);
+            txBuilder.ttl(800000000);
+            txBuilder.isTokenTransaction();
+            const tx = (await txBuilder.build());
+            const txHex = tx.toBroadcastFormat();
+            // Mock wallet with coinSpecific returning base address
+            const mockWallet = {
+                coinSpecific: () => ({
+                    baseAddress: senderAddress,
+                }),
+            };
+            // Verify consolidation transaction - no recipients, but consolidationToBaseAddress is true
+            const txParams = {
+                recipients: undefined,
+            };
+            const txPrebuild = { txHex };
+            const verification = { consolidationToBaseAddress: true };
+            const isVerified = await adaToken.verifyTransaction({
+                txParams,
+                txPrebuild,
+                verification,
+                wallet: mockWallet,
+            });
+            isVerified.should.equal(true);
+        });
+        it('should fail token consolidation when output address does not match base address', async () => {
+            const quantity = '100';
+            const totalInput = 20000000;
+            const totalAssetList = {
+                [fingerprint]: {
+                    quantity: '100',
+                    policy_id: policyId,
+                    asset_name: asciiEncodedName,
+                },
+            };
+            // Build a transaction with output to receiver (not base address)
+            const txBuilder = factory.getTransferBuilder();
+            txBuilder.input({
+                transaction_id: '3677e75c7ba699bfdc6cd57d42f246f86f63aefd76025006ac78313fad2bba21',
+                transaction_index: 1,
+            });
+            txBuilder.output({
+                address: receiverAddress, // Output goes to receiver, not base address
+                amount: '0',
+                multiAssets: {
+                    asset_name: asciiEncodedName,
+                    policy_id: policyId,
+                    quantity,
+                    fingerprint,
+                },
+            });
+            txBuilder.changeAddress(senderAddress, totalInput.toString(), totalAssetList);
+            txBuilder.ttl(800000000);
+            txBuilder.isTokenTransaction();
+            const tx = (await txBuilder.build());
+            const txHex = tx.toBroadcastFormat();
+            // Mock wallet with different base address
+            const mockWallet = {
+                coinSpecific: () => ({
+                    baseAddress: senderAddress, // Base address is sender, but output goes to receiver
+                }),
+            };
+            const txParams = {
+                recipients: undefined,
+            };
+            const txPrebuild = { txHex };
+            const verification = { consolidationToBaseAddress: true };
+            await adaToken
+                .verifyTransaction({
+                txParams,
+                txPrebuild,
+                verification,
+                wallet: mockWallet,
+            })
+                .should.be.rejectedWith('tx outputs does not match with expected address');
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tokenWithdrawal.js","sourceRoot":"","sources":["../../../test/unit/tokenWithdrawal.ts"],"names":[],"mappings":"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","sourcesContent":["import should from 'should';\nimport { TransactionType } from '@bitgo-beta/sdk-core';\nimport * as testData from '../resources';\nimport { TransactionBuilderFactory, AdaToken } from '../../src';\nimport { coins } from '@bitgo-beta/statics';\nimport * as CardanoWasm from '@emurgo/cardano-serialization-lib-nodejs';\nimport { Transaction } from '../../src/lib/transaction';\nimport { TestBitGo, TestBitGoAPI } from '@bitgo-beta/sdk-test';\nimport { BitGoAPI } from '@bitgo-beta/sdk-api';\n\ndescribe('ADA Token Operations', async () => {\n  const factory = new TransactionBuilderFactory(coins.get('tada'));\n\n  const receiverAddress = testData.rawTx.outputAddress2.address;\n  const senderAddress = testData.rawTx.outputAddress1.address;\n\n  const policyId = 'e16c2dc8ae937e8d3790c7fd7168d7b994621ba14ca11415f39fed72';\n  const policyScriptHash = CardanoWasm.ScriptHash.from_hex(policyId);\n  const assetName = 'tada:water';\n  const name = 'WATER';\n  const asciiEncodedName = Buffer.from(name, 'ascii').toString('hex');\n  const fingerprint = 'asset1n69xf60d0760xvn8v2ffd5frvsm0cl2r8hfjf6';\n\n  const unsupportedPolicyId = '279c909f348e533da5808898f87f9a14bb2c3dfbbacccd631d927a3f';\n  const unsupportedPolicyScriptHash = CardanoWasm.ScriptHash.from_hex(unsupportedPolicyId);\n  const unsupportedName = 'BITGO';\n  const unsupportedAsciiEncodedName = Buffer.from(unsupportedName, 'ascii').toString('hex');\n  const unsupportedFingerprint = 'asset1m8h0gk7f6x5j5qg0x5m4q5f5j5qg0x5m4q5f5j';\n\n  it(`should build a transaction with token ${assetName} - ada + ${assetName}`, async () => {\n    const quantity = '20';\n    const totalInput = 20000000;\n    const totalAssetList = {\n      [fingerprint]: {\n        quantity: '100',\n        policy_id: policyId,\n        asset_name: asciiEncodedName,\n      },\n    };\n    const expectedChangeAda = (\n      totalInput -\n      1500000 /* min ada for change token utxo */ -\n      1500000 /* min ada for recipient token utxo*/ -\n      173597\n    ) /* fee */\n      .toString();\n    const expectedChangeToken = '80';\n\n    const txBuilder = factory.getTransferBuilder();\n    txBuilder.input({\n      transaction_id: '3677e75c7ba699bfdc6cd57d42f246f86f63aefd76025006ac78313fad2bba21',\n      transaction_index: 1,\n    });\n\n    txBuilder.output({\n      address: receiverAddress,\n      amount: '0', // Set ADA amount to 0 for token transfer (min ADA is handled in sdk build)\n      multiAssets: {\n        asset_name: asciiEncodedName,\n        policy_id: policyId,\n        quantity,\n        fingerprint,\n      },\n    });\n\n    txBuilder.changeAddress(senderAddress, totalInput.toString(), totalAssetList);\n    txBuilder.ttl(800000000);\n    txBuilder.isTokenTransaction();\n    const tx = (await txBuilder.build()) as Transaction;\n\n    should.equal(tx.type, TransactionType.Send);\n    const txData = tx.toJson();\n\n    // Check outputs (should include multi-asset and regular change)\n    txData.outputs.length.should.equal(3);\n    txData.inputs.length.should.equal(1);\n\n    // One output should have the multi-asset change and the other for the transfer\n    const assetOutput = txData.outputs.filter((output) => output.multiAssets !== undefined);\n    assetOutput!.length.should.equal(2);\n\n    // Verify inputs and outputs\n    const input = txData.inputs[0];\n    input.transaction_id.should.equal('3677e75c7ba699bfdc6cd57d42f246f86f63aefd76025006ac78313fad2bba21');\n    input.transaction_index.should.equal(1);\n\n    // Validate receiver output\n    const receiverOutput = txData.outputs.filter((output) => output.address === receiverAddress);\n    receiverOutput.length.should.equal(1);\n    receiverOutput[0].amount.should.equal('1500000'); // Minimum ADA for asset output\n    (receiverOutput[0].multiAssets! as CardanoWasm.MultiAsset)\n      .get_asset(policyScriptHash, CardanoWasm.AssetName.new(Buffer.from(asciiEncodedName, 'hex')))\n      .to_str()\n      .should.equal(quantity);\n\n    // Validate change outputs (one with asset and one without)\n    const changeOutput = txData.outputs.filter((output) => output.address === senderAddress);\n    changeOutput.length.should.equal(2);\n    const changeWithAsset = changeOutput.find((output) => output.multiAssets !== undefined);\n    should.exist(changeWithAsset);\n    changeWithAsset!.amount.should.equal('1500000'); // Minimum ADA for asset output\n    (changeWithAsset!.multiAssets! as CardanoWasm.MultiAsset)\n      .get_asset(policyScriptHash, CardanoWasm.AssetName.new(Buffer.from(asciiEncodedName, 'hex')))\n      .to_str()\n      .should.equal(expectedChangeToken);\n\n    const changeWithoutAsset = changeOutput.find((output) => output.multiAssets === undefined);\n    should.exist(changeWithoutAsset);\n    changeWithoutAsset!.amount.should.equal(expectedChangeAda); // Remaining ADA after fees and min ADAs\n  });\n\n  it(`should build a transaction with token ${assetName} - ada + ${assetName} + unsupported token`, async () => {\n    const quantity = '20';\n    const totalInput = 20000000;\n    const totalAssetList = {\n      [fingerprint]: {\n        quantity: '100',\n        policy_id: policyId,\n        asset_name: asciiEncodedName,\n      },\n      [unsupportedFingerprint]: {\n        quantity: '10000',\n        policy_id: unsupportedPolicyId,\n        asset_name: unsupportedAsciiEncodedName,\n      },\n    };\n    const expectedChangeAda = (\n      totalInput -\n      1500000 /* min ada for change token utxo */ -\n      1500000 /* min ada for recipient token utxo*/ -\n      1500000 /* min ada for unsupported token change utxo */ -\n      179889\n    ) /* fee */\n      .toString();\n    const expectedChangeToken = '80';\n\n    const txBuilder = factory.getTransferBuilder();\n    txBuilder.input({\n      transaction_id: '3677e75c7ba699bfdc6cd57d42f246f86f63aefd76025006ac78313fad2bba21',\n      transaction_index: 1,\n    });\n    txBuilder.input({\n      transaction_id: '3677e75c7ba699bfdc6cd57d42f246f86f63aefd76025006ac78313fad2bba22',\n      transaction_index: 1,\n    });\n\n    txBuilder.output({\n      address: receiverAddress,\n      amount: '0', // Set ADA amount to 0 for token transfer (min ADA is handled in sdk build)\n      multiAssets: {\n        asset_name: asciiEncodedName,\n        policy_id: policyId,\n        quantity,\n        fingerprint,\n      },\n    });\n\n    txBuilder.changeAddress(senderAddress, totalInput.toString(), totalAssetList);\n    txBuilder.ttl(800000000);\n    txBuilder.isTokenTransaction();\n    const tx = (await txBuilder.build()) as Transaction;\n\n    should.equal(tx.type, TransactionType.Send);\n    const txData = tx.toJson();\n\n    // Check outputs (should include multi-asset and regular change)\n    txData.outputs.length.should.equal(4);\n    txData.inputs.length.should.equal(2);\n\n    // One output should have the multi-asset change and the other for the transfer\n    const assetOutput = txData.outputs.filter((output) => output.multiAssets !== undefined);\n    assetOutput!.length.should.equal(3);\n\n    // Verify inputs and outputs\n    txData.inputs[0].transaction_id.should.equal('3677e75c7ba699bfdc6cd57d42f246f86f63aefd76025006ac78313fad2bba21');\n    txData.inputs[0].transaction_index.should.equal(1);\n\n    txData.inputs[1].transaction_id.should.equal('3677e75c7ba699bfdc6cd57d42f246f86f63aefd76025006ac78313fad2bba22');\n    txData.inputs[1].transaction_index.should.equal(1);\n\n    // Validate receiver output\n    const receiverOutput = txData.outputs.filter((output) => output.address === receiverAddress);\n    receiverOutput.length.should.equal(1);\n    receiverOutput[0].amount.should.equal('1500000'); // Minimum ADA for asset output\n    (receiverOutput[0].multiAssets! as CardanoWasm.MultiAsset)\n      .get_asset(policyScriptHash, CardanoWasm.AssetName.new(Buffer.from(asciiEncodedName, 'hex')))\n      .to_str()\n      .should.equal(quantity);\n\n    // Validate change outputs (one with supported token, one with unsupported token and one for pure ada)\n    const changeOutput = txData.outputs.filter((output) => output.address === senderAddress);\n    changeOutput.length.should.equal(3);\n\n    const changeWithAsset = changeOutput.filter((output) => output.multiAssets !== undefined);\n    changeWithAsset.length.should.equal(2);\n    let tokens = 0;\n    changeWithAsset.forEach((output) => {\n      output!.amount.should.equal('1500000'); // Minimum ADA for asset output\n      const supportedTokenChangeQty = (output!.multiAssets! as CardanoWasm.MultiAsset)\n        .get_asset(policyScriptHash, CardanoWasm.AssetName.new(Buffer.from(asciiEncodedName, 'hex')))\n        .to_str();\n      const unsupportedTokenChangeQty = (output!.multiAssets! as CardanoWasm.MultiAsset)\n        .get_asset(\n          unsupportedPolicyScriptHash,\n          CardanoWasm.AssetName.new(Buffer.from(unsupportedAsciiEncodedName, 'hex'))\n        )\n        .to_str();\n      if (supportedTokenChangeQty !== '0') {\n        supportedTokenChangeQty.should.equal(expectedChangeToken);\n        tokens++;\n      } else {\n        unsupportedTokenChangeQty!.should.equal('10000');\n        tokens++;\n      }\n    });\n    tokens.should.equal(2);\n\n    const changeWithoutAsset = changeOutput.find((output) => output.multiAssets === undefined);\n    should.exist(changeWithoutAsset);\n    changeWithoutAsset!.amount.should.equal(expectedChangeAda); // Remaining ADA after fees and min ADAs\n  });\n\n  it(`should fail to build a transaction with ${assetName} token and insufficient minimum ADA`, async () => {\n    const quantity = '20';\n    const totalInput = 2000000;\n    const totalAssetList = {\n      [fingerprint]: {\n        quantity: '100',\n        policy_id: policyId,\n        asset_name: asciiEncodedName,\n      },\n    };\n\n    const txBuilder = factory.getTransferBuilder();\n    txBuilder.input({\n      transaction_id: '3677e75c7ba699bfdc6cd57d42f246f86f63aefd76025006ac78313fad2bba21',\n      transaction_index: 1,\n    });\n\n    txBuilder.output({\n      address: receiverAddress,\n      amount: '0', // Set ADA amount to 0 for token transfer (min ADA is handled in sdk build)\n      multiAssets: {\n        asset_name: asciiEncodedName,\n        policy_id: policyId,\n        quantity,\n        fingerprint,\n      },\n    });\n\n    txBuilder.changeAddress(senderAddress, totalInput.toString(), totalAssetList);\n    txBuilder.ttl(800000000);\n    txBuilder.isTokenTransaction();\n\n    await txBuilder\n      .build()\n      .should.rejectedWith(\n        'Insufficient funds: need a minimum of 1500000 lovelace per output to construct token transactions'\n      );\n  });\n\n  it(`should fail to build a transaction with ${assetName} and insufficient token qty`, async () => {\n    const quantity = '20';\n    const totalInput = 20000000;\n    const totalAssetList = {\n      [fingerprint]: {\n        quantity: '5',\n        policy_id: policyId,\n        asset_name: asciiEncodedName,\n      },\n    };\n\n    const txBuilder = factory.getTransferBuilder();\n    txBuilder.input({\n      transaction_id: '3677e75c7ba699bfdc6cd57d42f246f86f63aefd76025006ac78313fad2bba21',\n      transaction_index: 1,\n    });\n\n    txBuilder.output({\n      address: receiverAddress,\n      amount: '0', // Set ADA amount to 0 for token transfer (min ADA is handled in sdk build)\n      multiAssets: {\n        asset_name: asciiEncodedName,\n        policy_id: policyId,\n        quantity,\n        fingerprint,\n      },\n    });\n\n    txBuilder.changeAddress(senderAddress, totalInput.toString(), totalAssetList);\n    txBuilder.ttl(800000000);\n    txBuilder.isTokenTransaction();\n\n    await txBuilder.build().should.rejectedWith('Insufficient qty: not enough token qty to cover receiver output');\n  });\n\n  it(`should build a transaction with ${assetName} when the token qty is exactly the qty in withdrawal`, async () => {\n    const quantity = '1';\n    const totalInput = 20000000;\n    const totalAssetList = {\n      [fingerprint]: {\n        quantity: '1',\n        policy_id: policyId,\n        asset_name: asciiEncodedName,\n      },\n    };\n\n    const txBuilder = factory.getTransferBuilder();\n    txBuilder.input({\n      transaction_id: '3677e75c7ba699bfdc6cd57d42f246f86f63aefd76025006ac78313fad2bba21',\n      transaction_index: 1,\n    });\n\n    txBuilder.output({\n      address: receiverAddress,\n      amount: '0', // Set ADA amount to 0 for token transfer (min ADA is handled in sdk build)\n      multiAssets: {\n        asset_name: asciiEncodedName,\n        policy_id: policyId,\n        quantity,\n        fingerprint,\n      },\n    });\n\n    txBuilder.changeAddress(senderAddress, totalInput.toString(), totalAssetList);\n    txBuilder.ttl(800000000);\n    txBuilder.isTokenTransaction();\n\n    await txBuilder.build().should.not.be.rejected();\n  });\n\n  it(`should build a sponsored token transaction where fee address sponsors min ADA for receiver`, async () => {\n    const feeAddress =\n      'addr_test1qz2fxv2umyhttkxyxp8x0dlpdt3k6cwng5pxj3jhsydzer3jcu5d8ps7zex2k2xt3uqxgjqnnj83ws8lhrn648jjxtwq2ytjqp';\n    const quantity = '20';\n    const senderInputBalance = 5000000;\n    const feeAddressInputBalance = 20000000; // Fee address has enough ADA to sponsor\n    const totalAssetList = {\n      [fingerprint]: {\n        quantity: '100',\n        policy_id: policyId,\n        asset_name: asciiEncodedName,\n      },\n    };\n\n    const txBuilder = factory.getTransferBuilder();\n    // Sender input (has tokens)\n    txBuilder.input({\n      transaction_id: '3677e75c7ba699bfdc6cd57d42f246f86f63aefd76025006ac78313fad2bba21',\n      transaction_index: 1,\n    });\n    // Fee address input (sponsors fees and min ADA)\n    txBuilder.input({\n      transaction_id: '3677e75c7ba699bfdc6cd57d42f246f86f63aefd76025006ac78313fad2bba22',\n      transaction_index: 0,\n    });\n\n    txBuilder.output({\n      address: receiverAddress,\n      amount: '0', // Set ADA amount to 0 for token transfer (min ADA is handled by fee address)\n      multiAssets: {\n        asset_name: asciiEncodedName,\n        policy_id: policyId,\n        quantity,\n        fingerprint,\n      },\n    });\n\n    txBuilder.changeAddress(senderAddress, senderInputBalance.toString(), totalAssetList);\n    txBuilder.sponsorshipInfo({\n      feeAddress: feeAddress,\n      feeAddressInputBalance: feeAddressInputBalance.toString(),\n    });\n    txBuilder.ttl(800000000);\n    txBuilder.isTokenTransaction();\n    const tx = (await txBuilder.build()) as Transaction;\n\n    should.equal(tx.type, TransactionType.Send);\n    const txData = tx.toJson();\n\n    txData.inputs.length.should.equal(2);\n    txData.outputs.length.should.equal(4);\n\n    // Validate receiver output - min ADA should be sponsored by fee address\n    const receiverOutput = txData.outputs.filter((output) => output.address === receiverAddress);\n    receiverOutput.length.should.equal(1);\n    receiverOutput[0].amount.should.equal('1500000'); // Minimum ADA for asset output (sponsored by fee address)\n    (receiverOutput[0].multiAssets! as CardanoWasm.MultiAsset)\n      .get_asset(policyScriptHash, CardanoWasm.AssetName.new(Buffer.from(asciiEncodedName, 'hex')))\n      .to_str()\n      .should.equal(quantity);\n\n    // Validate sender change output - should have full sender balance (tokens only, no ADA deduction for receiver)\n    const senderChangeOutput = txData.outputs.filter((output) => output.address === senderAddress);\n    senderChangeOutput.length.should.be.equal(2);\n\n    // Validate fee address change output - should have remaining ADA after fees and min ADA for receiver\n    const feeAddressChangeOutput = txData.outputs.filter((output) => output.address === feeAddress);\n    feeAddressChangeOutput.length.should.equal(1);\n    // Fee address change should not have any tokens\n    should.not.exist(feeAddressChangeOutput[0].multiAssets);\n\n    tx.getFee.should.equal('182485'); // Fee with two witnesses\n  });\n\n  it(`should rebuild a sponsored transaction from hex with isRebuild flag`, async () => {\n    const feeAddress =\n      'addr_test1qz2fxv2umyhttkxyxp8x0dlpdt3k6cwng5pxj3jhsydzer3jcu5d8ps7zex2k2xt3uqxgjqnnj83ws8lhrn648jjxtwq2ytjqp';\n    const quantity = '20';\n    const senderInputBalance = 5000000;\n    const feeAddressInputBalance = 20000000;\n    const totalAssetList = {\n      [fingerprint]: {\n        quantity: '100',\n        policy_id: policyId,\n        asset_name: asciiEncodedName,\n      },\n    };\n\n    // Step 1: Build the initial sponsored transaction\n    const txBuilder = factory.getTransferBuilder();\n    txBuilder.input({\n      transaction_id: '3677e75c7ba699bfdc6cd57d42f246f86f63aefd76025006ac78313fad2bba21',\n      transaction_index: 1,\n    });\n    txBuilder.input({\n      transaction_id: '3677e75c7ba699bfdc6cd57d42f246f86f63aefd76025006ac78313fad2bba22',\n      transaction_index: 0,\n    });\n\n    txBuilder.output({\n      address: receiverAddress,\n      amount: '0',\n      multiAssets: {\n        asset_name: asciiEncodedName,\n        policy_id: policyId,\n        quantity,\n        fingerprint,\n      },\n    });\n\n    txBuilder.changeAddress(senderAddress, senderInputBalance.toString(), totalAssetList);\n    txBuilder.sponsorshipInfo({\n      feeAddress: feeAddress,\n      feeAddressInputBalance: feeAddressInputBalance.toString(),\n    });\n    txBuilder.ttl(800000000);\n    txBuilder.isTokenTransaction();\n    const initialTx = (await txBuilder.build()) as Transaction;\n    const initialFee = initialTx.getFee;\n    const initialTxData = initialTx.toJson();\n\n    // Step 2: Rebuild with isRebuild = true\n    // This simulates rebuilding from scratch but with isRebuild flag to add sponsor witness\n    const rebuildTxBuilder = factory.getTransferBuilder();\n    rebuildTxBuilder.input({\n      transaction_id: '3677e75c7ba699bfdc6cd57d42f246f86f63aefd76025006ac78313fad2bba21',\n      transaction_index: 1,\n    });\n    rebuildTxBuilder.input({\n      transaction_id: '3677e75c7ba699bfdc6cd57d42f246f86f63aefd76025006ac78313fad2bba22',\n      transaction_index: 0,\n    });\n\n    rebuildTxBuilder.output({\n      address: receiverAddress,\n      amount: '0',\n      multiAssets: {\n        asset_name: asciiEncodedName,\n        policy_id: policyId,\n        quantity,\n        fingerprint,\n      },\n    });\n\n    rebuildTxBuilder.changeAddress(senderAddress, senderInputBalance.toString(), totalAssetList);\n    rebuildTxBuilder.sponsorshipInfo({\n      feeAddress: feeAddress,\n      feeAddressInputBalance: feeAddressInputBalance.toString(),\n      isRebuild: true,\n    });\n    rebuildTxBuilder.ttl(800000000);\n    rebuildTxBuilder.isTokenTransaction();\n\n    const rebuiltTx = (await rebuildTxBuilder.build()) as Transaction;\n    const rebuiltTxData = rebuiltTx.toJson();\n\n    // Verify the rebuilt transaction preserves the same structure\n    rebuiltTxData.inputs.length.should.equal(initialTxData.inputs.length);\n    rebuiltTxData.outputs.length.should.equal(initialTxData.outputs.length);\n\n    // Fee should be preserved from the original transaction\n    rebuiltTx.getFee.should.equal(initialFee);\n\n    // Verify receiver output is preserved\n    const receiverOutput = rebuiltTxData.outputs.filter((output) => output.address === receiverAddress);\n    receiverOutput.length.should.equal(1);\n    receiverOutput[0].amount.should.equal('1500000');\n  });\n\n  describe('AdaToken verifyTransaction', () => {\n    let bitgo: TestBitGoAPI;\n    let adaToken;\n\n    before(function () {\n      bitgo = TestBitGo.decorate(BitGoAPI, { env: 'mock' });\n      bitgo.initializeTestVars();\n      const tokenConfig = {\n        type: 'tada:water',\n        coin: 'tada',\n        network: 'Testnet' as const,\n        name: 'WATER',\n        decimalPlaces: 0,\n        policyId: policyId,\n        assetName: name, // ASCII 'WATER', not hex-encoded\n        contractAddress: `${policyId}:${asciiEncodedName}`,\n      };\n      adaToken = new AdaToken(bitgo, tokenConfig);\n    });\n\n    it('should verify a token transaction with correct token amount', async () => {\n      const quantity = '20';\n      const totalInput = 20000000;\n      const totalAssetList = {\n        [fingerprint]: {\n          quantity: '100',\n          policy_id: policyId,\n          asset_name: asciiEncodedName,\n        },\n      };\n\n      const txBuilder = factory.getTransferBuilder();\n      txBuilder.input({\n        transaction_id: '3677e75c7ba699bfdc6cd57d42f246f86f63aefd76025006ac78313fad2bba21',\n        transaction_index: 1,\n      });\n\n      txBuilder.output({\n        address: receiverAddress,\n        amount: '0',\n        multiAssets: {\n          asset_name: asciiEncodedName,\n          policy_id: policyId,\n          quantity,\n          fingerprint,\n        },\n      });\n\n      txBuilder.changeAddress(senderAddress, totalInput.toString(), totalAssetList);\n      txBuilder.ttl(800000000);\n      txBuilder.isTokenTransaction();\n      const tx = (await txBuilder.build()) as Transaction;\n      const txHex = tx.toBroadcastFormat();\n\n      // Verify transaction with correct token amount\n      const txParams = {\n        recipients: [\n          {\n            address: receiverAddress,\n            amount: quantity, // Token amount, not ADA amount\n          },\n        ],\n      };\n\n      const txPrebuild = { txHex };\n      const mockWallet = { coinSpecific: () => ({ baseAddress: senderAddress }) };\n      const isVerified = await adaToken.verifyTransaction({ txParams, txPrebuild, wallet: mockWallet as any });\n      isVerified.should.equal(true);\n    });\n\n    it('should fail to verify a token transaction with incorrect token amount', async () => {\n      const quantity = '20';\n      const totalInput = 20000000;\n      const totalAssetList = {\n        [fingerprint]: {\n          quantity: '100',\n          policy_id: policyId,\n          asset_name: asciiEncodedName,\n        },\n      };\n\n      const txBuilder = factory.getTransferBuilder();\n      txBuilder.input({\n        transaction_id: '3677e75c7ba699bfdc6cd57d42f246f86f63aefd76025006ac78313fad2bba21',\n        transaction_index: 1,\n      });\n\n      txBuilder.output({\n        address: receiverAddress,\n        amount: '0',\n        multiAssets: {\n          asset_name: asciiEncodedName,\n          policy_id: policyId,\n          quantity,\n          fingerprint,\n        },\n      });\n\n      txBuilder.changeAddress(senderAddress, totalInput.toString(), totalAssetList);\n      txBuilder.ttl(800000000);\n      txBuilder.isTokenTransaction();\n      const tx = (await txBuilder.build()) as Transaction;\n      const txHex = tx.toBroadcastFormat();\n\n      // Verify transaction with WRONG token amount (should fail)\n      const txParams = {\n        recipients: [\n          {\n            address: receiverAddress,\n            amount: '999', // Wrong amount\n          },\n        ],\n      };\n\n      const txPrebuild = { txHex };\n      const mockWallet = { coinSpecific: () => ({ baseAddress: senderAddress }) };\n      await adaToken\n        .verifyTransaction({ txParams, txPrebuild, wallet: mockWallet as any })\n        .should.be.rejectedWith('cannot find recipient in expected output');\n    });\n\n    it('should fail to verify when address does not match', async () => {\n      const quantity = '20';\n      const totalInput = 20000000;\n      const totalAssetList = {\n        [fingerprint]: {\n          quantity: '100',\n          policy_id: policyId,\n          asset_name: asciiEncodedName,\n        },\n      };\n\n      const txBuilder = factory.getTransferBuilder();\n      txBuilder.input({\n        transaction_id: '3677e75c7ba699bfdc6cd57d42f246f86f63aefd76025006ac78313fad2bba21',\n        transaction_index: 1,\n      });\n\n      txBuilder.output({\n        address: receiverAddress,\n        amount: '0',\n        multiAssets: {\n          asset_name: asciiEncodedName,\n          policy_id: policyId,\n          quantity,\n          fingerprint,\n        },\n      });\n\n      txBuilder.changeAddress(senderAddress, totalInput.toString(), totalAssetList);\n      txBuilder.ttl(800000000);\n      txBuilder.isTokenTransaction();\n      const tx = (await txBuilder.build()) as Transaction;\n      const txHex = tx.toBroadcastFormat();\n\n      // Verify with wrong address (should fail)\n      const txParams = {\n        recipients: [\n          {\n            address:\n              'addr_test1qqa86e3d7lfpwu0k2rhjz76ecmfxdr74s9kf9yfcp5hj5vmnh6xccjcclrk8jtaw9jgeuy99p2n8smtdpylmy45qjjfsfmp3g6',\n            amount: quantity,\n          },\n        ],\n      };\n\n      const txPrebuild = { txHex };\n      const mockWallet = { coinSpecific: () => ({ baseAddress: senderAddress }) };\n      await adaToken\n        .verifyTransaction({ txParams, txPrebuild, wallet: mockWallet as any })\n        .should.be.rejectedWith('cannot find recipient in expected output');\n    });\n\n    it('should verify transaction when policyId has concatenated assetName (crypto compare format)', async () => {\n      // This tests the case where policyId in tokenConfig contains policyId + asciiEncodedAssetName\n      // which is consistent with crypto compare format\n      const concatenatedPolicyId = policyId + asciiEncodedName; // e.g., 'e16c2dc8ae937e8d3790c7fd7168d7b994621ba14ca11415f39fed725741544552'\n\n      const tokenConfigWithConcatenatedPolicyId = {\n        type: 'tada:water',\n        coin: 'tada',\n        network: 'Testnet' as const,\n        name: 'WATER',\n        decimalPlaces: 0,\n        policyId: concatenatedPolicyId, // policyId + assetName hex\n        assetName: name, // ASCII name 'WATER' (not hex encoded)\n        contractAddress: `${policyId}:${asciiEncodedName}`,\n      };\n      const adaTokenWithConcatenatedPolicyId = new AdaToken(bitgo, tokenConfigWithConcatenatedPolicyId);\n\n      const quantity = '20';\n      const totalInput = 20000000;\n      const totalAssetList = {\n        [fingerprint]: {\n          quantity: '100',\n          policy_id: policyId,\n          asset_name: asciiEncodedName,\n        },\n      };\n\n      const txBuilder = factory.getTransferBuilder();\n      txBuilder.input({\n        transaction_id: '3677e75c7ba699bfdc6cd57d42f246f86f63aefd76025006ac78313fad2bba21',\n        transaction_index: 1,\n      });\n\n      txBuilder.output({\n        address: receiverAddress,\n        amount: '0',\n        multiAssets: {\n          asset_name: asciiEncodedName,\n          policy_id: policyId,\n          quantity,\n          fingerprint,\n        },\n      });\n\n      txBuilder.changeAddress(senderAddress, totalInput.toString(), totalAssetList);\n      txBuilder.ttl(800000000);\n      txBuilder.isTokenTransaction();\n      const tx = (await txBuilder.build()) as Transaction;\n      const txHex = tx.toBroadcastFormat();\n\n      // Verify transaction - the verifyTransaction should strip the assetName from policyId\n      const txParams = {\n        recipients: [\n          {\n            address: receiverAddress,\n            amount: quantity,\n          },\n        ],\n      };\n\n      const txPrebuild = { txHex };\n      const mockWallet = { coinSpecific: () => ({ baseAddress: senderAddress }) };\n      const isVerified = await adaTokenWithConcatenatedPolicyId.verifyTransaction({\n        txParams,\n        txPrebuild,\n        wallet: mockWallet as any,\n      });\n      isVerified.should.equal(true);\n    });\n\n    it('should verify transaction with policyId that does not have concatenated assetName', async () => {\n      // This tests the case where policyId is just the 28-byte policy ID (no assetName appended)\n      const tokenConfigWithPlainPolicyId = {\n        type: 'tada:water',\n        coin: 'tada',\n        network: 'Testnet' as const,\n        name: 'WATER',\n        decimalPlaces: 0,\n        policyId: policyId, // Just the policy ID without assetName\n        assetName: name, // ASCII name 'WATER'\n        contractAddress: `${policyId}:${asciiEncodedName}`,\n      };\n      const adaTokenWithPlainPolicyId = new AdaToken(bitgo, tokenConfigWithPlainPolicyId);\n\n      const quantity = '20';\n      const totalInput = 20000000;\n      const totalAssetList = {\n        [fingerprint]: {\n          quantity: '100',\n          policy_id: policyId,\n          asset_name: asciiEncodedName,\n        },\n      };\n\n      const txBuilder = factory.getTransferBuilder();\n      txBuilder.input({\n        transaction_id: '3677e75c7ba699bfdc6cd57d42f246f86f63aefd76025006ac78313fad2bba21',\n        transaction_index: 1,\n      });\n\n      txBuilder.output({\n        address: receiverAddress,\n        amount: '0',\n        multiAssets: {\n          asset_name: asciiEncodedName,\n          policy_id: policyId,\n          quantity,\n          fingerprint,\n        },\n      });\n\n      txBuilder.changeAddress(senderAddress, totalInput.toString(), totalAssetList);\n      txBuilder.ttl(800000000);\n      txBuilder.isTokenTransaction();\n      const tx = (await txBuilder.build()) as Transaction;\n      const txHex = tx.toBroadcastFormat();\n\n      // Verify transaction - should work with plain policyId as well\n      const txParams = {\n        recipients: [\n          {\n            address: receiverAddress,\n            amount: quantity,\n          },\n        ],\n      };\n\n      const txPrebuild = { txHex };\n      const mockWallet = { coinSpecific: () => ({ baseAddress: senderAddress }) };\n      const isVerified = await adaTokenWithPlainPolicyId.verifyTransaction({\n        txParams,\n        txPrebuild,\n        wallet: mockWallet as any,\n      });\n      isVerified.should.equal(true);\n    });\n\n    it('should verify token consolidation transaction when all outputs go to base address', async () => {\n      const quantity = '100';\n      const totalInput = 20000000;\n      const totalAssetList = {\n        [fingerprint]: {\n          quantity: '100',\n          policy_id: policyId,\n          asset_name: asciiEncodedName,\n        },\n      };\n\n      // Build a consolidation transaction - all outputs go to sender (base) address\n      const txBuilder = factory.getTransferBuilder();\n      txBuilder.input({\n        transaction_id: '3677e75c7ba699bfdc6cd57d42f246f86f63aefd76025006ac78313fad2bba21',\n        transaction_index: 1,\n      });\n\n      // For consolidation, tokens go back to the sender's base address\n      txBuilder.output({\n        address: senderAddress,\n        amount: '0',\n        multiAssets: {\n          asset_name: asciiEncodedName,\n          policy_id: policyId,\n          quantity,\n          fingerprint,\n        },\n      });\n\n      txBuilder.changeAddress(senderAddress, totalInput.toString(), totalAssetList);\n      txBuilder.ttl(800000000);\n      txBuilder.isTokenTransaction();\n      const tx = (await txBuilder.build()) as Transaction;\n      const txHex = tx.toBroadcastFormat();\n\n      // Mock wallet with coinSpecific returning base address\n      const mockWallet = {\n        coinSpecific: () => ({\n          baseAddress: senderAddress,\n        }),\n      };\n\n      // Verify consolidation transaction - no recipients, but consolidationToBaseAddress is true\n      const txParams = {\n        recipients: undefined,\n      };\n\n      const txPrebuild = { txHex };\n      const verification = { consolidationToBaseAddress: true };\n\n      const isVerified = await adaToken.verifyTransaction({\n        txParams,\n        txPrebuild,\n        verification,\n        wallet: mockWallet as any,\n      });\n      isVerified.should.equal(true);\n    });\n\n    it('should fail token consolidation when output address does not match base address', async () => {\n      const quantity = '100';\n      const totalInput = 20000000;\n      const totalAssetList = {\n        [fingerprint]: {\n          quantity: '100',\n          policy_id: policyId,\n          asset_name: asciiEncodedName,\n        },\n      };\n\n      // Build a transaction with output to receiver (not base address)\n      const txBuilder = factory.getTransferBuilder();\n      txBuilder.input({\n        transaction_id: '3677e75c7ba699bfdc6cd57d42f246f86f63aefd76025006ac78313fad2bba21',\n        transaction_index: 1,\n      });\n\n      txBuilder.output({\n        address: receiverAddress, // Output goes to receiver, not base address\n        amount: '0',\n        multiAssets: {\n          asset_name: asciiEncodedName,\n          policy_id: policyId,\n          quantity,\n          fingerprint,\n        },\n      });\n\n      txBuilder.changeAddress(senderAddress, totalInput.toString(), totalAssetList);\n      txBuilder.ttl(800000000);\n      txBuilder.isTokenTransaction();\n      const tx = (await txBuilder.build()) as Transaction;\n      const txHex = tx.toBroadcastFormat();\n\n      // Mock wallet with different base address\n      const mockWallet = {\n        coinSpecific: () => ({\n          baseAddress: senderAddress, // Base address is sender, but output goes to receiver\n        }),\n      };\n\n      const txParams = {\n        recipients: undefined,\n      };\n\n      const txPrebuild = { txHex };\n      const verification = { consolidationToBaseAddress: true };\n\n      await adaToken\n        .verifyTransaction({\n          txParams,\n          txPrebuild,\n          verification,\n          wallet: mockWallet as any,\n        })\n        .should.be.rejectedWith('tx outputs does not match with expected address');\n    });\n  });\n});\n"]}