@bitgo/sdk-coin-flrp 1.1.0

package/dist/test/unit/lib/transaction.js

@@ -0,0 +1,460 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const statics_1 = require("@bitgo/statics");
+const sdk_core_1 = require("@bitgo/sdk-core");
+const assert = __importStar(require("assert"));
+const transaction_1 = require("../../../src/lib/transaction");
+const keyPair_1 = require("../../../src/lib/keyPair");
+describe('FLRP Transaction', function () {
+    let transaction;
+    const coinConfig = statics_1.coins.get('tflrp');
+    // Helper to create a mock transaction for testing
+    const createMockTx = () => ({ test: 'transaction' });
+    beforeEach(function () {
+        transaction = new transaction_1.Transaction(coinConfig);
+    });
+    describe('Constructor', function () {
+        it('should initialize with correct network configuration', function () {
+            assert.strictEqual(transaction._assetId, 'FLR');
+            assert.strictEqual(transaction._blockchainID, '11111111111111111111111111111111LpoYY');
+            assert.strictEqual(transaction._networkID, 114);
+            assert.strictEqual(transaction._threshold, 2);
+            assert.strictEqual(transaction._locktime, BigInt(0));
+        });
+        it('should initialize empty arrays and default values', function () {
+            assert.deepStrictEqual(transaction._fromAddresses, []);
+            assert.deepStrictEqual(transaction._rewardAddresses, []);
+            assert.deepStrictEqual(transaction._utxos, []);
+            assert.deepStrictEqual(transaction._fee, {});
+        });
+    });
+    describe('Transaction Type Management', function () {
+        it('should set supported transaction types', function () {
+            const supportedTypes = [
+                sdk_core_1.TransactionType.Export,
+                sdk_core_1.TransactionType.Import,
+                sdk_core_1.TransactionType.AddValidator,
+                sdk_core_1.TransactionType.AddDelegator,
+                sdk_core_1.TransactionType.AddPermissionlessValidator,
+                sdk_core_1.TransactionType.AddPermissionlessDelegator,
+            ];
+            supportedTypes.forEach((type) => {
+                assert.doesNotThrow(() => {
+                    transaction.setTransactionType(type);
+                    assert.strictEqual(transaction._type, type);
+                });
+            });
+        });
+        it('should throw error for unsupported transaction types', function () {
+            assert.throws(() => {
+                transaction.setTransactionType(sdk_core_1.TransactionType.Send);
+            }, /Transaction type .* is not supported/);
+        });
+    });
+    describe('Getters', function () {
+        it('should return correct flareTransaction', function () {
+            const mockTx = createMockTx();
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            transaction.setTransaction(mockTx);
+            assert.strictEqual(transaction.flareTransaction, mockTx);
+        });
+        it('should return empty signature array when no credentials', function () {
+            assert.deepStrictEqual(transaction.signature, []);
+        });
+        it('should return empty credentials array', function () {
+            assert.deepStrictEqual(transaction.credentials, []);
+        });
+        it('should return false for hasCredentials when no credentials', function () {
+            assert.strictEqual(transaction.hasCredentials, false);
+        });
+        it('should return placeholder ID when no transaction set', function () {
+            // This should throw error when no transaction is set
+            assert.throws(() => {
+                transaction.id;
+            }, sdk_core_1.InvalidTransactionError);
+        });
+        it('should return placeholder signablePayload when no transaction set', function () {
+            // This should throw error when no transaction is set
+            assert.throws(() => {
+                void transaction.signablePayload;
+            }, sdk_core_1.InvalidTransactionError);
+        });
+        it('should return formatted fromAddresses', function () {
+            transaction._fromAddresses = ['address1', 'address2'];
+            const addresses = transaction.fromAddresses;
+            assert.deepStrictEqual(addresses, ['address1', 'address2']);
+        });
+        it('should return formatted rewardAddresses', function () {
+            transaction._rewardAddresses = ['reward1', 'reward2'];
+            const addresses = transaction.rewardAddresses;
+            assert.deepStrictEqual(addresses, ['reward1', 'reward2']);
+        });
+    });
+    describe('Transaction Outputs', function () {
+        beforeEach(function () {
+            transaction._nodeID = 'test-node-id';
+            transaction._stakeAmount = BigInt('1000000000000000'); // 1M FLR
+        });
+        it('should return empty outputs for Export type', function () {
+            transaction.setTransactionType(sdk_core_1.TransactionType.Export);
+            const outputs = transaction.outputs;
+            assert.deepStrictEqual(outputs, []);
+        });
+        it('should return empty outputs for Import type', function () {
+            transaction.setTransactionType(sdk_core_1.TransactionType.Import);
+            const outputs = transaction.outputs;
+            assert.deepStrictEqual(outputs, []);
+        });
+        it('should return staking outputs for AddValidator type', function () {
+            transaction.setTransactionType(sdk_core_1.TransactionType.AddValidator);
+            const outputs = transaction.outputs;
+            assert.strictEqual(outputs.length, 1);
+            assert.strictEqual(outputs[0].address, 'test-node-id');
+            assert.strictEqual(outputs[0].value, '1000000000000000');
+        });
+        it('should return staking outputs for AddPermissionlessValidator type', function () {
+            transaction.setTransactionType(sdk_core_1.TransactionType.AddPermissionlessValidator);
+            const outputs = transaction.outputs;
+            assert.strictEqual(outputs.length, 1);
+            assert.strictEqual(outputs[0].address, 'test-node-id');
+            assert.strictEqual(outputs[0].value, '1000000000000000');
+        });
+        it('should return staking outputs for AddDelegator type', function () {
+            transaction.setTransactionType(sdk_core_1.TransactionType.AddDelegator);
+            const outputs = transaction.outputs;
+            assert.strictEqual(outputs.length, 1);
+            assert.strictEqual(outputs[0].address, 'test-node-id');
+            assert.strictEqual(outputs[0].value, '1000000000000000');
+        });
+        it('should return staking outputs for AddPermissionlessDelegator type', function () {
+            transaction.setTransactionType(sdk_core_1.TransactionType.AddPermissionlessDelegator);
+            const outputs = transaction.outputs;
+            assert.strictEqual(outputs.length, 1);
+            assert.strictEqual(outputs[0].address, 'test-node-id');
+            assert.strictEqual(outputs[0].value, '1000000000000000');
+        });
+        it('should return empty outputs for unknown type', function () {
+            // Don't set type, should default to empty
+            const outputs = transaction.outputs;
+            assert.deepStrictEqual(outputs, []);
+        });
+    });
+    describe('Transaction Inputs', function () {
+        it('should return inputs from UTXOs', function () {
+            transaction._utxos = [
+                {
+                    outputID: 1,
+                    amount: '1000000',
+                    txid: 'test-txid-1',
+                    outputidx: '0',
+                    threshold: 2,
+                    addresses: ['addr1', 'addr2'],
+                },
+                {
+                    outputID: 2,
+                    amount: '2000000',
+                    txid: 'test-txid-2',
+                    outputidx: '1',
+                    threshold: 2,
+                    addresses: ['addr3', 'addr4'],
+                },
+            ];
+            transaction._fromAddresses = ['addr1', 'addr2', 'addr3', 'addr4'];
+            const inputs = transaction.inputs;
+            assert.strictEqual(inputs.length, 2);
+            assert.strictEqual(inputs[0].id, 'test-txid-1:0');
+            assert.strictEqual(inputs[0].value, '1000000');
+            assert.strictEqual(inputs[0].address, 'addr1~addr2~addr3~addr4');
+            assert.strictEqual(inputs[1].id, 'test-txid-2:1');
+            assert.strictEqual(inputs[1].value, '2000000');
+        });
+        it('should return empty inputs when no UTXOs', function () {
+            const inputs = transaction.inputs;
+            assert.deepStrictEqual(inputs, []);
+        });
+    });
+    describe('Change Outputs', function () {
+        it('should return empty change outputs', function () {
+            const changeOutputs = transaction.changeOutputs;
+            assert.deepStrictEqual(changeOutputs, []);
+        });
+    });
+    describe('Fee Handling', function () {
+        it('should return default fee when no fee set', function () {
+            const fee = transaction.fee;
+            assert.deepStrictEqual(fee, { fee: '0' });
+        });
+        it('should return custom fee when set', function () {
+            transaction._fee = { fee: '1000000' };
+            const fee = transaction.fee;
+            assert.deepStrictEqual(fee, { fee: '1000000' });
+        });
+    });
+    describe('Signing', function () {
+        let keyPair;
+        beforeEach(function () {
+            // Create a test key pair with a private key
+            keyPair = new keyPair_1.KeyPair({ prv: '01'.repeat(32) });
+        });
+        it('should throw error when no private key', async function () {
+            const emptyKeyPair = new keyPair_1.KeyPair();
+            await assert.rejects(async () => {
+                await transaction.sign(emptyKeyPair);
+            }, sdk_core_1.InvalidTransactionError); // Will throw InvalidTransactionError for empty transaction first
+        });
+        it('should throw error when no transaction to sign', async function () {
+            await assert.rejects(async () => {
+                await transaction.sign(keyPair);
+            }, sdk_core_1.InvalidTransactionError);
+        });
+        it('should throw error for FlareJS signing not implemented', async function () {
+            // Set a mock transaction and mock credentials to pass validation
+            const mockTx = createMockTx();
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            transaction.setTransaction(mockTx);
+            // Mock hasCredentials to return true
+            Object.defineProperty(transaction, 'hasCredentials', {
+                get: () => true,
+            });
+            await assert.rejects(async () => {
+                await transaction.sign(keyPair);
+            }, /FlareJS signing not yet implemented/);
+        });
+    });
+    describe('Serialization', function () {
+        it('should throw error for toBroadcastFormat when no transaction', function () {
+            assert.throws(() => {
+                transaction.toBroadcastFormat();
+            }, sdk_core_1.InvalidTransactionError);
+        });
+        it('should return placeholder for toBroadcastFormat when transaction set', function () {
+            const mockTx = createMockTx();
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            transaction.setTransaction(mockTx);
+            const broadcastFormat = transaction.toBroadcastFormat();
+            assert.strictEqual(broadcastFormat, 'flare-tx-hex-placeholder');
+        });
+        it('should throw error for toJson when no transaction', function () {
+            assert.throws(() => {
+                transaction.toJson();
+            }, sdk_core_1.InvalidTransactionError);
+        });
+        it('should return transaction data for toJson when transaction set', function () {
+            const mockTx = createMockTx();
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            transaction.setTransaction(mockTx);
+            transaction._fromAddresses = ['addr1'];
+            transaction._threshold = 2;
+            transaction._locktime = BigInt(100);
+            const jsonData = transaction.toJson();
+            assert.strictEqual(jsonData.id, 'flare-transaction-id-placeholder');
+            assert.deepStrictEqual(jsonData.fromAddresses, ['addr1']);
+            assert.strictEqual(jsonData.threshold, 2);
+            assert.strictEqual(jsonData.locktime, '100');
+        });
+    });
+    describe('Cross-chain Properties', function () {
+        it('should identify Export as cross-chain transaction', function () {
+            transaction.setTransactionType(sdk_core_1.TransactionType.Export);
+            assert.strictEqual(transaction.isTransactionForCChain, true);
+        });
+        it('should identify Import as cross-chain transaction', function () {
+            transaction.setTransactionType(sdk_core_1.TransactionType.Import);
+            assert.strictEqual(transaction.isTransactionForCChain, true);
+        });
+        it('should identify AddValidator as non-cross-chain transaction', function () {
+            transaction.setTransactionType(sdk_core_1.TransactionType.AddValidator);
+            assert.strictEqual(transaction.isTransactionForCChain, false);
+        });
+    });
+    describe('Transaction Explanation', function () {
+        beforeEach(function () {
+            const mockTx = createMockTx();
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            transaction.setTransaction(mockTx);
+            transaction._fromAddresses = ['test-address'];
+            transaction._fee = { fee: '1000000' };
+        });
+        it('should explain a basic transaction', function () {
+            transaction.setTransactionType(sdk_core_1.TransactionType.Export);
+            const explanation = transaction.explainTransaction();
+            assert.ok(explanation.displayOrder);
+            assert.ok(Array.isArray(explanation.displayOrder));
+            assert.strictEqual(explanation.id, 'flare-transaction-id-placeholder');
+            assert.deepStrictEqual(explanation.fee, { fee: '1000000' });
+            assert.strictEqual(explanation.type, sdk_core_1.TransactionType.Export);
+        });
+        it('should include reward addresses for staking transactions', function () {
+            transaction.setTransactionType(sdk_core_1.TransactionType.AddValidator);
+            transaction._rewardAddresses = ['reward-addr-1'];
+            const explanation = transaction.explainTransaction();
+            assert.ok(explanation.displayOrder);
+            assert.ok(explanation.displayOrder.includes('rewardAddresses'));
+            assert.deepStrictEqual(explanation.rewardAddresses, ['reward-addr-1']);
+        });
+        it('should include cross-chain information for export/import', function () {
+            transaction.setTransactionType(sdk_core_1.TransactionType.Export);
+            const explanation = transaction.explainTransaction();
+            assert.ok(explanation.displayOrder);
+            assert.ok(explanation.displayOrder.includes('sourceChain'));
+            assert.ok(explanation.displayOrder.includes('destinationChain'));
+        });
+        it('should calculate output amounts correctly', function () {
+            transaction._nodeID = 'test-node';
+            transaction._stakeAmount = BigInt('5000000000000000');
+            transaction.setTransactionType(sdk_core_1.TransactionType.AddValidator);
+            const explanation = transaction.explainTransaction();
+            assert.strictEqual(explanation.outputAmount, '5000000000000000');
+            assert.strictEqual(explanation.changeAmount, '0');
+        });
+    });
+    describe('Signature Creation', function () {
+        it('should create signature placeholder', function () {
+            const mockPrivateKey = Buffer.from('1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef', 'hex');
+            const mockTx = createMockTx();
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            transaction.setTransaction(mockTx);
+            const signature = transaction.createSignature(mockPrivateKey);
+            assert.ok(typeof signature === 'string');
+            assert.ok(signature.length > 0);
+        });
+    });
+    describe('Validation', function () {
+        it('should allow signing with valid key', function () {
+            const keyPair = new keyPair_1.KeyPair({ prv: '01'.repeat(32) });
+            const canSign = transaction.canSign({ key: keyPair });
+            assert.strictEqual(canSign, true);
+        });
+    });
+    describe('Transaction Setting', function () {
+        it('should set transaction correctly', function () {
+            const mockTx = createMockTx();
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            transaction.setTransaction(mockTx);
+            // Can't directly access _flareTransaction (protected), but can test via getter
+            assert.strictEqual(transaction.flareTransaction, mockTx);
+        });
+    });
+    describe('Hex Conversion', function () {
+        it('should convert byte array to hex string', function () {
+            const byteArray = new Uint8Array([0x01, 0x23, 0xab, 0xcd]);
+            const hexString = transaction.toHexString(byteArray);
+            assert.strictEqual(hexString, '0123abcd');
+        });
+        it('should handle empty byte array', function () {
+            const byteArray = new Uint8Array([]);
+            const hexString = transaction.toHexString(byteArray);
+            assert.strictEqual(hexString, '');
+        });
+    });
+    describe('Memo Functionality', function () {
+        it('should initialize with empty memo', function () {
+            assert.strictEqual(transaction.hasMemo(), false);
+            assert.strictEqual(transaction.getMemoString(), '');
+            assert.deepStrictEqual(transaction.getMemoBytes(), new Uint8Array());
+        });
+        it('should set memo from string', function () {
+            const memoText = 'Test transaction memo';
+            transaction.setMemo(memoText);
+            assert.strictEqual(transaction.hasMemo(), true);
+            assert.strictEqual(transaction.getMemoString(), memoText);
+            assert.deepStrictEqual(transaction.getMemoBytes(), new TextEncoder().encode(memoText));
+        });
+        it('should set memo from JSON object', function () {
+            const memoObj = { user: 'alice', amount: 1000 };
+            transaction.setMemoData(memoObj);
+            assert.strictEqual(transaction.hasMemo(), true);
+            assert.strictEqual(transaction.getMemoString(), JSON.stringify(memoObj));
+        });
+        it('should set memo from bytes', function () {
+            const memoBytes = new TextEncoder().encode('Binary memo data');
+            transaction.setMemoData(memoBytes);
+            assert.strictEqual(transaction.hasMemo(), true);
+            assert.deepStrictEqual(transaction.getMemoBytes(), memoBytes);
+            assert.strictEqual(transaction.getMemoString(), 'Binary memo data');
+        });
+        it('should handle empty string memo', function () {
+            transaction.setMemo('');
+            assert.strictEqual(transaction.hasMemo(), false);
+            assert.strictEqual(transaction.getMemoString(), '');
+        });
+        it('should handle UTF-8 memo', function () {
+            const utf8Memo = 'Hello 世界 🌍 Flare!';
+            transaction.setMemo(utf8Memo);
+            assert.strictEqual(transaction.hasMemo(), true);
+            assert.strictEqual(transaction.getMemoString(), utf8Memo);
+        });
+        it('should include memo in transaction JSON when present', function () {
+            const memoText = 'Transaction metadata';
+            transaction.setMemo(memoText);
+            // Mock the FlareJS transaction
+            const mockTx = createMockTx();
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            transaction.setTransaction(mockTx);
+            transaction.setTransactionType(sdk_core_1.TransactionType.Export);
+            const txData = transaction.toJson();
+            assert.strictEqual(txData.memo, memoText);
+        });
+        it('should not include memo in JSON when empty', function () {
+            // Mock the FlareJS transaction
+            const mockTx = createMockTx();
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            transaction.setTransaction(mockTx);
+            transaction.setTransactionType(sdk_core_1.TransactionType.Export);
+            const txData = transaction.toJson();
+            assert.strictEqual(txData.memo, '');
+        });
+        it('should validate memo size limits', function () {
+            // Test large memo - this should be validated by utils
+            const largeMemo = 'x'.repeat(5000); // 5KB memo
+            transaction.setMemo(largeMemo);
+            assert.strictEqual(transaction.getMemoString(), largeMemo);
+        });
+        it('should handle special characters in memo', function () {
+            const specialMemo = 'Special chars: \n\t\r\0\x01\xff';
+            transaction.setMemo(specialMemo);
+            assert.strictEqual(transaction.getMemoString(), specialMemo);
+        });
+        it('should throw error for invalid memo format in setMemoData', function () {
+            // This should be tested in utils, but we can check basic behavior
+            assert.throws(() => {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                transaction.setMemoData(123);
+            });
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"transaction.js","sourceRoot":"","sources":["../../../../test/unit/lib/transaction.ts"],"names":[],"mappings":"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","sourcesContent":["import { coins } from '@bitgo/statics';\nimport { TransactionType, InvalidTransactionError } from '@bitgo/sdk-core';\nimport * as assert from 'assert';\nimport { Transaction } from '../../../src/lib/transaction';\nimport { KeyPair } from '../../../src/lib/keyPair';\n\n// Mock transaction for testing\ninterface MockTx {\n  test: string;\n}\n\ndescribe('FLRP Transaction', function () {\n  let transaction: Transaction;\n  const coinConfig = coins.get('tflrp');\n\n  // Helper to create a mock transaction for testing\n  const createMockTx = (): MockTx => ({ test: 'transaction' });\n\n  beforeEach(function () {\n    transaction = new Transaction(coinConfig);\n  });\n\n  describe('Constructor', function () {\n    it('should initialize with correct network configuration', function () {\n      assert.strictEqual(transaction._assetId, 'FLR');\n      assert.strictEqual(transaction._blockchainID, '11111111111111111111111111111111LpoYY');\n      assert.strictEqual(transaction._networkID, 114);\n      assert.strictEqual(transaction._threshold, 2);\n      assert.strictEqual(transaction._locktime, BigInt(0));\n    });\n\n    it('should initialize empty arrays and default values', function () {\n      assert.deepStrictEqual(transaction._fromAddresses, []);\n      assert.deepStrictEqual(transaction._rewardAddresses, []);\n      assert.deepStrictEqual(transaction._utxos, []);\n      assert.deepStrictEqual(transaction._fee, {});\n    });\n  });\n\n  describe('Transaction Type Management', function () {\n    it('should set supported transaction types', function () {\n      const supportedTypes = [\n        TransactionType.Export,\n        TransactionType.Import,\n        TransactionType.AddValidator,\n        TransactionType.AddDelegator,\n        TransactionType.AddPermissionlessValidator,\n        TransactionType.AddPermissionlessDelegator,\n      ];\n\n      supportedTypes.forEach((type) => {\n        assert.doesNotThrow(() => {\n          transaction.setTransactionType(type);\n          assert.strictEqual(transaction._type, type);\n        });\n      });\n    });\n\n    it('should throw error for unsupported transaction types', function () {\n      assert.throws(() => {\n        transaction.setTransactionType(TransactionType.Send);\n      }, /Transaction type .* is not supported/);\n    });\n  });\n\n  describe('Getters', function () {\n    it('should return correct flareTransaction', function () {\n      const mockTx = createMockTx();\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      transaction.setTransaction(mockTx as any);\n      assert.strictEqual(transaction.flareTransaction, mockTx);\n    });\n\n    it('should return empty signature array when no credentials', function () {\n      assert.deepStrictEqual(transaction.signature, []);\n    });\n\n    it('should return empty credentials array', function () {\n      assert.deepStrictEqual(transaction.credentials, []);\n    });\n\n    it('should return false for hasCredentials when no credentials', function () {\n      assert.strictEqual(transaction.hasCredentials, false);\n    });\n\n    it('should return placeholder ID when no transaction set', function () {\n      // This should throw error when no transaction is set\n      assert.throws(() => {\n        transaction.id;\n      }, InvalidTransactionError);\n    });\n\n    it('should return placeholder signablePayload when no transaction set', function () {\n      // This should throw error when no transaction is set\n      assert.throws(() => {\n        void transaction.signablePayload;\n      }, InvalidTransactionError);\n    });\n\n    it('should return formatted fromAddresses', function () {\n      transaction._fromAddresses = ['address1', 'address2'];\n      const addresses = transaction.fromAddresses;\n      assert.deepStrictEqual(addresses, ['address1', 'address2']);\n    });\n\n    it('should return formatted rewardAddresses', function () {\n      transaction._rewardAddresses = ['reward1', 'reward2'];\n      const addresses = transaction.rewardAddresses;\n      assert.deepStrictEqual(addresses, ['reward1', 'reward2']);\n    });\n  });\n\n  describe('Transaction Outputs', function () {\n    beforeEach(function () {\n      transaction._nodeID = 'test-node-id';\n      transaction._stakeAmount = BigInt('1000000000000000'); // 1M FLR\n    });\n\n    it('should return empty outputs for Export type', function () {\n      transaction.setTransactionType(TransactionType.Export);\n      const outputs = transaction.outputs;\n      assert.deepStrictEqual(outputs, []);\n    });\n\n    it('should return empty outputs for Import type', function () {\n      transaction.setTransactionType(TransactionType.Import);\n      const outputs = transaction.outputs;\n      assert.deepStrictEqual(outputs, []);\n    });\n\n    it('should return staking outputs for AddValidator type', function () {\n      transaction.setTransactionType(TransactionType.AddValidator);\n      const outputs = transaction.outputs;\n      assert.strictEqual(outputs.length, 1);\n      assert.strictEqual(outputs[0].address, 'test-node-id');\n      assert.strictEqual(outputs[0].value, '1000000000000000');\n    });\n\n    it('should return staking outputs for AddPermissionlessValidator type', function () {\n      transaction.setTransactionType(TransactionType.AddPermissionlessValidator);\n      const outputs = transaction.outputs;\n      assert.strictEqual(outputs.length, 1);\n      assert.strictEqual(outputs[0].address, 'test-node-id');\n      assert.strictEqual(outputs[0].value, '1000000000000000');\n    });\n\n    it('should return staking outputs for AddDelegator type', function () {\n      transaction.setTransactionType(TransactionType.AddDelegator);\n      const outputs = transaction.outputs;\n      assert.strictEqual(outputs.length, 1);\n      assert.strictEqual(outputs[0].address, 'test-node-id');\n      assert.strictEqual(outputs[0].value, '1000000000000000');\n    });\n\n    it('should return staking outputs for AddPermissionlessDelegator type', function () {\n      transaction.setTransactionType(TransactionType.AddPermissionlessDelegator);\n      const outputs = transaction.outputs;\n      assert.strictEqual(outputs.length, 1);\n      assert.strictEqual(outputs[0].address, 'test-node-id');\n      assert.strictEqual(outputs[0].value, '1000000000000000');\n    });\n\n    it('should return empty outputs for unknown type', function () {\n      // Don't set type, should default to empty\n      const outputs = transaction.outputs;\n      assert.deepStrictEqual(outputs, []);\n    });\n  });\n\n  describe('Transaction Inputs', function () {\n    it('should return inputs from UTXOs', function () {\n      transaction._utxos = [\n        {\n          outputID: 1,\n          amount: '1000000',\n          txid: 'test-txid-1',\n          outputidx: '0',\n          threshold: 2,\n          addresses: ['addr1', 'addr2'],\n        },\n        {\n          outputID: 2,\n          amount: '2000000',\n          txid: 'test-txid-2',\n          outputidx: '1',\n          threshold: 2,\n          addresses: ['addr3', 'addr4'],\n        },\n      ];\n      transaction._fromAddresses = ['addr1', 'addr2', 'addr3', 'addr4'];\n\n      const inputs = transaction.inputs;\n      assert.strictEqual(inputs.length, 2);\n      assert.strictEqual(inputs[0].id, 'test-txid-1:0');\n      assert.strictEqual(inputs[0].value, '1000000');\n      assert.strictEqual(inputs[0].address, 'addr1~addr2~addr3~addr4');\n      assert.strictEqual(inputs[1].id, 'test-txid-2:1');\n      assert.strictEqual(inputs[1].value, '2000000');\n    });\n\n    it('should return empty inputs when no UTXOs', function () {\n      const inputs = transaction.inputs;\n      assert.deepStrictEqual(inputs, []);\n    });\n  });\n\n  describe('Change Outputs', function () {\n    it('should return empty change outputs', function () {\n      const changeOutputs = transaction.changeOutputs;\n      assert.deepStrictEqual(changeOutputs, []);\n    });\n  });\n\n  describe('Fee Handling', function () {\n    it('should return default fee when no fee set', function () {\n      const fee = transaction.fee;\n      assert.deepStrictEqual(fee, { fee: '0' });\n    });\n\n    it('should return custom fee when set', function () {\n      transaction._fee = { fee: '1000000' };\n      const fee = transaction.fee;\n      assert.deepStrictEqual(fee, { fee: '1000000' });\n    });\n  });\n\n  describe('Signing', function () {\n    let keyPair: KeyPair;\n\n    beforeEach(function () {\n      // Create a test key pair with a private key\n      keyPair = new KeyPair({ prv: '01'.repeat(32) });\n    });\n\n    it('should throw error when no private key', async function () {\n      const emptyKeyPair = new KeyPair();\n\n      await assert.rejects(async () => {\n        await transaction.sign(emptyKeyPair);\n      }, InvalidTransactionError); // Will throw InvalidTransactionError for empty transaction first\n    });\n\n    it('should throw error when no transaction to sign', async function () {\n      await assert.rejects(async () => {\n        await transaction.sign(keyPair);\n      }, InvalidTransactionError);\n    });\n\n    it('should throw error for FlareJS signing not implemented', async function () {\n      // Set a mock transaction and mock credentials to pass validation\n      const mockTx = createMockTx();\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      transaction.setTransaction(mockTx as any);\n\n      // Mock hasCredentials to return true\n      Object.defineProperty(transaction, 'hasCredentials', {\n        get: () => true,\n      });\n\n      await assert.rejects(async () => {\n        await transaction.sign(keyPair);\n      }, /FlareJS signing not yet implemented/);\n    });\n  });\n\n  describe('Serialization', function () {\n    it('should throw error for toBroadcastFormat when no transaction', function () {\n      assert.throws(() => {\n        transaction.toBroadcastFormat();\n      }, InvalidTransactionError);\n    });\n\n    it('should return placeholder for toBroadcastFormat when transaction set', function () {\n      const mockTx = createMockTx();\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      transaction.setTransaction(mockTx as any);\n      const broadcastFormat = transaction.toBroadcastFormat();\n      assert.strictEqual(broadcastFormat, 'flare-tx-hex-placeholder');\n    });\n\n    it('should throw error for toJson when no transaction', function () {\n      assert.throws(() => {\n        transaction.toJson();\n      }, InvalidTransactionError);\n    });\n\n    it('should return transaction data for toJson when transaction set', function () {\n      const mockTx = createMockTx();\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      transaction.setTransaction(mockTx as any);\n      transaction._fromAddresses = ['addr1'];\n      transaction._threshold = 2;\n      transaction._locktime = BigInt(100);\n\n      const jsonData = transaction.toJson();\n      assert.strictEqual(jsonData.id, 'flare-transaction-id-placeholder');\n      assert.deepStrictEqual(jsonData.fromAddresses, ['addr1']);\n      assert.strictEqual(jsonData.threshold, 2);\n      assert.strictEqual(jsonData.locktime, '100');\n    });\n  });\n\n  describe('Cross-chain Properties', function () {\n    it('should identify Export as cross-chain transaction', function () {\n      transaction.setTransactionType(TransactionType.Export);\n      assert.strictEqual(transaction.isTransactionForCChain, true);\n    });\n\n    it('should identify Import as cross-chain transaction', function () {\n      transaction.setTransactionType(TransactionType.Import);\n      assert.strictEqual(transaction.isTransactionForCChain, true);\n    });\n\n    it('should identify AddValidator as non-cross-chain transaction', function () {\n      transaction.setTransactionType(TransactionType.AddValidator);\n      assert.strictEqual(transaction.isTransactionForCChain, false);\n    });\n  });\n\n  describe('Transaction Explanation', function () {\n    beforeEach(function () {\n      const mockTx = createMockTx();\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      transaction.setTransaction(mockTx as any);\n      transaction._fromAddresses = ['test-address'];\n      transaction._fee = { fee: '1000000' };\n    });\n\n    it('should explain a basic transaction', function () {\n      transaction.setTransactionType(TransactionType.Export);\n\n      const explanation = transaction.explainTransaction();\n      assert.ok(explanation.displayOrder);\n      assert.ok(Array.isArray(explanation.displayOrder));\n      assert.strictEqual(explanation.id, 'flare-transaction-id-placeholder');\n      assert.deepStrictEqual(explanation.fee, { fee: '1000000' });\n      assert.strictEqual(explanation.type, TransactionType.Export);\n    });\n\n    it('should include reward addresses for staking transactions', function () {\n      transaction.setTransactionType(TransactionType.AddValidator);\n      transaction._rewardAddresses = ['reward-addr-1'];\n\n      const explanation = transaction.explainTransaction();\n      assert.ok(explanation.displayOrder);\n      assert.ok(explanation.displayOrder.includes('rewardAddresses'));\n      assert.deepStrictEqual(explanation.rewardAddresses, ['reward-addr-1']);\n    });\n\n    it('should include cross-chain information for export/import', function () {\n      transaction.setTransactionType(TransactionType.Export);\n\n      const explanation = transaction.explainTransaction();\n      assert.ok(explanation.displayOrder);\n      assert.ok(explanation.displayOrder.includes('sourceChain'));\n      assert.ok(explanation.displayOrder.includes('destinationChain'));\n    });\n\n    it('should calculate output amounts correctly', function () {\n      transaction._nodeID = 'test-node';\n      transaction._stakeAmount = BigInt('5000000000000000');\n      transaction.setTransactionType(TransactionType.AddValidator);\n\n      const explanation = transaction.explainTransaction();\n      assert.strictEqual(explanation.outputAmount, '5000000000000000');\n      assert.strictEqual(explanation.changeAmount, '0');\n    });\n  });\n\n  describe('Signature Creation', function () {\n    it('should create signature placeholder', function () {\n      const mockPrivateKey = Buffer.from('1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef', 'hex');\n      const mockTx = createMockTx();\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      transaction.setTransaction(mockTx as any);\n\n      const signature = transaction.createSignature(mockPrivateKey);\n      assert.ok(typeof signature === 'string');\n      assert.ok(signature.length > 0);\n    });\n  });\n\n  describe('Validation', function () {\n    it('should allow signing with valid key', function () {\n      const keyPair = new KeyPair({ prv: '01'.repeat(32) });\n\n      const canSign = transaction.canSign({ key: keyPair });\n      assert.strictEqual(canSign, true);\n    });\n  });\n\n  describe('Transaction Setting', function () {\n    it('should set transaction correctly', function () {\n      const mockTx = createMockTx();\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      transaction.setTransaction(mockTx as any);\n      // Can't directly access _flareTransaction (protected), but can test via getter\n      assert.strictEqual(transaction.flareTransaction, mockTx);\n    });\n  });\n\n  describe('Hex Conversion', function () {\n    it('should convert byte array to hex string', function () {\n      const byteArray = new Uint8Array([0x01, 0x23, 0xab, 0xcd]);\n      const hexString = transaction.toHexString(byteArray);\n      assert.strictEqual(hexString, '0123abcd');\n    });\n\n    it('should handle empty byte array', function () {\n      const byteArray = new Uint8Array([]);\n      const hexString = transaction.toHexString(byteArray);\n      assert.strictEqual(hexString, '');\n    });\n  });\n\n  describe('Memo Functionality', function () {\n    it('should initialize with empty memo', function () {\n      assert.strictEqual(transaction.hasMemo(), false);\n      assert.strictEqual(transaction.getMemoString(), '');\n      assert.deepStrictEqual(transaction.getMemoBytes(), new Uint8Array());\n    });\n\n    it('should set memo from string', function () {\n      const memoText = 'Test transaction memo';\n      transaction.setMemo(memoText);\n\n      assert.strictEqual(transaction.hasMemo(), true);\n      assert.strictEqual(transaction.getMemoString(), memoText);\n      assert.deepStrictEqual(transaction.getMemoBytes(), new TextEncoder().encode(memoText));\n    });\n\n    it('should set memo from JSON object', function () {\n      const memoObj = { user: 'alice', amount: 1000 };\n      transaction.setMemoData(memoObj);\n\n      assert.strictEqual(transaction.hasMemo(), true);\n      assert.strictEqual(transaction.getMemoString(), JSON.stringify(memoObj));\n    });\n\n    it('should set memo from bytes', function () {\n      const memoBytes = new TextEncoder().encode('Binary memo data');\n      transaction.setMemoData(memoBytes);\n\n      assert.strictEqual(transaction.hasMemo(), true);\n      assert.deepStrictEqual(transaction.getMemoBytes(), memoBytes);\n      assert.strictEqual(transaction.getMemoString(), 'Binary memo data');\n    });\n\n    it('should handle empty string memo', function () {\n      transaction.setMemo('');\n      assert.strictEqual(transaction.hasMemo(), false);\n      assert.strictEqual(transaction.getMemoString(), '');\n    });\n\n    it('should handle UTF-8 memo', function () {\n      const utf8Memo = 'Hello 世界 🌍 Flare!';\n      transaction.setMemo(utf8Memo);\n\n      assert.strictEqual(transaction.hasMemo(), true);\n      assert.strictEqual(transaction.getMemoString(), utf8Memo);\n    });\n\n    it('should include memo in transaction JSON when present', function () {\n      const memoText = 'Transaction metadata';\n      transaction.setMemo(memoText);\n\n      // Mock the FlareJS transaction\n      const mockTx = createMockTx();\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      transaction.setTransaction(mockTx as any);\n      transaction.setTransactionType(TransactionType.Export);\n\n      const txData = transaction.toJson();\n      assert.strictEqual(txData.memo, memoText);\n    });\n\n    it('should not include memo in JSON when empty', function () {\n      // Mock the FlareJS transaction\n      const mockTx = createMockTx();\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      transaction.setTransaction(mockTx as any);\n      transaction.setTransactionType(TransactionType.Export);\n\n      const txData = transaction.toJson();\n      assert.strictEqual(txData.memo, '');\n    });\n\n    it('should validate memo size limits', function () {\n      // Test large memo - this should be validated by utils\n      const largeMemo = 'x'.repeat(5000); // 5KB memo\n      transaction.setMemo(largeMemo);\n      assert.strictEqual(transaction.getMemoString(), largeMemo);\n    });\n\n    it('should handle special characters in memo', function () {\n      const specialMemo = 'Special chars: \\n\\t\\r\\0\\x01\\xff';\n      transaction.setMemo(specialMemo);\n      assert.strictEqual(transaction.getMemoString(), specialMemo);\n    });\n\n    it('should throw error for invalid memo format in setMemoData', function () {\n      // This should be tested in utils, but we can check basic behavior\n      assert.throws(() => {\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        transaction.setMemoData(123 as any);\n      });\n    });\n  });\n});\n"]}

package/dist/test/unit/lib/utils.d.ts

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

package/dist/test/unit/lib/utils.d.ts.map

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