@luxfi/exchange 0.1.0

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

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

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,272 @@
+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
+    });
+});

package/dist/bridge/cross-chain-store.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Zustand store for cross-chain mint operations
+ */
+import type { CrossChainMintRequest, CrossChainMintState, CrossChainMintStatus } from './types';
+interface PendingMint extends CrossChainMintRequest {
+    state: CrossChainMintState;
+}
+export interface CrossChainStore {
+    /** Currently active mints by swap ID */
+    pendingMints: Record<string, PendingMint>;
+    /** Most recent completed mints (for history) */
+    recentMints: PendingMint[];
+    /** Maximum number of recent mints to keep */
+    maxRecentMints: number;
+    initiateMint: (request: CrossChainMintRequest) => string;
+    updateMintStatus: (swapId: string, status: CrossChainMintStatus) => void;
+    updateMintTxHash: (swapId: string, field: 'sourceTxHash' | 'mintTxHash' | 'swapTxHash', hash: string) => void;
+    completeMint: (swapId: string) => void;
+    failMint: (swapId: string, error: string) => void;
+    cancelMint: (swapId: string) => void;
+    clearPendingMint: (swapId: string) => void;
+    getPendingMint: (swapId: string) => PendingMint | undefined;
+    getActiveMints: () => PendingMint[];
+}
+export declare const useCrossChainStore: import("zustand").UseBoundStore<Omit<Omit<import("zustand").StoreApi<CrossChainStore>, "setState" | "devtools"> & {
+    setState(partial: CrossChainStore | Partial<CrossChainStore> | ((state: CrossChainStore) => CrossChainStore | Partial<CrossChainStore>), replace?: false | undefined, action?: (string | {
+        [x: string]: unknown;
+        [x: number]: unknown;
+        [x: symbol]: unknown;
+        type: string;
+    }) | undefined): void;
+    setState(state: CrossChainStore | ((state: CrossChainStore) => CrossChainStore), replace: true, action?: (string | {
+        [x: string]: unknown;
+        [x: number]: unknown;
+        [x: symbol]: unknown;
+        type: string;
+    }) | undefined): void;
+    devtools: {
+        cleanup: () => void;
+    };
+}, "persist"> & {
+    persist: {
+        setOptions: (options: Partial<import("zustand/middleware").PersistOptions<CrossChainStore, {
+            recentMints: PendingMint[];
+        }>>) => void;
+        clearStorage: () => void;
+        rehydrate: () => Promise<void> | void;
+        hasHydrated: () => boolean;
+        onHydrate: (fn: (state: CrossChainStore) => void) => () => void;
+        onFinishHydration: (fn: (state: CrossChainStore) => void) => () => void;
+        getOptions: () => Partial<import("zustand/middleware").PersistOptions<CrossChainStore, {
+            recentMints: PendingMint[];
+        }>>;
+    };
+}>;
+export {};
+//# sourceMappingURL=cross-chain-store.d.ts.map

package/dist/bridge/cross-chain-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cross-chain-store.d.ts","sourceRoot":"","sources":["../../src/bridge/cross-chain-store.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH,OAAO,KAAK,EAAE,qBAAqB,EAAE,mBAAmB,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAA;AAE/F,UAAU,WAAY,SAAQ,qBAAqB;IACjD,KAAK,EAAE,mBAAmB,CAAA;CAC3B;AAED,MAAM,WAAW,eAAe;IAC9B,wCAAwC;IACxC,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,CAAA;IACzC,gDAAgD;IAChD,WAAW,EAAE,WAAW,EAAE,CAAA;IAC1B,6CAA6C;IAC7C,cAAc,EAAE,MAAM,CAAA;IAGtB,YAAY,EAAE,CAAC,OAAO,EAAE,qBAAqB,KAAK,MAAM,CAAA;IACxD,gBAAgB,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,oBAAoB,KAAK,IAAI,CAAA;IACxE,gBAAgB,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,cAAc,GAAG,YAAY,GAAG,YAAY,EAAE,IAAI,EAAE,MAAM,KAAK,IAAI,CAAA;IAC7G,YAAY,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAA;IACtC,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,IAAI,CAAA;IACjD,UAAU,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAA;IACpC,gBAAgB,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAA;IAC1C,cAAc,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,WAAW,GAAG,SAAS,CAAA;IAC3D,cAAc,EAAE,MAAM,WAAW,EAAE,CAAA;CACpC;AASD,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA0K9B,CAAA"}

package/dist/bridge/cross-chain-store.js

@@ -0,0 +1,158 @@
+/**
+ * Zustand store for cross-chain mint operations
+ */
+import { create } from 'zustand';
+import { devtools, persist } from 'zustand/middleware';
+// Generate a random swap ID
+function generateSwapId() {
+    const bytes = new Uint8Array(32);
+    crypto.getRandomValues(bytes);
+    return '0x' + Array.from(bytes).map(b => b.toString(16).padStart(2, '0')).join('');
+}
+export const useCrossChainStore = create()(devtools(persist((set, get) => ({
+    pendingMints: {},
+    recentMints: [],
+    maxRecentMints: 20,
+    initiateMint: (request) => {
+        const swapId = generateSwapId();
+        const now = Date.now();
+        const pendingMint = {
+            ...request,
+            state: {
+                swapId: swapId,
+                status: 'initiating',
+                sourceTxHash: null,
+                mintTxHash: null,
+                swapTxHash: null,
+                error: null,
+                startedAt: now,
+                completedAt: null,
+            },
+        };
+        set((state) => ({
+            pendingMints: {
+                ...state.pendingMints,
+                [swapId]: pendingMint,
+            },
+        }));
+        return swapId;
+    },
+    updateMintStatus: (swapId, status) => {
+        set((state) => {
+            const mint = state.pendingMints[swapId];
+            if (!mint)
+                return state;
+            return {
+                pendingMints: {
+                    ...state.pendingMints,
+                    [swapId]: {
+                        ...mint,
+                        state: {
+                            ...mint.state,
+                            status,
+                        },
+                    },
+                },
+            };
+        });
+    },
+    updateMintTxHash: (swapId, field, hash) => {
+        set((state) => {
+            const mint = state.pendingMints[swapId];
+            if (!mint)
+                return state;
+            return {
+                pendingMints: {
+                    ...state.pendingMints,
+                    [swapId]: {
+                        ...mint,
+                        state: {
+                            ...mint.state,
+                            [field]: hash,
+                        },
+                    },
+                },
+            };
+        });
+    },
+    completeMint: (swapId) => {
+        set((state) => {
+            const mint = state.pendingMints[swapId];
+            if (!mint)
+                return state;
+            const completedMint = {
+                ...mint,
+                state: {
+                    ...mint.state,
+                    status: 'complete',
+                    completedAt: Date.now(),
+                },
+            };
+            const { [swapId]: _, ...remainingPending } = state.pendingMints;
+            const newRecent = [completedMint, ...state.recentMints].slice(0, state.maxRecentMints);
+            return {
+                pendingMints: remainingPending,
+                recentMints: newRecent,
+            };
+        });
+    },
+    failMint: (swapId, error) => {
+        set((state) => {
+            const mint = state.pendingMints[swapId];
+            if (!mint)
+                return state;
+            return {
+                pendingMints: {
+                    ...state.pendingMints,
+                    [swapId]: {
+                        ...mint,
+                        state: {
+                            ...mint.state,
+                            status: 'failed',
+                            error,
+                            completedAt: Date.now(),
+                        },
+                    },
+                },
+            };
+        });
+    },
+    cancelMint: (swapId) => {
+        set((state) => {
+            const mint = state.pendingMints[swapId];
+            if (!mint)
+                return state;
+            return {
+                pendingMints: {
+                    ...state.pendingMints,
+                    [swapId]: {
+                        ...mint,
+                        state: {
+                            ...mint.state,
+                            status: 'cancelled',
+                            completedAt: Date.now(),
+                        },
+                    },
+                },
+            };
+        });
+    },
+    clearPendingMint: (swapId) => {
+        set((state) => {
+            const { [swapId]: _, ...remainingPending } = state.pendingMints;
+            return { pendingMints: remainingPending };
+        });
+    },
+    getPendingMint: (swapId) => {
+        return get().pendingMints[swapId];
+    },
+    getActiveMints: () => {
+        const { pendingMints } = get();
+        return Object.values(pendingMints).filter((m) => m.state.status !== 'failed' && m.state.status !== 'cancelled');
+    },
+}), {
+    name: 'cross-chain-mint-storage',
+    partialize: (state) => ({
+        recentMints: state.recentMints,
+    }),
+}), { name: 'CrossChainStore' }));

package/dist/bridge/index.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Cross-chain bridge module for XVM ↔ C-Chain atomic swaps
+ *
+ * Enables one-click minting of wrapped tokens on C-Chain from X-Chain assets
+ * using Warp cross-chain messaging and HTLC atomic swaps.
+ *
+ * Includes Z-Chain privacy layer for fully shielded cross-chain teleportation:
+ * XVM UTXO → ZNote (shielded) → Z-Chain AMM (private swap) → destination
+ *
+ * @example
+ * ```tsx
+ * // Standard cross-chain mint
+ * import { useCrossChainMint } from '@luxfi/exchange/bridge'
+ *
+ * function MintButton() {
+ *   const { mint, isLoading } = useCrossChainMint()
+ *
+ *   const handleMint = async () => {
+ *     const swapId = await mint({
+ *       sourceAsset: '0x...', // XVM asset ID
+ *       amount: 1000000n,     // 1 token (6 decimals)
+ *       recipient: '0x...',   // C-Chain recipient
+ *       targetToken: '0x...', // Optional: swap to this token
+ *       minReceive: 990000n,  // Slippage protection
+ *     })
+ *     console.log('Mint initiated:', swapId)
+ *   }
+ *
+ *   return (
+ *     <button onClick={handleMint} disabled={isLoading}>
+ *       {isLoading ? 'Minting...' : 'Mint on C-Chain'}
+ *     </button>
+ *   )
+ * }
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // Private teleport with Z-Chain
+ * import { usePrivateTeleport } from '@luxfi/exchange/bridge'
+ *
+ * function PrivateTeleportButton() {
+ *   const { teleport, executeSwap, exportToDestination, isLoading } = usePrivateTeleport()
+ *
+ *   const handlePrivateTeleport = async () => {
+ *     // 1. Initiate shielded teleport (creates ZNote)
+ *     const teleportId = await teleport({
+ *       sourceChain: '0x...', // X-Chain ID
+ *       destChain: '0x...',   // C-Chain ID
+ *       sourceAsset: '0x...', // Asset to teleport
+ *       destAsset: '0x...',   // Asset to receive (if swapping)
+ *       amount: 1000000n,     // Amount (will be encrypted)
+ *       recipient: '0x...',   // Destination address
+ *       deadline: Math.floor(Date.now() / 1000) + 3600,
+ *       privateSwap: true,    // Use Z-Chain AMM for private swap
+ *     })
+ *
+ *     // 2. Execute private swap on Z-Chain (optional)
+ *     await executeSwap(teleportId, '0x...poolId', 990000n)
+ *
+ *     // 3. Export to destination chain with range proof
+ *     await exportToDestination(teleportId)
+ *   }
+ *
+ *   return (
+ *     <button onClick={handlePrivateTeleport} disabled={isLoading}>
+ *       Private Teleport
+ *     </button>
+ *   )
+ * }
+ * ```
+ */
+export * from './types';
+export * from './cross-chain-store';
+export * from './use-cross-chain-mint';
+export * from './private-teleport-types';
+export * from './use-private-teleport';
+//# sourceMappingURL=index.d.ts.map

package/dist/bridge/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/bridge/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuEG;AAGH,cAAc,SAAS,CAAA;AACvB,cAAc,qBAAqB,CAAA;AACnC,cAAc,wBAAwB,CAAA;AAGtC,cAAc,0BAA0B,CAAA;AACxC,cAAc,wBAAwB,CAAA"}

package/dist/bridge/index.js

@@ -0,0 +1,79 @@
+/**
+ * Cross-chain bridge module for XVM ↔ C-Chain atomic swaps
+ *
+ * Enables one-click minting of wrapped tokens on C-Chain from X-Chain assets
+ * using Warp cross-chain messaging and HTLC atomic swaps.
+ *
+ * Includes Z-Chain privacy layer for fully shielded cross-chain teleportation:
+ * XVM UTXO → ZNote (shielded) → Z-Chain AMM (private swap) → destination
+ *
+ * @example
+ * ```tsx
+ * // Standard cross-chain mint
+ * import { useCrossChainMint } from '@luxfi/exchange/bridge'
+ *
+ * function MintButton() {
+ *   const { mint, isLoading } = useCrossChainMint()
+ *
+ *   const handleMint = async () => {
+ *     const swapId = await mint({
+ *       sourceAsset: '0x...', // XVM asset ID
+ *       amount: 1000000n,     // 1 token (6 decimals)
+ *       recipient: '0x...',   // C-Chain recipient
+ *       targetToken: '0x...', // Optional: swap to this token
+ *       minReceive: 990000n,  // Slippage protection
+ *     })
+ *     console.log('Mint initiated:', swapId)
+ *   }
+ *
+ *   return (
+ *     <button onClick={handleMint} disabled={isLoading}>
+ *       {isLoading ? 'Minting...' : 'Mint on C-Chain'}
+ *     </button>
+ *   )
+ * }
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // Private teleport with Z-Chain
+ * import { usePrivateTeleport } from '@luxfi/exchange/bridge'
+ *
+ * function PrivateTeleportButton() {
+ *   const { teleport, executeSwap, exportToDestination, isLoading } = usePrivateTeleport()
+ *
+ *   const handlePrivateTeleport = async () => {
+ *     // 1. Initiate shielded teleport (creates ZNote)
+ *     const teleportId = await teleport({
+ *       sourceChain: '0x...', // X-Chain ID
+ *       destChain: '0x...',   // C-Chain ID
+ *       sourceAsset: '0x...', // Asset to teleport
+ *       destAsset: '0x...',   // Asset to receive (if swapping)
+ *       amount: 1000000n,     // Amount (will be encrypted)
+ *       recipient: '0x...',   // Destination address
+ *       deadline: Math.floor(Date.now() / 1000) + 3600,
+ *       privateSwap: true,    // Use Z-Chain AMM for private swap
+ *     })
+ *
+ *     // 2. Execute private swap on Z-Chain (optional)
+ *     await executeSwap(teleportId, '0x...poolId', 990000n)
+ *
+ *     // 3. Export to destination chain with range proof
+ *     await exportToDestination(teleportId)
+ *   }
+ *
+ *   return (
+ *     <button onClick={handlePrivateTeleport} disabled={isLoading}>
+ *       Private Teleport
+ *     </button>
+ *   )
+ * }
+ * ```
+ */
+// Standard cross-chain (public)
+export * from './types';
+export * from './cross-chain-store';
+export * from './use-cross-chain-mint';
+// Private teleport (Z-Chain privacy layer)
+export * from './private-teleport-types';
+export * from './use-private-teleport';