@luxfi/exchange 0.1.0 → 1.0.0

package/dist/contracts/addresses.js

@@ -30,6 +30,10 @@ export const LUX_TESTNET_CONTRACTS = {
     WLUX: '0x732740c5c895C9FCF619930ed4293fc858eb44c7',
     WETH: '0xd9956542B51032d940ef076d70B69410667277A3',
     MULTICALL: '0xd25F88CBdAe3c2CCA3Bb75FC4E723b44C0Ea362F',
+    // Bridge tokens (testnet deployments)
+    LETH: '0x60E0a8167FC13dE89348978860466C9ceC24B9ba',
+    LBTC: '0x1E48D32a4F5e9f08DB9aE4959163300FaF8A6C8e',
+    LUSD: '0xb84112ac9318a0b2319aa11d4d10e9762b25f7f4',
     // AMM V2
     V2_FACTORY: '0x81C3669B139D92909AA67DbF74a241b10540d919',
     V2_ROUTER: '0xDB6c703c80BFaE5F9a56482d3c8535f27E1136EB',
@@ -44,38 +48,42 @@ export const LUX_TESTNET_CONTRACTS = {
     V3_NFT_DESCRIPTOR: '0x53B1aAA5b6DDFD4eD00D0A7b5Ef333dc74B605b5',
 };
 /**
- * DEX Precompile addresses (native AMM)
- * These provide sub-microsecond execution
+ * DEX Precompile addresses (native AMM - Uniswap v4 style singleton PoolManager)
+ * These provide sub-microsecond execution via native Go implementation
  *
- * Lux Precompile Address Standard:
- * - Prefix format: 0xNNNN000000000000000000000000000000000000
- * - Range 0x0400-0x04FF is reserved for DEX precompiles
+ * Address format: 0x0000...00LPNUMBER (addresses end with LP number)
+ * LP-9010: DEX Precompile - Native HFT Order Book (PoolManager)
+ * LP-9011: Oracle Precompile - Multi-Source Price Aggregation
  *
- * @see ~/work/lux/precompile/dex/module.go for implementation
+ * @see ~/work/lux/precompile/registry/registry.go for the full address scheme
+ * @see ~/work/lux/dex/pkg/gateway/lux/provider.go for gateway implementation
  */
 export const DEX_PRECOMPILES = {
-    POOL_MANAGER: '0x0400000000000000000000000000000000000000',
-    SWAP_ROUTER: '0x0401000000000000000000000000000000000000',
-    HOOKS_REGISTRY: '0x0402000000000000000000000000000000000000',
-    FLASH_LOAN: '0x0403000000000000000000000000000000000000',
-    LENDING: '0x0410000000000000000000000000000000000000',
-    LIQUID: '0x0430000000000000000000000000000000000000',
-    TELEPORT: '0x0440000000000000000000000000000000000000',
+    // Core DEX (LP-9010 series - Uniswap v4 style)
+    POOL_MANAGER: '0x0000000000000000000000000000000000009010', // LP-9010
+    SWAP_ROUTER: '0x0000000000000000000000000000000000009012', // LP-9012
+    HOOKS_REGISTRY: '0x0000000000000000000000000000000000009013', // LP-9013
+    FLASH_LOAN: '0x0000000000000000000000000000000000009014', // LP-9014
+    // DeFi Extensions
+    ORACLE_HUB: '0x0000000000000000000000000000000000009011', // LP-9011
+    CLOB: '0x0000000000000000000000000000000000009020', // LP-9020
+    VAULT: '0x0000000000000000000000000000000000009030', // LP-9030
+    // Bridges (LP-6xxx)
+    TELEPORT: '0x0000000000000000000000000000000000006010', // LP-6010
 };
 /**
  * Contract addresses for Lux Dev (1337)
+ * Deterministic CREATE addresses from DeployFullStack.s.sol deployed by anvil account 0
+ * Account 0: 0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266
  */
 export const LUX_DEV_CONTRACTS = {
-    // Core
-    WLUX: '0x610178dA211FEF7D417bC0e6FeD39F05609AD788',
+    // Core - Nonce 0
+    WLUX: '0x5FbDB2315678afecb367f032d93F642f64180aa3',
     MULTICALL: '0xd25F88CBdAe3c2CCA3Bb75FC4E723b44C0Ea362F',
-    // Bridged tokens (local dev)
-    ETH: '0x5FbDB2315678afecb367f032d93F642f64180aa3',
-    BTC: '0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512',
-    USDC: '0x9fE46736679d2D9a65F0992F2272dE9f3c7fa6e0',
-    USDT: '0xCf7Ed3AccA5a467e9e704C703E8D87F634fB0Fc9',
-    DAI: '0xDc64a140Aa3E981100a9becA4E685f962f0cF6C9',
-    AI: '0x0B306BF915C4d645ff596e518fAf3F9669b97016',
+    // Bridged tokens (deterministic deployment nonces 1-3)
+    LETH: '0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512', // Nonce 1
+    LBTC: '0x9fE46736679d2D9a65F0992F2272dE9f3c7fa6e0', // Nonce 2
+    LUSD: '0xCf7Ed3AccA5a467e9e704C703E8D87F634fB0Fc9', // Nonce 3
     // AMM V2
     V2_FACTORY: '0x959922bE3CAee4b8Cd9a407cc3ac1C251C2007B1',
     V2_ROUTER: '0x9A9f2CCfdE556A7E9Ff0848998Aa4a0CFD8863AE',

package/dist/index.d.ts

@@ -14,4 +14,5 @@ export * from './contracts';
 export * from './dex';
 export * from './hooks';
 export * from './stores';
+export * from './bridge';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAGH,cAAc,UAAU,CAAA;AAGxB,cAAc,UAAU,CAAA;AAGxB,cAAc,aAAa,CAAA;AAG3B,cAAc,OAAO,CAAA;AAGrB,cAAc,SAAS,CAAA;AAGvB,cAAc,UAAU,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAGH,cAAc,UAAU,CAAA;AAGxB,cAAc,UAAU,CAAA;AAGxB,cAAc,aAAa,CAAA;AAG3B,cAAc,OAAO,CAAA;AAGrB,cAAc,SAAS,CAAA;AAGvB,cAAc,UAAU,CAAA;AAGxB,cAAc,UAAU,CAAA"}

package/dist/index.js

@@ -20,5 +20,5 @@ export * from './dex';
 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/tokens/index.d.ts

@@ -28,9 +28,22 @@ export declare const WLUX_DEV: Token;
 export declare const LUSD: Token;
 /**
  * Bridge tokens (L-prefix for assets bridged to Lux)
+ * These are the canonical mainnet addresses from @luxfi/config
  */
 export declare const LETH: Token;
 export declare const LBTC: Token;
+/**
+ * Testnet bridge tokens
+ */
+export declare const LETH_TESTNET: Token;
+export declare const LBTC_TESTNET: Token;
+export declare const LUSD_TESTNET: Token;
+/**
+ * Dev mode bridge tokens (deterministic CREATE addresses)
+ */
+export declare const LETH_DEV: Token;
+export declare const LBTC_DEV: Token;
+export declare const LUSD_DEV: Token;
 /**
  * Major tokens on Lux Mainnet
  */
@@ -54,6 +67,18 @@ export declare const LUX_MAINNET_TOKENS: Token[];
  * Default token list for Zoo Mainnet
  */
 export declare const ZOO_MAINNET_TOKENS: Token[];
+/**
+ * Default token list for Lux Testnet
+ */
+export declare const LUX_TESTNET_TOKENS: Token[];
+/**
+ * Default token list for Lux Dev
+ */
+export declare const LUX_DEV_TOKENS: Token[];
+/**
+ * Get tokens for a chain
+ */
+export declare function getTokensForChain(chainId: number): Token[];
 /**
  * Get wrapped native token for chain
  */

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/tokens/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAA;AAEnC;;GAEG;AACH,MAAM,WAAW,KAAK;IACpB,OAAO,EAAE,OAAO,CAAA;IAChB,OAAO,EAAE,MAAM,CAAA;IACf,QAAQ,EAAE,MAAM,CAAA;IAChB,MAAM,EAAE,MAAM,CAAA;IACd,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,QAAQ,CAAC,EAAE,OAAO,CAAA;CACnB;AAED;;GAEG;AACH,eAAO,MAAM,UAAU,EAAE,KAOxB,CAAA;AAED,eAAO,MAAM,UAAU,EAAE,KAOxB,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,YAAY,EAAE,KAM1B,CAAA;AAED,eAAO,MAAM,YAAY,EAAE,KAM1B,CAAA;AAED,eAAO,MAAM,QAAQ,EAAE,KAMtB,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,IAAI,EAAE,KAMlB,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,IAAI,EAAE,KAMlB,CAAA;AAED,eAAO,MAAM,IAAI,EAAE,KAMlB,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,QAAQ,EAAE,KAMtB,CAAA;AAED,eAAO,MAAM,QAAQ,EAAE,KAMtB,CAAA;AAED,eAAO,MAAM,QAAQ,EAAE,KAMtB,CAAA;AAED,eAAO,MAAM,QAAQ,EAAE,KAMtB,CAAA;AAED,eAAO,MAAM,OAAO,EAAE,KAMrB,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,IAAI,EAAE,KAMlB,CAAA;AAED,eAAO,MAAM,QAAQ,EAAE,KAMtB,CAAA;AAED,eAAO,MAAM,QAAQ,EAAE,KAMtB,CAAA;AAED,eAAO,MAAM,QAAQ,EAAE,KAMtB,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,kBAAkB,EAAE,KAAK,EAWrC,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,kBAAkB,EAAE,KAAK,EAMrC,CAAA;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,KAAK,GAAG,SAAS,CAWnE;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,KAAK,GAAG,OAAO,CAEnD"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/tokens/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAA;AAEnC;;GAEG;AACH,MAAM,WAAW,KAAK;IACpB,OAAO,EAAE,OAAO,CAAA;IAChB,OAAO,EAAE,MAAM,CAAA;IACf,QAAQ,EAAE,MAAM,CAAA;IAChB,MAAM,EAAE,MAAM,CAAA;IACd,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,QAAQ,CAAC,EAAE,OAAO,CAAA;CACnB;AAED;;GAEG;AACH,eAAO,MAAM,UAAU,EAAE,KAOxB,CAAA;AAED,eAAO,MAAM,UAAU,EAAE,KAOxB,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,YAAY,EAAE,KAM1B,CAAA;AAED,eAAO,MAAM,YAAY,EAAE,KAM1B,CAAA;AAED,eAAO,MAAM,QAAQ,EAAE,KAOtB,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,IAAI,EAAE,KAMlB,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,IAAI,EAAE,KAMlB,CAAA;AAED,eAAO,MAAM,IAAI,EAAE,KAMlB,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,YAAY,EAAE,KAM1B,CAAA;AAED,eAAO,MAAM,YAAY,EAAE,KAM1B,CAAA;AAED,eAAO,MAAM,YAAY,EAAE,KAM1B,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,QAAQ,EAAE,KAMtB,CAAA;AAED,eAAO,MAAM,QAAQ,EAAE,KAMtB,CAAA;AAED,eAAO,MAAM,QAAQ,EAAE,KAMtB,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,QAAQ,EAAE,KAMtB,CAAA;AAED,eAAO,MAAM,QAAQ,EAAE,KAMtB,CAAA;AAED,eAAO,MAAM,QAAQ,EAAE,KAMtB,CAAA;AAED,eAAO,MAAM,QAAQ,EAAE,KAMtB,CAAA;AAED,eAAO,MAAM,OAAO,EAAE,KAMrB,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,IAAI,EAAE,KAMlB,CAAA;AAED,eAAO,MAAM,QAAQ,EAAE,KAMtB,CAAA;AAED,eAAO,MAAM,QAAQ,EAAE,KAMtB,CAAA;AAED,eAAO,MAAM,QAAQ,EAAE,KAMtB,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,kBAAkB,EAAE,KAAK,EAWrC,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,kBAAkB,EAAE,KAAK,EAMrC,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,kBAAkB,EAAE,KAAK,EAKrC,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,cAAc,EAAE,KAAK,EAKjC,CAAA;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,GAAG,KAAK,EAAE,CAa1D;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,KAAK,GAAG,SAAS,CAWnE;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,KAAK,GAAG,OAAO,CAEnD"}

package/dist/tokens/index.js

@@ -35,7 +35,8 @@ export const WLUX_TESTNET = {
     name: 'Wrapped LUX',
 };
 export const WLUX_DEV = {
-    address: '0x610178dA211FEF7D417bC0e6FeD39F05609AD788',
+    // Deterministic CREATE address from DeployFullStack.s.sol (nonce 0)
+    address: '0x5FbDB2315678afecb367f032d93F642f64180aa3',
     chainId: 1337,
     decimals: 18,
     symbol: 'WLUX',
@@ -45,29 +46,78 @@ export const WLUX_DEV = {
  * Stablecoins
  */
 export const LUSD = {
-    address: '0x0000000000000000000000000000000000000000', // TODO: Deploy
+    address: '0x4B1BfA76eD63F1A0aD2E4f40b3F46C45E8F7A4E2',
     chainId: 96369,
-    decimals: 18,
+    decimals: 6, // USDC-compatible decimals
     symbol: 'LUSD',
     name: 'Lux Dollar',
 };
 /**
  * Bridge tokens (L-prefix for assets bridged to Lux)
+ * These are the canonical mainnet addresses from @luxfi/config
  */
 export const LETH = {
-    address: '0xAA3AE951A7925F25aE8Ad65b052a76Bd8f052598',
+    address: '0xAA3AE95816a4A6FbC6b8Ed5a6C06f22A96A80C8C',
     chainId: 96369,
     decimals: 18,
     symbol: 'LETH',
     name: 'Lux ETH',
 };
 export const LBTC = {
-    address: '0x526903Ee6118de6737D11b37f82fC7f69B13685D',
+    address: '0x526903E35E7106D62ED3B5d77E14e51d024Aa1D3',
     chainId: 96369,
     decimals: 8,
     symbol: 'LBTC',
     name: 'Lux BTC',
 };
+/**
+ * Testnet bridge tokens
+ */
+export const LETH_TESTNET = {
+    address: '0x60E0a8167FC13dE89348978860466C9ceC24B9ba',
+    chainId: 96368,
+    decimals: 18,
+    symbol: 'LETH',
+    name: 'Lux ETH',
+};
+export const LBTC_TESTNET = {
+    address: '0x1E48D32a4F5e9f08DB9aE4959163300FaF8A6C8e',
+    chainId: 96368,
+    decimals: 8,
+    symbol: 'LBTC',
+    name: 'Lux BTC',
+};
+export const LUSD_TESTNET = {
+    address: '0xb84112ac9318a0b2319aa11d4d10e9762b25f7f4',
+    chainId: 96368,
+    decimals: 18,
+    symbol: 'LUSD',
+    name: 'Lux Dollar',
+};
+/**
+ * Dev mode bridge tokens (deterministic CREATE addresses)
+ */
+export const LETH_DEV = {
+    address: '0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512',
+    chainId: 1337,
+    decimals: 18,
+    symbol: 'LETH',
+    name: 'Lux ETH',
+};
+export const LBTC_DEV = {
+    address: '0x9fE46736679d2D9a65F0992F2272dE9f3c7fa6e0',
+    chainId: 1337,
+    decimals: 8,
+    symbol: 'LBTC',
+    name: 'Lux BTC',
+};
+export const LUSD_DEV = {
+    address: '0xCf7Ed3AccA5a467e9e704C703E8D87F634fB0Fc9',
+    chainId: 1337,
+    decimals: 6,
+    symbol: 'LUSD',
+    name: 'Lux Dollar',
+};
 /**
  * Major tokens on Lux Mainnet
  */
@@ -162,6 +212,41 @@ export const ZOO_MAINNET_TOKENS = [
     USDT_ZOO,
     WETH_ZOO,
 ];
+/**
+ * Default token list for Lux Testnet
+ */
+export const LUX_TESTNET_TOKENS = [
+    WLUX_TESTNET,
+    LETH_TESTNET,
+    LBTC_TESTNET,
+    LUSD_TESTNET,
+];
+/**
+ * Default token list for Lux Dev
+ */
+export const LUX_DEV_TOKENS = [
+    WLUX_DEV,
+    LETH_DEV,
+    LBTC_DEV,
+    LUSD_DEV,
+];
+/**
+ * Get tokens for a chain
+ */
+export function getTokensForChain(chainId) {
+    switch (chainId) {
+        case 96369:
+            return LUX_MAINNET_TOKENS;
+        case 96368:
+            return LUX_TESTNET_TOKENS;
+        case 1337:
+            return LUX_DEV_TOKENS;
+        case 200200:
+            return ZOO_MAINNET_TOKENS;
+        default:
+            return [];
+    }
+}
 /**
  * Get wrapped native token for chain
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@luxfi/exchange",
-  "version": "0.1.0",
+  "version": "1.0.0",
   "description": "Lux Exchange SDK - React hooks and utilities for Lux DEX",
   "license": "MIT",
   "main": "./dist/index.js",
@@ -34,6 +34,10 @@
     "./dex": {
       "types": "./dist/dex/index.d.ts",
       "import": "./dist/dex/index.js"
+    },
+    "./bridge": {
+      "types": "./dist/bridge/index.d.ts",
+      "import": "./dist/bridge/index.js"
     }
   },
   "files": [
@@ -64,7 +68,7 @@
   "repository": {
     "type": "git",
     "url": "https://github.com/luxfi/exchange.git",
-    "directory": "packages/exchange"
+    "directory": "pkgs/exchange"
   },
   "keywords": [
     "lux",

package/src/bridge/cross-chain-store.ts

@@ -0,0 +1,210 @@
+/**
+ * Zustand store for cross-chain mint operations
+ */
+
+import { create } from 'zustand'
+import { devtools, persist } from 'zustand/middleware'
+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
+
+  // Actions
+  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[]
+}
+
+// Generate a random swap ID
+function generateSwapId(): string {
+  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<CrossChainStore>()(
+  devtools(
+    persist(
+      (set, get) => ({
+        pendingMints: {},
+        recentMints: [],
+        maxRecentMints: 20,
+
+        initiateMint: (request: CrossChainMintRequest) => {
+          const swapId = generateSwapId()
+          const now = Date.now()
+
+          const pendingMint: PendingMint = {
+            ...request,
+            state: {
+              swapId: swapId as `0x${string}`,
+              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: string, status: CrossChainMintStatus) => {
+          set((state) => {
+            const mint = state.pendingMints[swapId]
+            if (!mint) return state
+
+            return {
+              pendingMints: {
+                ...state.pendingMints,
+                [swapId]: {
+                  ...mint,
+                  state: {
+                    ...mint.state,
+                    status,
+                  },
+                },
+              },
+            }
+          })
+        },
+
+        updateMintTxHash: (swapId: string, field: 'sourceTxHash' | 'mintTxHash' | 'swapTxHash', hash: string) => {
+          set((state) => {
+            const mint = state.pendingMints[swapId]
+            if (!mint) return state
+
+            return {
+              pendingMints: {
+                ...state.pendingMints,
+                [swapId]: {
+                  ...mint,
+                  state: {
+                    ...mint.state,
+                    [field]: hash,
+                  },
+                },
+              },
+            }
+          })
+        },
+
+        completeMint: (swapId: string) => {
+          set((state) => {
+            const mint = state.pendingMints[swapId]
+            if (!mint) return state
+
+            const completedMint: PendingMint = {
+              ...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: string, error: string) => {
+          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: string) => {
+          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: string) => {
+          set((state) => {
+            const { [swapId]: _, ...remainingPending } = state.pendingMints
+            return { pendingMints: remainingPending }
+          })
+        },
+
+        getPendingMint: (swapId: string) => {
+          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/src/bridge/index.ts

@@ -0,0 +1,81 @@
+/**
+ * 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'