@bitgo/sdk-coin-flrp 1.1.0

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

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

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

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

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

@@ -0,0 +1,377 @@
+"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 assert = __importStar(require("assert"));
+const exportInPTxBuilder_1 = require("../../../src/lib/exportInPTxBuilder");
+describe('ExportInPTxBuilder', function () {
+    const coinConfig = statics_1.coins.get('tflrp');
+    let builder;
+    beforeEach(function () {
+        builder = new exportInPTxBuilder_1.ExportInPTxBuilder(coinConfig);
+    });
+    describe('Constructor', function () {
+        it('should initialize with coin config', function () {
+            assert.ok(builder);
+            assert.ok(builder instanceof exportInPTxBuilder_1.ExportInPTxBuilder);
+        });
+        it('should extend AtomicTransactionBuilder', function () {
+            // Test inheritance
+            assert.ok(builder);
+        });
+        it('should initialize with default amount', function () {
+            // Default amount should be 0n
+            assert.ok(builder);
+        });
+    });
+    describe('Amount Management', function () {
+        it('should set valid bigint amounts', function () {
+            const validAmounts = [1000n, 1000000000000000000n, 999999999999999999n]; // Removed 0n
+            validAmounts.forEach((amount) => {
+                assert.doesNotThrow(() => {
+                    builder.amount(amount);
+                }, `Should accept bigint amount: ${amount}`);
+            });
+        });
+        it('should set string amounts', function () {
+            const stringAmounts = ['1000', '1000000000000000000', '999999999999999999']; // Removed '0'
+            stringAmounts.forEach((amount) => {
+                assert.doesNotThrow(() => {
+                    builder.amount(amount);
+                }, `Should accept string amount: ${amount}`);
+            });
+        });
+        it('should set numeric amounts', function () {
+            const numericAmounts = [1000, 2000000, 999999999]; // Removed 0
+            numericAmounts.forEach((amount) => {
+                assert.doesNotThrow(() => {
+                    builder.amount(amount);
+                }, `Should accept numeric amount: ${amount}`);
+            });
+        });
+        it('should reject zero amount', function () {
+            assert.throws(() => {
+                builder.amount(0n);
+            }, /Amount must be positive/);
+            assert.throws(() => {
+                builder.amount('0');
+            }, /Amount must be positive/);
+            assert.throws(() => {
+                builder.amount(0);
+            }, /Amount must be positive/);
+        });
+        it('should handle large amounts', function () {
+            const largeAmounts = [
+                '100000000000000000000000', // Very large amount
+                '18446744073709551615', // Near uint64 max
+                BigInt('999999999999999999999999999999'),
+                999999999999999999n,
+            ];
+            largeAmounts.forEach((amount) => {
+                assert.doesNotThrow(() => {
+                    builder.amount(amount);
+                }, `Should handle large amount: ${amount}`);
+            });
+        });
+        it('should reject negative amounts', function () {
+            const negativeAmounts = ['-1000', '-1'];
+            negativeAmounts.forEach((amount) => {
+                assert.throws(() => {
+                    builder.amount(amount);
+                }, Error, // validateAmount should throw error for negative amounts
+                `Should reject negative amount: ${amount}`);
+            });
+        });
+        it('should reject negative bigint amounts', function () {
+            const negativeBigints = [-1n, -1000n, -999999999999n];
+            negativeBigints.forEach((amount) => {
+                assert.throws(() => {
+                    builder.amount(amount);
+                }, Error, `Should reject negative bigint amount: ${amount}`);
+            });
+        });
+        it('should chain amount setting with other methods', function () {
+            const amount = 1000000000000000000n; // 1 FLR
+            assert.doesNotThrow(() => {
+                builder.amount(amount);
+            });
+        });
+    });
+    describe('Transaction Type', function () {
+        it('should return Export transaction type', function () {
+            // Can't access protected method directly, but test doesn't throw
+            assert.ok(builder);
+        });
+    });
+    describe('Transaction Initialization', function () {
+        it('should initialize builder from transaction', function () {
+            const mockTx = { type: 'export', data: 'placeholder' };
+            assert.doesNotThrow(() => {
+                builder.initBuilder(mockTx);
+            });
+        });
+        it('should handle null transaction initialization', function () {
+            assert.doesNotThrow(() => {
+                builder.initBuilder(null);
+            });
+        });
+        it('should handle undefined transaction initialization', function () {
+            assert.doesNotThrow(() => {
+                builder.initBuilder(undefined);
+            });
+        });
+        it('should handle object transaction initialization', function () {
+            const mockTx = {
+                id: 'test-tx',
+                type: 'export',
+                amount: '1000000000000000000',
+                from: 'P-flare1source',
+                to: 'C-flare1dest',
+            };
+            assert.doesNotThrow(() => {
+                builder.initBuilder(mockTx);
+            });
+        });
+    });
+    describe('Transaction Type Verification', function () {
+        it('should verify transaction type (returns false - not implemented)', function () {
+            const mockTx = { type: 'export' };
+            const result = exportInPTxBuilder_1.ExportInPTxBuilder.verifyTxType(mockTx);
+            assert.strictEqual(result, false); // Not implemented yet
+        });
+        it('should handle different transaction objects', function () {
+            const testCases = [{}, null, undefined, { type: 'import' }, { data: 'test' }];
+            testCases.forEach((testCase, index) => {
+                const result = exportInPTxBuilder_1.ExportInPTxBuilder.verifyTxType(testCase);
+                assert.strictEqual(result, false, `Test case ${index} should return false (not implemented)`);
+            });
+        });
+        it('should verify via instance method', function () {
+            const mockTx = { type: 'export' };
+            const result = builder.verifyTxType(mockTx);
+            assert.strictEqual(result, false); // Not implemented
+        });
+        it('should verify static and instance methods return same result', function () {
+            const mockTx = { type: 'export' };
+            const staticResult = exportInPTxBuilder_1.ExportInPTxBuilder.verifyTxType(mockTx);
+            const instanceResult = builder.verifyTxType(mockTx);
+            assert.strictEqual(staticResult, instanceResult);
+        });
+    });
+    describe('Transaction Building', function () {
+        it('should throw error when building (not implemented)', function () {
+            builder.amount(1000000000000000000n);
+            assert.throws(() => {
+                // Access protected method for testing
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                builder.buildFlareTransaction();
+            }, Error);
+        });
+        it('should throw specific error message', function () {
+            assert.throws(() => {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                builder.buildFlareTransaction();
+            }, /Flare P-chain export transaction build not implemented/);
+        });
+    });
+    describe('Exported Outputs', function () {
+        it('should return empty array for exported outputs', function () {
+            // Access protected method for testing
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const result = builder.exportedOutputs();
+            assert.ok(Array.isArray(result));
+            assert.strictEqual(result.length, 0);
+        });
+        it('should consistently return empty array', function () {
+            // Call multiple times to ensure consistency
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const result1 = builder.exportedOutputs();
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const result2 = builder.exportedOutputs();
+            assert.deepStrictEqual(result1, result2);
+        });
+    });
+    describe('Amount Validation', function () {
+        it('should validate positive amounts', function () {
+            const positiveAmounts = [1n, 1000n, 1000000000000000000n];
+            positiveAmounts.forEach((amount) => {
+                assert.doesNotThrow(() => {
+                    builder.amount(amount);
+                }, `Should validate positive amount: ${amount}`);
+            });
+        });
+        it('should reject zero amount', function () {
+            assert.throws(() => {
+                builder.amount(0n);
+            }, /Amount must be positive/);
+        });
+        it('should validate large amounts', function () {
+            const largeAmounts = [
+                BigInt('18446744073709551615'), // Max uint64
+                BigInt('999999999999999999999999999999'), // Very large
+            ];
+            largeAmounts.forEach((amount) => {
+                assert.doesNotThrow(() => {
+                    builder.amount(amount);
+                }, `Should validate large amount: ${amount}`);
+            });
+        });
+    });
+    describe('Integration Tests', function () {
+        it('should handle basic P-chain export setup', function () {
+            const amount = 5000000000000000000n; // 5 FLR
+            // Basic setup
+            builder.amount(amount);
+            // Should not throw during setup
+            assert.ok(true);
+        });
+        it('should handle amount conversion from different types', function () {
+            // Test conversion from string
+            builder.amount('1000000000000000000');
+            // Test conversion from number
+            builder.amount(1000000);
+            // Test direct bigint
+            builder.amount(2000000000000000000n);
+            // All conversions should work
+            assert.ok(true);
+        });
+        it('should maintain state across operations', function () {
+            // Set amount
+            builder.amount(1000000000000000000n);
+            // Initialize with transaction
+            const mockTx = { type: 'export' };
+            builder.initBuilder(mockTx);
+            // State should be maintained
+            assert.ok(true);
+        });
+        it('should handle sequential amount updates', function () {
+            // Update amount multiple times
+            builder.amount(1000n);
+            builder.amount(2000n);
+            builder.amount(3000n);
+            // Should handle updates without issues
+            assert.ok(true);
+        });
+    });
+    describe('Error Handling', function () {
+        it('should handle invalid amount types gracefully', function () {
+            const invalidAmounts = [null, undefined, {}, [], 'invalid'];
+            invalidAmounts.forEach((amount) => {
+                assert.throws(() => {
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    builder.amount(amount);
+                }, `Should throw for invalid amount: ${amount}`);
+            });
+        });
+        it('should handle edge case string amounts', function () {
+            const edgeCaseAmounts = ['', '  ', 'abc', '1.5', 'infinity', 'NaN'];
+            edgeCaseAmounts.forEach((amount) => {
+                assert.throws(() => {
+                    builder.amount(amount);
+                }, `Should throw for edge case amount: ${amount}`);
+            });
+        });
+    });
+    describe('Inheritance Tests', function () {
+        it('should inherit from AtomicTransactionBuilder', function () {
+            // Test that builder has expected inherited functionality
+            assert.ok(builder);
+            // Should have initBuilder method
+            assert.ok(typeof builder.initBuilder === 'function');
+            // Should have verifyTxType method
+            assert.ok(typeof builder.verifyTxType === 'function');
+        });
+        it('should have access to inherited UTXO methods', function () {
+            // Should inherit utxos method from parent
+            assert.ok(typeof builder.utxos === 'function');
+        });
+    });
+    describe('Edge Cases', function () {
+        it('should handle rapid consecutive operations', function () {
+            // Rapid amount changes (start from 1 since 0 is not valid)
+            for (let i = 1; i <= 100; i++) {
+                builder.amount(BigInt(i * 1000));
+            }
+            // Should handle rapid operations
+            assert.ok(true);
+        });
+        it('should handle maximum bigint values', function () {
+            const maxValues = [
+                BigInt(Number.MAX_SAFE_INTEGER),
+                BigInt('18446744073709551615'), // Max uint64
+            ];
+            maxValues.forEach((value) => {
+                assert.doesNotThrow(() => {
+                    builder.amount(value);
+                }, `Should handle max value: ${value}`);
+            });
+        });
+        it('should handle minimum valid values', function () {
+            const minValues = [1n]; // Removed 0n since it's not valid
+            minValues.forEach((value) => {
+                assert.doesNotThrow(() => {
+                    builder.amount(value);
+                }, `Should handle min value: ${value}`);
+            });
+        });
+    });
+    describe('Future Implementation Readiness', function () {
+        it('should be ready for future buildFlareTransaction implementation', function () {
+            // Setup valid state
+            builder.amount(1000000000000000000n);
+            // Current implementation throws, but structure is in place
+            assert.throws(() => {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                builder.buildFlareTransaction();
+            }, /not implemented/);
+        });
+        it('should be ready for future verifyTxType implementation', function () {
+            // Current implementation returns false
+            const result = builder.verifyTxType({ type: 'export' });
+            assert.strictEqual(result, false);
+            // But method signature is ready for implementation
+            assert.ok(typeof builder.verifyTxType === 'function');
+        });
+        it('should be ready for future exportedOutputs implementation', function () {
+            // Current implementation returns empty array
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const result = builder.exportedOutputs();
+            assert.ok(Array.isArray(result));
+            // But method exists and is ready for implementation
+            assert.strictEqual(result.length, 0);
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"exportInPTxBuilder.js","sourceRoot":"","sources":["../../../../test/unit/lib/exportInPTxBuilder.ts"],"names":[],"mappings":"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","sourcesContent":["import { coins } from '@bitgo/statics';\nimport * as assert from 'assert';\nimport { ExportInPTxBuilder } from '../../../src/lib/exportInPTxBuilder';\n\ndescribe('ExportInPTxBuilder', function () {\n  const coinConfig = coins.get('tflrp');\n  let builder: ExportInPTxBuilder;\n\n  beforeEach(function () {\n    builder = new ExportInPTxBuilder(coinConfig);\n  });\n\n  describe('Constructor', function () {\n    it('should initialize with coin config', function () {\n      assert.ok(builder);\n      assert.ok(builder instanceof ExportInPTxBuilder);\n    });\n\n    it('should extend AtomicTransactionBuilder', function () {\n      // Test inheritance\n      assert.ok(builder);\n    });\n\n    it('should initialize with default amount', function () {\n      // Default amount should be 0n\n      assert.ok(builder);\n    });\n  });\n\n  describe('Amount Management', function () {\n    it('should set valid bigint amounts', function () {\n      const validAmounts = [1000n, 1000000000000000000n, 999999999999999999n]; // Removed 0n\n\n      validAmounts.forEach((amount) => {\n        assert.doesNotThrow(() => {\n          builder.amount(amount);\n        }, `Should accept bigint amount: ${amount}`);\n      });\n    });\n\n    it('should set string amounts', function () {\n      const stringAmounts = ['1000', '1000000000000000000', '999999999999999999']; // Removed '0'\n\n      stringAmounts.forEach((amount) => {\n        assert.doesNotThrow(() => {\n          builder.amount(amount);\n        }, `Should accept string amount: ${amount}`);\n      });\n    });\n\n    it('should set numeric amounts', function () {\n      const numericAmounts = [1000, 2000000, 999999999]; // Removed 0\n\n      numericAmounts.forEach((amount) => {\n        assert.doesNotThrow(() => {\n          builder.amount(amount);\n        }, `Should accept numeric amount: ${amount}`);\n      });\n    });\n\n    it('should reject zero amount', function () {\n      assert.throws(() => {\n        builder.amount(0n);\n      }, /Amount must be positive/);\n\n      assert.throws(() => {\n        builder.amount('0');\n      }, /Amount must be positive/);\n\n      assert.throws(() => {\n        builder.amount(0);\n      }, /Amount must be positive/);\n    });\n\n    it('should handle large amounts', function () {\n      const largeAmounts = [\n        '100000000000000000000000', // Very large amount\n        '18446744073709551615', // Near uint64 max\n        BigInt('999999999999999999999999999999'),\n        999999999999999999n,\n      ];\n\n      largeAmounts.forEach((amount) => {\n        assert.doesNotThrow(() => {\n          builder.amount(amount);\n        }, `Should handle large amount: ${amount}`);\n      });\n    });\n\n    it('should reject negative amounts', function () {\n      const negativeAmounts = ['-1000', '-1'];\n\n      negativeAmounts.forEach((amount) => {\n        assert.throws(\n          () => {\n            builder.amount(amount);\n          },\n          Error, // validateAmount should throw error for negative amounts\n          `Should reject negative amount: ${amount}`\n        );\n      });\n    });\n\n    it('should reject negative bigint amounts', function () {\n      const negativeBigints = [-1n, -1000n, -999999999999n];\n\n      negativeBigints.forEach((amount) => {\n        assert.throws(\n          () => {\n            builder.amount(amount);\n          },\n          Error,\n          `Should reject negative bigint amount: ${amount}`\n        );\n      });\n    });\n\n    it('should chain amount setting with other methods', function () {\n      const amount = 1000000000000000000n; // 1 FLR\n\n      assert.doesNotThrow(() => {\n        builder.amount(amount);\n      });\n    });\n  });\n\n  describe('Transaction Type', function () {\n    it('should return Export transaction type', function () {\n      // Can't access protected method directly, but test doesn't throw\n      assert.ok(builder);\n    });\n  });\n\n  describe('Transaction Initialization', function () {\n    it('should initialize builder from transaction', function () {\n      const mockTx = { type: 'export', data: 'placeholder' };\n\n      assert.doesNotThrow(() => {\n        builder.initBuilder(mockTx);\n      });\n    });\n\n    it('should handle null transaction initialization', function () {\n      assert.doesNotThrow(() => {\n        builder.initBuilder(null);\n      });\n    });\n\n    it('should handle undefined transaction initialization', function () {\n      assert.doesNotThrow(() => {\n        builder.initBuilder(undefined);\n      });\n    });\n\n    it('should handle object transaction initialization', function () {\n      const mockTx = {\n        id: 'test-tx',\n        type: 'export',\n        amount: '1000000000000000000',\n        from: 'P-flare1source',\n        to: 'C-flare1dest',\n      };\n\n      assert.doesNotThrow(() => {\n        builder.initBuilder(mockTx);\n      });\n    });\n  });\n\n  describe('Transaction Type Verification', function () {\n    it('should verify transaction type (returns false - not implemented)', function () {\n      const mockTx = { type: 'export' };\n      const result = ExportInPTxBuilder.verifyTxType(mockTx);\n      assert.strictEqual(result, false); // Not implemented yet\n    });\n\n    it('should handle different transaction objects', function () {\n      const testCases = [{}, null, undefined, { type: 'import' }, { data: 'test' }];\n\n      testCases.forEach((testCase, index) => {\n        const result = ExportInPTxBuilder.verifyTxType(testCase);\n        assert.strictEqual(result, false, `Test case ${index} should return false (not implemented)`);\n      });\n    });\n\n    it('should verify via instance method', function () {\n      const mockTx = { type: 'export' };\n      const result = builder.verifyTxType(mockTx);\n      assert.strictEqual(result, false); // Not implemented\n    });\n\n    it('should verify static and instance methods return same result', function () {\n      const mockTx = { type: 'export' };\n      const staticResult = ExportInPTxBuilder.verifyTxType(mockTx);\n      const instanceResult = builder.verifyTxType(mockTx);\n      assert.strictEqual(staticResult, instanceResult);\n    });\n  });\n\n  describe('Transaction Building', function () {\n    it('should throw error when building (not implemented)', function () {\n      builder.amount(1000000000000000000n);\n\n      assert.throws(() => {\n        // Access protected method for testing\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        (builder as any).buildFlareTransaction();\n      }, Error);\n    });\n\n    it('should throw specific error message', function () {\n      assert.throws(() => {\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        (builder as any).buildFlareTransaction();\n      }, /Flare P-chain export transaction build not implemented/);\n    });\n  });\n\n  describe('Exported Outputs', function () {\n    it('should return empty array for exported outputs', function () {\n      // Access protected method for testing\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      const result = (builder as any).exportedOutputs();\n\n      assert.ok(Array.isArray(result));\n      assert.strictEqual(result.length, 0);\n    });\n\n    it('should consistently return empty array', function () {\n      // Call multiple times to ensure consistency\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      const result1 = (builder as any).exportedOutputs();\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      const result2 = (builder as any).exportedOutputs();\n\n      assert.deepStrictEqual(result1, result2);\n    });\n  });\n\n  describe('Amount Validation', function () {\n    it('should validate positive amounts', function () {\n      const positiveAmounts = [1n, 1000n, 1000000000000000000n];\n\n      positiveAmounts.forEach((amount) => {\n        assert.doesNotThrow(() => {\n          builder.amount(amount);\n        }, `Should validate positive amount: ${amount}`);\n      });\n    });\n\n    it('should reject zero amount', function () {\n      assert.throws(() => {\n        builder.amount(0n);\n      }, /Amount must be positive/);\n    });\n\n    it('should validate large amounts', function () {\n      const largeAmounts = [\n        BigInt('18446744073709551615'), // Max uint64\n        BigInt('999999999999999999999999999999'), // Very large\n      ];\n\n      largeAmounts.forEach((amount) => {\n        assert.doesNotThrow(() => {\n          builder.amount(amount);\n        }, `Should validate large amount: ${amount}`);\n      });\n    });\n  });\n\n  describe('Integration Tests', function () {\n    it('should handle basic P-chain export setup', function () {\n      const amount = 5000000000000000000n; // 5 FLR\n\n      // Basic setup\n      builder.amount(amount);\n\n      // Should not throw during setup\n      assert.ok(true);\n    });\n\n    it('should handle amount conversion from different types', function () {\n      // Test conversion from string\n      builder.amount('1000000000000000000');\n\n      // Test conversion from number\n      builder.amount(1000000);\n\n      // Test direct bigint\n      builder.amount(2000000000000000000n);\n\n      // All conversions should work\n      assert.ok(true);\n    });\n\n    it('should maintain state across operations', function () {\n      // Set amount\n      builder.amount(1000000000000000000n);\n\n      // Initialize with transaction\n      const mockTx = { type: 'export' };\n      builder.initBuilder(mockTx);\n\n      // State should be maintained\n      assert.ok(true);\n    });\n\n    it('should handle sequential amount updates', function () {\n      // Update amount multiple times\n      builder.amount(1000n);\n      builder.amount(2000n);\n      builder.amount(3000n);\n\n      // Should handle updates without issues\n      assert.ok(true);\n    });\n  });\n\n  describe('Error Handling', function () {\n    it('should handle invalid amount types gracefully', function () {\n      const invalidAmounts = [null, undefined, {}, [], 'invalid'];\n\n      invalidAmounts.forEach((amount) => {\n        assert.throws(() => {\n          // eslint-disable-next-line @typescript-eslint/no-explicit-any\n          builder.amount(amount as any);\n        }, `Should throw for invalid amount: ${amount}`);\n      });\n    });\n\n    it('should handle edge case string amounts', function () {\n      const edgeCaseAmounts = ['', '  ', 'abc', '1.5', 'infinity', 'NaN'];\n\n      edgeCaseAmounts.forEach((amount) => {\n        assert.throws(() => {\n          builder.amount(amount);\n        }, `Should throw for edge case amount: ${amount}`);\n      });\n    });\n  });\n\n  describe('Inheritance Tests', function () {\n    it('should inherit from AtomicTransactionBuilder', function () {\n      // Test that builder has expected inherited functionality\n      assert.ok(builder);\n\n      // Should have initBuilder method\n      assert.ok(typeof builder.initBuilder === 'function');\n\n      // Should have verifyTxType method\n      assert.ok(typeof builder.verifyTxType === 'function');\n    });\n\n    it('should have access to inherited UTXO methods', function () {\n      // Should inherit utxos method from parent\n      assert.ok(typeof builder.utxos === 'function');\n    });\n  });\n\n  describe('Edge Cases', function () {\n    it('should handle rapid consecutive operations', function () {\n      // Rapid amount changes (start from 1 since 0 is not valid)\n      for (let i = 1; i <= 100; i++) {\n        builder.amount(BigInt(i * 1000));\n      }\n\n      // Should handle rapid operations\n      assert.ok(true);\n    });\n\n    it('should handle maximum bigint values', function () {\n      const maxValues = [\n        BigInt(Number.MAX_SAFE_INTEGER),\n        BigInt('18446744073709551615'), // Max uint64\n      ];\n\n      maxValues.forEach((value) => {\n        assert.doesNotThrow(() => {\n          builder.amount(value);\n        }, `Should handle max value: ${value}`);\n      });\n    });\n\n    it('should handle minimum valid values', function () {\n      const minValues = [1n]; // Removed 0n since it's not valid\n\n      minValues.forEach((value) => {\n        assert.doesNotThrow(() => {\n          builder.amount(value);\n        }, `Should handle min value: ${value}`);\n      });\n    });\n  });\n\n  describe('Future Implementation Readiness', function () {\n    it('should be ready for future buildFlareTransaction implementation', function () {\n      // Setup valid state\n      builder.amount(1000000000000000000n);\n\n      // Current implementation throws, but structure is in place\n      assert.throws(() => {\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        (builder as any).buildFlareTransaction();\n      }, /not implemented/);\n    });\n\n    it('should be ready for future verifyTxType implementation', function () {\n      // Current implementation returns false\n      const result = builder.verifyTxType({ type: 'export' });\n      assert.strictEqual(result, false);\n\n      // But method signature is ready for implementation\n      assert.ok(typeof builder.verifyTxType === 'function');\n    });\n\n    it('should be ready for future exportedOutputs implementation', function () {\n      // Current implementation returns empty array\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      const result = (builder as any).exportedOutputs();\n      assert.ok(Array.isArray(result));\n\n      // But method exists and is ready for implementation\n      assert.strictEqual(result.length, 0);\n    });\n  });\n});\n"]}

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

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

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

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