@bitgo-beta/sdk-coin-flrp 1.0.1-beta.9 → 1.0.1-beta.91

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

@@ -0,0 +1,257 @@
+"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-beta/statics");
+const sdk_core_1 = require("@bitgo-beta/sdk-core");
+const assert = __importStar(require("assert"));
+const importInCTxBuilder_1 = require("../../../src/lib/importInCTxBuilder");
+describe('ImportInCTxBuilder', function () {
+    const coinConfig = statics_1.coins.get('tflrp');
+    let builder;
+    beforeEach(function () {
+        builder = new importInCTxBuilder_1.ImportInCTxBuilder(coinConfig);
+    });
+    describe('Constructor', function () {
+        it('should initialize with coin config', function () {
+            assert.ok(builder);
+            assert.ok(builder instanceof importInCTxBuilder_1.ImportInCTxBuilder);
+        });
+    });
+    describe('Address Management', function () {
+        it('should set valid C-chain destination address', function () {
+            const validAddresses = [
+                'P-flare1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq6f4avh',
+                'P-flare1abcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdef123456',
+                'NodeID-flare1test123456789abcdef',
+            ];
+            validAddresses.forEach((address) => {
+                assert.doesNotThrow(() => {
+                    builder.to(address);
+                }, `Should accept valid address: ${address}`);
+            });
+        });
+        it('should reject invalid C-chain addresses', function () {
+            const invalidAddresses = [
+                '',
+                'invalid-address',
+                '0x742C4B18dd62F23BF0bf8c183f4D5E5F6c6c46f8', // Ethereum format
+                'C-invalid-format',
+                'flare1test', // Missing prefix
+                'random-string-123',
+            ];
+            invalidAddresses.forEach((address) => {
+                assert.throws(() => {
+                    builder.to(address);
+                }, sdk_core_1.BuildTransactionError, `Should reject invalid address: ${address}`);
+            });
+        });
+        it('should handle multiple address settings', function () {
+            const address1 = 'P-flare1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq6f4avh';
+            const address2 = 'P-flare1abcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdef123456';
+            builder.to(address1);
+            builder.to(address2); // Should overwrite the first address
+            // Test doesn't throw
+            assert.ok(true);
+        });
+    });
+    describe('UTXO Management', function () {
+        it('should add single UTXO', function () {
+            const utxo = {
+                outputID: 1,
+                amount: '1000000000000000000', // 1 FLR
+                txid: 'test-txid-single',
+                outputidx: '0',
+                threshold: 1,
+                addresses: ['P-flare1test'],
+            };
+            assert.doesNotThrow(() => {
+                builder.addUtxos([utxo]);
+            });
+        });
+        it('should add multiple UTXOs', function () {
+            const utxos = [
+                {
+                    outputID: 1,
+                    amount: '1000000000000000000', // 1 FLR
+                    txid: 'test-txid-1',
+                    outputidx: '0',
+                    threshold: 1,
+                    addresses: ['P-flare1test1'],
+                },
+                {
+                    outputID: 2,
+                    amount: '2000000000000000000', // 2 FLR
+                    txid: 'test-txid-2',
+                    outputidx: '1',
+                    threshold: 2,
+                    addresses: ['P-flare1test2', 'P-flare1test3'],
+                },
+                {
+                    outputID: 3,
+                    amount: '500000000000000000', // 0.5 FLR
+                    txid: 'test-txid-3',
+                    outputidx: '0',
+                    threshold: 1,
+                    addresses: ['P-flare1test4'],
+                },
+            ];
+            assert.doesNotThrow(() => {
+                builder.addUtxos(utxos);
+            });
+        });
+        it('should handle empty UTXO array', function () {
+            assert.doesNotThrow(() => {
+                builder.addUtxos([]);
+            });
+        });
+        it('should accumulate UTXOs from multiple calls', function () {
+            const utxos1 = [
+                {
+                    outputID: 1,
+                    amount: '1000000000000000000',
+                    txid: 'test-txid-1',
+                    outputidx: '0',
+                    threshold: 1,
+                    addresses: ['P-flare1test1'],
+                },
+            ];
+            const utxos2 = [
+                {
+                    outputID: 2,
+                    amount: '2000000000000000000',
+                    txid: 'test-txid-2',
+                    outputidx: '0',
+                    threshold: 1,
+                    addresses: ['P-flare1test2'],
+                },
+            ];
+            builder.addUtxos(utxos1);
+            builder.addUtxos(utxos2);
+            // Test doesn't throw
+            assert.ok(true);
+        });
+    });
+    describe('Source Chain Management', function () {
+        it('should set valid source chain IDs', function () {
+            const validChainIds = ['P-flare12345', 'NodeID-flare67890', '0x123456789abcdef', 'abc123def456'];
+            validChainIds.forEach((chainId) => {
+                assert.doesNotThrow(() => {
+                    builder.sourceChain(chainId);
+                }, `Should accept chain ID: ${chainId}`);
+            });
+        });
+        it('should handle different chain ID formats', function () {
+            // Test various formats that might be encountered
+            const chainIds = ['P-chain-id-123', 'C-chain-id-456', 'hex-formatted-id', '1234567890abcdef'];
+            chainIds.forEach((chainId) => {
+                assert.doesNotThrow(() => {
+                    builder.sourceChain(chainId);
+                });
+            });
+        });
+    });
+    describe('Transaction Type Verification', function () {
+        it('should verify transaction type (placeholder)', function () {
+            const mockTx = { type: 'import' };
+            const result = importInCTxBuilder_1.ImportInCTxBuilder.verifyTxType(mockTx);
+            assert.strictEqual(result, true); // Placeholder returns true
+        });
+        it('should handle different transaction objects', function () {
+            const validCases = [
+                { type: 'import' }, // Placeholder import transaction
+                {
+                    importIns: [{ input: 'test' }],
+                    sourceChain: 'P-chain',
+                    to: '0x1234567890123456789012345678901234567890',
+                }, // Realistic import transaction
+            ];
+            const invalidCases = [{}, null, undefined, { type: 'export' }, { data: 'test' }];
+            validCases.forEach((testCase, index) => {
+                const result = importInCTxBuilder_1.ImportInCTxBuilder.verifyTxType(testCase);
+                assert.strictEqual(result, true, `Valid test case ${index} should return true`);
+            });
+            invalidCases.forEach((testCase, index) => {
+                const result = importInCTxBuilder_1.ImportInCTxBuilder.verifyTxType(testCase);
+                assert.strictEqual(result, false, `Invalid test case ${index} should return false`);
+            });
+        });
+        it('should verify via instance method', function () {
+            const mockTx = { type: 'import' };
+            const result = builder.verifyTxType(mockTx);
+            assert.strictEqual(result, true);
+        });
+    });
+    describe('Integration Tests', function () {
+        it('should handle complete import flow preparation', function () {
+            const address = 'P-flare1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq6f4avh';
+            const chainId = 'P-source-chain-123';
+            const utxos = [
+                {
+                    outputID: 1,
+                    amount: '5000000000000000000', // 5 FLR
+                    txid: 'integration-test-txid',
+                    outputidx: '0',
+                    threshold: 1,
+                    addresses: ['P-flare1source'],
+                },
+            ];
+            // Complete setup
+            builder.to(address);
+            builder.sourceChain(chainId);
+            builder.addUtxos(utxos);
+            // All operations should complete without throwing
+            assert.ok(true);
+        });
+        it('should handle method chaining', function () {
+            const address = 'P-flare1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq6f4avh';
+            const chainId = 'P-chain-123';
+            const utxos = [
+                {
+                    outputID: 1,
+                    amount: '1000000000000000000',
+                    txid: 'chain-test-txid',
+                    outputidx: '0',
+                    threshold: 1,
+                    addresses: ['P-flare1test'],
+                },
+            ];
+            // Test method chaining
+            assert.doesNotThrow(() => {
+                builder.to(address).sourceChain(chainId).addUtxos(utxos);
+            });
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"importInCTxBuilder.js","sourceRoot":"","sources":["../../../../test/unit/lib/importInCTxBuilder.ts"],"names":[],"mappings":"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","sourcesContent":["import { coins } from '@bitgo-beta/statics';\nimport { BuildTransactionError } from '@bitgo-beta/sdk-core';\nimport * as assert from 'assert';\nimport { ImportInCTxBuilder } from '../../../src/lib/importInCTxBuilder';\nimport { DecodedUtxoObj } from '../../../src/lib/iface';\n\ndescribe('ImportInCTxBuilder', function () {\n  const coinConfig = coins.get('tflrp');\n  let builder: ImportInCTxBuilder;\n\n  beforeEach(function () {\n    builder = new ImportInCTxBuilder(coinConfig);\n  });\n\n  describe('Constructor', function () {\n    it('should initialize with coin config', function () {\n      assert.ok(builder);\n      assert.ok(builder instanceof ImportInCTxBuilder);\n    });\n  });\n\n  describe('Address Management', function () {\n    it('should set valid C-chain destination address', function () {\n      const validAddresses = [\n        'P-flare1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq6f4avh',\n        'P-flare1abcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdef123456',\n        'NodeID-flare1test123456789abcdef',\n      ];\n\n      validAddresses.forEach((address) => {\n        assert.doesNotThrow(() => {\n          builder.to(address);\n        }, `Should accept valid address: ${address}`);\n      });\n    });\n\n    it('should reject invalid C-chain addresses', function () {\n      const invalidAddresses = [\n        '',\n        'invalid-address',\n        '0x742C4B18dd62F23BF0bf8c183f4D5E5F6c6c46f8', // Ethereum format\n        'C-invalid-format',\n        'flare1test', // Missing prefix\n        'random-string-123',\n      ];\n\n      invalidAddresses.forEach((address) => {\n        assert.throws(\n          () => {\n            builder.to(address);\n          },\n          BuildTransactionError,\n          `Should reject invalid address: ${address}`\n        );\n      });\n    });\n\n    it('should handle multiple address settings', function () {\n      const address1 = 'P-flare1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq6f4avh';\n      const address2 = 'P-flare1abcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdef123456';\n\n      builder.to(address1);\n      builder.to(address2); // Should overwrite the first address\n\n      // Test doesn't throw\n      assert.ok(true);\n    });\n  });\n\n  describe('UTXO Management', function () {\n    it('should add single UTXO', function () {\n      const utxo: DecodedUtxoObj = {\n        outputID: 1,\n        amount: '1000000000000000000', // 1 FLR\n        txid: 'test-txid-single',\n        outputidx: '0',\n        threshold: 1,\n        addresses: ['P-flare1test'],\n      };\n\n      assert.doesNotThrow(() => {\n        builder.addUtxos([utxo]);\n      });\n    });\n\n    it('should add multiple UTXOs', function () {\n      const utxos: DecodedUtxoObj[] = [\n        {\n          outputID: 1,\n          amount: '1000000000000000000', // 1 FLR\n          txid: 'test-txid-1',\n          outputidx: '0',\n          threshold: 1,\n          addresses: ['P-flare1test1'],\n        },\n        {\n          outputID: 2,\n          amount: '2000000000000000000', // 2 FLR\n          txid: 'test-txid-2',\n          outputidx: '1',\n          threshold: 2,\n          addresses: ['P-flare1test2', 'P-flare1test3'],\n        },\n        {\n          outputID: 3,\n          amount: '500000000000000000', // 0.5 FLR\n          txid: 'test-txid-3',\n          outputidx: '0',\n          threshold: 1,\n          addresses: ['P-flare1test4'],\n        },\n      ];\n\n      assert.doesNotThrow(() => {\n        builder.addUtxos(utxos);\n      });\n    });\n\n    it('should handle empty UTXO array', function () {\n      assert.doesNotThrow(() => {\n        builder.addUtxos([]);\n      });\n    });\n\n    it('should accumulate UTXOs from multiple calls', function () {\n      const utxos1: DecodedUtxoObj[] = [\n        {\n          outputID: 1,\n          amount: '1000000000000000000',\n          txid: 'test-txid-1',\n          outputidx: '0',\n          threshold: 1,\n          addresses: ['P-flare1test1'],\n        },\n      ];\n\n      const utxos2: DecodedUtxoObj[] = [\n        {\n          outputID: 2,\n          amount: '2000000000000000000',\n          txid: 'test-txid-2',\n          outputidx: '0',\n          threshold: 1,\n          addresses: ['P-flare1test2'],\n        },\n      ];\n\n      builder.addUtxos(utxos1);\n      builder.addUtxos(utxos2);\n\n      // Test doesn't throw\n      assert.ok(true);\n    });\n  });\n\n  describe('Source Chain Management', function () {\n    it('should set valid source chain IDs', function () {\n      const validChainIds = ['P-flare12345', 'NodeID-flare67890', '0x123456789abcdef', 'abc123def456'];\n\n      validChainIds.forEach((chainId) => {\n        assert.doesNotThrow(() => {\n          builder.sourceChain(chainId);\n        }, `Should accept chain ID: ${chainId}`);\n      });\n    });\n\n    it('should handle different chain ID formats', function () {\n      // Test various formats that might be encountered\n      const chainIds = ['P-chain-id-123', 'C-chain-id-456', 'hex-formatted-id', '1234567890abcdef'];\n\n      chainIds.forEach((chainId) => {\n        assert.doesNotThrow(() => {\n          builder.sourceChain(chainId);\n        });\n      });\n    });\n  });\n\n  describe('Transaction Type Verification', function () {\n    it('should verify transaction type (placeholder)', function () {\n      const mockTx = { type: 'import' };\n      const result = ImportInCTxBuilder.verifyTxType(mockTx);\n      assert.strictEqual(result, true); // Placeholder returns true\n    });\n\n    it('should handle different transaction objects', function () {\n      const validCases = [\n        { type: 'import' }, // Placeholder import transaction\n        {\n          importIns: [{ input: 'test' }],\n          sourceChain: 'P-chain',\n          to: '0x1234567890123456789012345678901234567890',\n        }, // Realistic import transaction\n      ];\n\n      const invalidCases = [{}, null, undefined, { type: 'export' }, { data: 'test' }];\n\n      validCases.forEach((testCase, index) => {\n        const result = ImportInCTxBuilder.verifyTxType(testCase);\n        assert.strictEqual(result, true, `Valid test case ${index} should return true`);\n      });\n\n      invalidCases.forEach((testCase, index) => {\n        const result = ImportInCTxBuilder.verifyTxType(testCase);\n        assert.strictEqual(result, false, `Invalid test case ${index} should return false`);\n      });\n    });\n\n    it('should verify via instance method', function () {\n      const mockTx = { type: 'import' };\n      const result = builder.verifyTxType(mockTx);\n      assert.strictEqual(result, true);\n    });\n  });\n\n  describe('Integration Tests', function () {\n    it('should handle complete import flow preparation', function () {\n      const address = 'P-flare1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq6f4avh';\n      const chainId = 'P-source-chain-123';\n      const utxos: DecodedUtxoObj[] = [\n        {\n          outputID: 1,\n          amount: '5000000000000000000', // 5 FLR\n          txid: 'integration-test-txid',\n          outputidx: '0',\n          threshold: 1,\n          addresses: ['P-flare1source'],\n        },\n      ];\n\n      // Complete setup\n      builder.to(address);\n      builder.sourceChain(chainId);\n      builder.addUtxos(utxos);\n\n      // All operations should complete without throwing\n      assert.ok(true);\n    });\n\n    it('should handle method chaining', function () {\n      const address = 'P-flare1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq6f4avh';\n      const chainId = 'P-chain-123';\n      const utxos: DecodedUtxoObj[] = [\n        {\n          outputID: 1,\n          amount: '1000000000000000000',\n          txid: 'chain-test-txid',\n          outputidx: '0',\n          threshold: 1,\n          addresses: ['P-flare1test'],\n        },\n      ];\n\n      // Test method chaining\n      assert.doesNotThrow(() => {\n        builder.to(address).sourceChain(chainId).addUtxos(utxos);\n      });\n    });\n  });\n});\n"]}

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

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

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

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