@luxfi/exchange 0.1.0 → 0.2.0

package/src/index.ts

@@ -27,5 +27,5 @@ export * from './hooks'
 // Stores
 export * from './stores'
 
-// Note: Bridge module is experimental and will be added in a future release
-// See bridge-wip/ for the work-in-progress implementation
+// Bridge (cross-chain + Z-Chain privacy layer)
+export * from './bridge'

package/dist/bridge/__tests__/use-private-teleport.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=use-private-teleport.test.d.ts.map

package/dist/bridge/__tests__/use-private-teleport.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"use-private-teleport.test.d.ts","sourceRoot":"","sources":["../../../src/bridge/__tests__/use-private-teleport.test.ts"],"names":[],"mappings":""}

package/dist/bridge/__tests__/use-private-teleport.test.js

@@ -1,272 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { TeleportState } from '../private-teleport-types';
-// Test that types are correctly exported and usable
-describe('PrivateTeleport Types', () => {
-    describe('TeleportState enum', () => {
-        it('should have correct numeric values', () => {
-            expect(TeleportState.INITIATED).toBe(0);
-            expect(TeleportState.SHIELDED).toBe(1);
-            expect(TeleportState.SWAP_COMPLETE).toBe(2);
-            expect(TeleportState.EXPORTED).toBe(3);
-            expect(TeleportState.COMPLETED).toBe(4);
-            expect(TeleportState.CANCELLED).toBe(5);
-            expect(TeleportState.EXPIRED).toBe(6);
-        });
-        it('should have all expected states', () => {
-            const states = Object.values(TeleportState).filter(v => typeof v === 'number');
-            expect(states).toHaveLength(7);
-        });
-    });
-    describe('ZNote type', () => {
-        it('should allow valid ZNote creation', () => {
-            const znote = {
-                commitment: '0x1234567890abcdef',
-                nullifier: '0xfedcba0987654321',
-                encryptedAmount: '0xencrypted',
-                owner: '0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266',
-            };
-            expect(znote.commitment).toBe('0x1234567890abcdef');
-            expect(znote.nullifier).toBe('0xfedcba0987654321');
-            expect(znote.encryptedAmount).toBe('0xencrypted');
-            expect(znote.owner).toBe('0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266');
-        });
-    });
-    describe('TeleportInfo type', () => {
-        it('should allow valid TeleportInfo creation', () => {
-            const info = {
-                id: '0xteleportId',
-                sourceChain: 1,
-                destChain: 2,
-                sourceToken: '0xsourceToken',
-                destToken: '0xdestToken',
-                sender: '0xsender',
-                recipient: '0xrecipient',
-                amount: BigInt(1000000000000000000),
-                state: TeleportState.INITIATED,
-                createdAt: BigInt(Date.now()),
-                deadline: BigInt(Date.now() + 3600000),
-            };
-            expect(info.state).toBe(TeleportState.INITIATED);
-            expect(info.sourceChain).toBe(1);
-            expect(info.destChain).toBe(2);
-        });
-        it('should handle optional znote field', () => {
-            const infoWithZNote = {
-                id: '0xteleportId',
-                sourceChain: 1,
-                destChain: 2,
-                sourceToken: '0xsourceToken',
-                destToken: '0xdestToken',
-                sender: '0xsender',
-                recipient: '0xrecipient',
-                amount: BigInt(1000000000000000000),
-                state: TeleportState.SHIELDED,
-                createdAt: BigInt(Date.now()),
-                deadline: BigInt(Date.now() + 3600000),
-                znote: {
-                    commitment: '0xcommitment',
-                    nullifier: '0xnullifier',
-                    encryptedAmount: '0xencrypted',
-                    owner: '0xowner',
-                },
-            };
-            expect(infoWithZNote.znote).toBeDefined();
-            expect(infoWithZNote.znote?.commitment).toBe('0xcommitment');
-        });
-    });
-    describe('PrivateTeleportConfig type', () => {
-        it('should allow valid config creation', () => {
-            const config = {
-                sourceChainId: 1,
-                destChainId: 2,
-                sourceToken: '0xsourceToken',
-                destToken: '0xdestToken',
-                amount: BigInt(1000000000000000000),
-                recipient: '0xrecipient',
-                slippageTolerance: 50, // 0.5%
-                deadline: BigInt(Date.now() + 3600000),
-            };
-            expect(config.sourceChainId).toBe(1);
-            expect(config.destChainId).toBe(2);
-            expect(config.slippageTolerance).toBe(50);
-        });
-    });
-});
-describe('TeleportState transitions', () => {
-    it('should follow valid state progression', () => {
-        // Valid progression: INITIATED -> SHIELDED -> SWAP_COMPLETE -> EXPORTED -> COMPLETED
-        const validProgression = [
-            TeleportState.INITIATED,
-            TeleportState.SHIELDED,
-            TeleportState.SWAP_COMPLETE,
-            TeleportState.EXPORTED,
-            TeleportState.COMPLETED,
-        ];
-        for (let i = 0; i < validProgression.length - 1; i++) {
-            expect(validProgression[i]).toBeLessThan(validProgression[i + 1]);
-        }
-    });
-    it('should identify terminal states', () => {
-        const terminalStates = [TeleportState.COMPLETED, TeleportState.CANCELLED, TeleportState.EXPIRED];
-        terminalStates.forEach((state) => {
-            expect(state).toBeGreaterThanOrEqual(TeleportState.COMPLETED);
-        });
-    });
-    it('should identify cancellable states', () => {
-        const cancellableStates = [TeleportState.INITIATED, TeleportState.SHIELDED];
-        cancellableStates.forEach((state) => {
-            expect(state).toBeLessThan(TeleportState.SWAP_COMPLETE);
-        });
-    });
-});
-describe('Amount calculations', () => {
-    it('should handle BigInt amounts correctly', () => {
-        const oneEther = BigInt(1e18);
-        const halfEther = BigInt(5e17);
-        expect(oneEther + halfEther).toBe(BigInt(15e17));
-        expect(oneEther - halfEther).toBe(halfEther);
-        expect(oneEther / BigInt(2)).toBe(halfEther);
-    });
-    it('should calculate slippage correctly', () => {
-        const amount = BigInt(1000000000000000000); // 1 ETH
-        const slippageBps = 50; // 0.5%
-        const minOutput = amount - (amount * BigInt(slippageBps)) / BigInt(10000);
-        const expectedMinOutput = BigInt(995000000000000000); // 0.995 ETH
-        expect(minOutput).toBe(expectedMinOutput);
-    });
-    it('should handle zero amounts', () => {
-        const zero = BigInt(0);
-        expect(zero).toBe(BigInt(0));
-        expect(zero + BigInt(100)).toBe(BigInt(100));
-    });
-});
-describe('Address validation helpers', () => {
-    it('should validate Ethereum addresses', () => {
-        const validAddress = '0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266';
-        expect(validAddress.length).toBe(42);
-        expect(validAddress.startsWith('0x')).toBe(true);
-        expect(/^0x[a-fA-F0-9]{40}$/.test(validAddress)).toBe(true);
-    });
-    it('should reject invalid addresses', () => {
-        const invalidAddresses = ['0x123', 'notanaddress', '0x' + 'g'.repeat(40)];
-        invalidAddresses.forEach((addr) => {
-            expect(/^0x[a-fA-F0-9]{40}$/.test(addr)).toBe(false);
-        });
-    });
-    it('should handle checksummed addresses', () => {
-        const checksummed = '0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266';
-        const lowercase = checksummed.toLowerCase();
-        expect(checksummed.toLowerCase()).toBe(lowercase);
-    });
-});
-describe('Chain ID validation', () => {
-    const supportedChains = [1, 96369, 200200, 200201]; // Mainnet, Lux, Zoo, Zootest
-    it('should identify supported chains', () => {
-        supportedChains.forEach((chainId) => {
-            expect(chainId).toBeGreaterThan(0);
-        });
-    });
-    it('should reject invalid chain IDs', () => {
-        const invalidChains = [0, -1];
-        invalidChains.forEach((chainId) => {
-            expect(chainId).toBeLessThanOrEqual(0);
-        });
-    });
-});
-describe('Deadline handling', () => {
-    it('should calculate valid deadline', () => {
-        const now = BigInt(Math.floor(Date.now() / 1000));
-        const oneHourFromNow = now + BigInt(3600);
-        expect(oneHourFromNow).toBeGreaterThan(now);
-    });
-    it('should identify expired deadlines', () => {
-        const now = BigInt(Math.floor(Date.now() / 1000));
-        const oneHourAgo = now - BigInt(3600);
-        expect(oneHourAgo).toBeLessThan(now);
-    });
-    it('should handle deadline extension', () => {
-        const now = BigInt(Math.floor(Date.now() / 1000));
-        const deadline = now + BigInt(3600);
-        const extendedDeadline = deadline + BigInt(1800); // Add 30 minutes
-        expect(extendedDeadline).toBeGreaterThan(deadline);
-        expect(extendedDeadline - deadline).toBe(BigInt(1800));
-    });
-});
-describe('Error scenarios', () => {
-    it('should handle insufficient balance error', () => {
-        const balance = BigInt(1e18);
-        const requested = BigInt(2e18);
-        expect(balance < requested).toBe(true);
-    });
-    it('should handle slippage exceeded error', () => {
-        const expectedOutput = BigInt(1e18); // 1 ETH expected
-        const actualOutput = BigInt(9e17); // 0.9 ETH received (10% slippage)
-        const minAcceptable = BigInt(95e16); // 0.95 ETH (5% slippage tolerance)
-        // Actual output is below minimum acceptable, so slippage exceeded
-        expect(actualOutput < minAcceptable).toBe(true);
-        expect(actualOutput < expectedOutput).toBe(true);
-    });
-    it('should handle deadline passed error', () => {
-        const now = Math.floor(Date.now() / 1000);
-        const expiredDeadline = now - 3600;
-        expect(expiredDeadline < now).toBe(true);
-    });
-});
-describe('Privacy features', () => {
-    it('should generate unique commitments', () => {
-        // Mock commitment generation - in reality uses keccak256(secret + value)
-        const commitment1 = '0x' + '1'.repeat(64);
-        const commitment2 = '0x' + '2'.repeat(64);
-        expect(commitment1).not.toBe(commitment2);
-        expect(commitment1.length).toBe(66); // 0x + 64 hex chars
-    });
-    it('should verify nullifier uniqueness', () => {
-        const nullifiers = new Set();
-        const nullifier1 = '0x' + 'a'.repeat(64);
-        const nullifier2 = '0x' + 'b'.repeat(64);
-        nullifiers.add(nullifier1);
-        expect(nullifiers.has(nullifier1)).toBe(true);
-        expect(nullifiers.has(nullifier2)).toBe(false);
-    });
-    it('should handle encrypted amounts', () => {
-        // FHE encrypted values are opaque strings
-        const encryptedAmount = '0x' + 'encrypted_data'.padEnd(128, '0');
-        expect(encryptedAmount.startsWith('0x')).toBe(true);
-        expect(encryptedAmount.length).toBeGreaterThan(2);
-    });
-});
-describe('Swap routing', () => {
-    it('should calculate price impact', () => {
-        const inputAmount = BigInt(1e18);
-        const outputAmount = BigInt(998e15); // 0.998 ETH equivalent
-        const priceImpactBps = ((inputAmount - outputAmount) * BigInt(10000)) / inputAmount;
-        expect(priceImpactBps).toBe(BigInt(20)); // 0.2%
-    });
-    it('should select optimal route', () => {
-        const routes = [
-            { output: BigInt(990e15), path: ['A', 'B'] },
-            { output: BigInt(995e15), path: ['A', 'C', 'B'] },
-            { output: BigInt(998e15), path: ['A', 'B'] },
-        ];
-        const bestRoute = routes.reduce((best, current) => (current.output > best.output ? current : best));
-        expect(bestRoute.output).toBe(BigInt(998e15));
-    });
-});
-describe('Cross-chain message verification', () => {
-    it('should verify Warp message format', () => {
-        const warpMessage = {
-            sourceChainId: 1,
-            destChainId: 96369,
-            payload: '0x' + 'data'.padEnd(64, '0'),
-            signature: '0x' + 'sig'.padEnd(130, '0'),
-        };
-        expect(warpMessage.sourceChainId).toBe(1);
-        expect(warpMessage.destChainId).toBe(96369);
-        expect(warpMessage.payload.startsWith('0x')).toBe(true);
-    });
-    it('should validate BLS signature length', () => {
-        // BLS signatures are 96 bytes = 192 hex chars
-        const blsSignature = '0x' + '0'.repeat(192);
-        expect(blsSignature.length).toBe(194); // 0x + 192 hex chars
-    });
-});