@luxfi/exchange 0.1.0

package/dist/bridge/use-cross-chain-mint.js

@@ -0,0 +1,228 @@
+/**
+ * React hook for one-click cross-chain minting
+ *
+ * Enables users to mint wrapped tokens on C-Chain from X-Chain assets
+ * with a single transaction using Warp atomic swaps.
+ */
+import { useCallback, useEffect, useState } from 'react';
+import { usePublicClient, useWalletClient } from 'wagmi';
+import { encodeFunctionData, parseAbi } from 'viem';
+import { useCrossChainStore } from './cross-chain-store';
+import { DEFAULT_SWAP_CONFIG, getWrappedToken } from './types';
+// AtomicSwapBridge contract ABI (minimal interface)
+const BRIDGE_ABI = parseAbi([
+    'function initiateMint(bytes32 swapId, address recipient, bytes32 asset, uint256 amount, uint256 minReceive, uint64 deadline, tuple(address tokenIn, address tokenOut, uint24 poolFee, int24 tickSpacing, address hooks)[] routes) external payable',
+    'function processLockMessage(uint32 messageIndex) external',
+    'function executeSwap(bytes32 swapId, tuple(address tokenIn, address tokenOut, uint24 poolFee, int24 tickSpacing, address hooks)[] routes) external',
+    'function settleSwap(bytes32 swapId, bytes32 preimage) external',
+    'function cancelSwap(bytes32 swapId) external',
+    'function getSwapState(bytes32 swapId) external view returns (uint8 state, address sender, address recipient, bytes32 asset, uint256 amount, uint256 minReceive, uint64 deadline)',
+    'event SwapInitiated(bytes32 indexed swapId, address indexed sender, address indexed recipient, bytes32 asset, uint256 amount)',
+    'event SwapCompleted(bytes32 indexed swapId, uint256 amountReceived)',
+    'event SwapCancelled(bytes32 indexed swapId)',
+]);
+export function useCrossChainMint(options = {}) {
+    const { config: configOverrides, pollInterval = 5000 } = options;
+    const config = { ...DEFAULT_SWAP_CONFIG, ...configOverrides };
+    const publicClient = usePublicClient();
+    const { data: walletClient } = useWalletClient();
+    const store = useCrossChainStore();
+    const [isLoading, setIsLoading] = useState(false);
+    const [error, setError] = useState(null);
+    /**
+     * Initiate a one-click cross-chain mint
+     */
+    const mint = useCallback(async (request) => {
+        if (!walletClient) {
+            throw new Error('Wallet not connected');
+        }
+        setIsLoading(true);
+        setError(null);
+        try {
+            // Validate the asset has a wrapped token mapping
+            const wrappedToken = getWrappedToken(request.sourceAsset);
+            if (!wrappedToken) {
+                throw new Error('Asset not supported for cross-chain mint');
+            }
+            // Create the full request with deadline
+            const fullRequest = {
+                ...request,
+                deadline: request.deadline ?? Math.floor(Date.now() / 1000) + config.defaultDeadline,
+            };
+            // Initialize in store
+            const swapId = store.initiateMint(fullRequest);
+            store.updateMintStatus(swapId, 'locking');
+            // Build swap routes if target token specified
+            const routes = [];
+            if (request.targetToken && request.targetToken !== wrappedToken) {
+                routes.push({
+                    tokenIn: wrappedToken,
+                    tokenOut: request.targetToken,
+                    poolFee: 3000, // 0.3% default
+                    tickSpacing: 60,
+                });
+            }
+            // Prepare transaction data
+            const txData = encodeFunctionData({
+                abi: BRIDGE_ABI,
+                functionName: 'initiateMint',
+                args: [
+                    swapId,
+                    request.recipient,
+                    request.sourceAsset,
+                    request.amount,
+                    request.minReceive ?? BigInt(0),
+                    BigInt(fullRequest.deadline),
+                    routes.map((r) => ({
+                        tokenIn: r.tokenIn,
+                        tokenOut: r.tokenOut,
+                        poolFee: r.poolFee,
+                        tickSpacing: r.tickSpacing,
+                        hooks: r.hooks ?? '0x0000000000000000000000000000000000000000',
+                    })),
+                ],
+            });
+            // Send transaction to bridge contract
+            const hash = await walletClient.sendTransaction({
+                to: config.bridgeContract,
+                data: txData,
+                value: BigInt(0), // Native assets locked via XVM, not ETH
+            });
+            store.updateMintTxHash(swapId, 'sourceTxHash', hash);
+            store.updateMintStatus(swapId, 'waiting_confirmation');
+            // Wait for transaction confirmation
+            if (publicClient) {
+                const receipt = await publicClient.waitForTransactionReceipt({ hash });
+                if (receipt.status === 'success') {
+                    // Transaction was included, now waiting for Warp message
+                    store.updateMintStatus(swapId, 'minting');
+                    // The bridge contract handles the rest:
+                    // 1. Warp message is sent to destination chain
+                    // 2. Validators sign the message
+                    // 3. Message is processed, wrapped tokens minted
+                    // 4. Optional DEX swap executed
+                    // 5. Tokens delivered to recipient
+                }
+                else {
+                    store.failMint(swapId, 'Transaction failed');
+                }
+            }
+            return swapId;
+        }
+        catch (err) {
+            const errorMessage = err instanceof Error ? err.message : 'Unknown error';
+            setError(errorMessage);
+            throw err;
+        }
+        finally {
+            setIsLoading(false);
+        }
+    }, [walletClient, publicClient, store, config]);
+    /**
+     * Cancel a pending mint after deadline
+     */
+    const cancel = useCallback(async (swapId) => {
+        if (!walletClient) {
+            throw new Error('Wallet not connected');
+        }
+        const pending = store.getPendingMint(swapId);
+        if (!pending) {
+            throw new Error('Mint not found');
+        }
+        // Check deadline
+        if (pending.deadline > Date.now() / 1000) {
+            throw new Error('Cannot cancel before deadline');
+        }
+        const txData = encodeFunctionData({
+            abi: BRIDGE_ABI,
+            functionName: 'cancelSwap',
+            args: [swapId],
+        });
+        const hash = await walletClient.sendTransaction({
+            to: config.bridgeContract,
+            data: txData,
+        });
+        if (publicClient) {
+            await publicClient.waitForTransactionReceipt({ hash });
+        }
+        store.cancelMint(swapId);
+    }, [walletClient, publicClient, store, config]);
+    /**
+     * Get mint state by swap ID
+     */
+    const getMintState = useCallback((swapId) => {
+        return store.getPendingMint(swapId)?.state;
+    }, [store]);
+    /**
+     * Poll for status updates on active mints
+     */
+    useEffect(() => {
+        if (!publicClient)
+            return;
+        const activeMints = store.getActiveMints();
+        if (activeMints.length === 0)
+            return;
+        const pollStatuses = async () => {
+            for (const mint of activeMints) {
+                if (!mint.state.swapId)
+                    continue;
+                try {
+                    // Query on-chain state
+                    const state = await publicClient.readContract({
+                        address: config.bridgeContract,
+                        abi: BRIDGE_ABI,
+                        functionName: 'getSwapState',
+                        args: [mint.state.swapId],
+                    });
+                    // Map on-chain state to our status
+                    const [onChainState] = state;
+                    let newStatus = mint.state.status;
+                    switch (onChainState) {
+                        case 0: // Pending
+                            newStatus = 'waiting_confirmation';
+                            break;
+                        case 1: // Locked
+                            newStatus = 'locking';
+                            break;
+                        case 2: // Minted
+                            newStatus = 'minting';
+                            break;
+                        case 3: // Swapped
+                            newStatus = 'swapping';
+                            break;
+                        case 4: // Settled
+                            newStatus = 'complete';
+                            store.completeMint(mint.state.swapId);
+                            break;
+                        case 5: // Cancelled
+                            newStatus = 'cancelled';
+                            store.cancelMint(mint.state.swapId);
+                            break;
+                        case 6: // Expired
+                            newStatus = 'failed';
+                            store.failMint(mint.state.swapId, 'Swap expired');
+                            break;
+                    }
+                    if (newStatus !== mint.state.status && onChainState < 4) {
+                        store.updateMintStatus(mint.state.swapId, newStatus);
+                    }
+                }
+                catch {
+                    // Ignore polling errors
+                }
+            }
+        };
+        pollStatuses();
+        const interval = setInterval(pollStatuses, pollInterval);
+        return () => clearInterval(interval);
+    }, [publicClient, store, config, pollInterval]);
+    return {
+        mint,
+        cancel,
+        getMintState,
+        activeMints: store.pendingMints,
+        recentMints: store.recentMints,
+        isLoading,
+        error,
+    };
+}

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

@@ -0,0 +1,69 @@
+/**
+ * Private Teleport Hook
+ *
+ * React hook for cross-chain private teleportation
+ * Enables: XVM UTXO → ZNote (shielded) → Z-Chain AMM → destination
+ */
+import { type PrivateTeleportConfig, type PrivateTeleportRequest, type TeleportRecord, type TeleportState } from './private-teleport-types';
+export interface UsePrivateTeleportOptions {
+    /** Custom config */
+    config?: Partial<PrivateTeleportConfig>;
+    /** Enable auto-polling for teleport status */
+    pollInterval?: number;
+    /** Callback when teleport state changes */
+    onStateChange?: (teleportId: string, state: TeleportState) => void;
+}
+/** Private transfer request to another recipient */
+export interface PrivateTransferRequest {
+    teleportId: string;
+    /** Recipient's viewing public key (for note encryption) */
+    recipientViewKey: `0x${string}`;
+    /** Amount to send (will generate new commitment) */
+    amount: bigint;
+    /** Optional: change amount back to sender */
+    changeAmount?: bigint;
+}
+/** Unshield request to X-Chain */
+export interface UnshieldToXChainRequest {
+    teleportId: string;
+    /** X-Chain destination address (bech32 format) */
+    destinationAddress: string;
+    /** Amount to unshield (must match commitment) */
+    amount: bigint;
+}
+export interface UsePrivateTeleportReturn {
+    /** Initiate a private teleport */
+    teleport: (request: PrivateTeleportRequest) => Promise<string>;
+    /** Execute private swap on Z-Chain AMM */
+    executeSwap: (teleportId: string, poolId: string, minOutput: bigint) => Promise<void>;
+    /** Export to C-Chain (unshield) */
+    exportToDestination: (teleportId: string) => Promise<void>;
+    /** Unshield back to X-Chain UTXO */
+    unshieldToXChain: (request: UnshieldToXChainRequest) => Promise<string>;
+    /** Private transfer to another recipient (stays shielded) */
+    privateTransfer: (request: PrivateTransferRequest) => Promise<number>;
+    /** Split note into payment + change */
+    splitAndTransfer: (teleportId: string, outputs: Array<{
+        recipient: `0x${string}`;
+        amount: bigint;
+    }>) => Promise<number[]>;
+    /** Complete teleport after confirmation */
+    completeTeleport: (teleportId: string, warpConfirmation: `0x${string}`) => Promise<void>;
+    /** Cancel teleport */
+    cancelTeleport: (teleportId: string) => Promise<void>;
+    /** Get teleport record */
+    getTeleport: (teleportId: string) => Promise<TeleportRecord | null>;
+    /** Check if teleport is complete */
+    isComplete: (teleportId: string) => Promise<boolean>;
+    /** Current teleport ID (if any) */
+    currentTeleportId: string | null;
+    /** Current teleport state */
+    currentState: TeleportState | null;
+    /** Loading state */
+    isLoading: boolean;
+    /** Error state */
+    error: Error | null;
+}
+export declare function usePrivateTeleport(options?: UsePrivateTeleportOptions): UsePrivateTeleportReturn;
+export type { PrivateTeleportRequest, TeleportRecord, TeleportState, PrivateTeleportConfig, } from './private-teleport-types';
+//# sourceMappingURL=use-private-teleport.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"use-private-teleport.d.ts","sourceRoot":"","sources":["../../src/bridge/use-private-teleport.ts"],"names":[],"mappings":"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"}