@luxfi/dex 1.3.0 → 2.0.1

package/src/precompile/abis.ts

@@ -1,6 +1,7 @@
 /**
- * DEX Precompile ABIs
- * Native Go implementation at 0x0400-0x0403
+ * DEX Precompile ABIs (LP-Aligned)
+ * Native Go implementation at LP-9010 to LP-9040
+ * Address format: 0x0000000000000000000000000000000000LPNUM
  */
 
 /**
@@ -289,3 +290,466 @@ export const FLASH_LOAN_ABI = [
     stateMutability: 'nonpayable',
   },
 ] as const
+
+// ============================================================================
+// LXBook ABI (LP-9020) - CLOB Matching Engine
+// ============================================================================
+
+/**
+ * LXBook ABI (LP-9020)
+ * Permissionless orderbooks with Hyperliquid-style execute() endpoint
+ */
+export const LX_BOOK_ABI = [
+  // Hyperliquid-style execute endpoint
+  {
+    type: 'function',
+    name: 'execute',
+    inputs: [
+      {
+        name: 'action',
+        type: 'tuple',
+        components: [
+          { name: 'actionType', type: 'uint8' },
+          { name: 'nonce', type: 'uint64' },
+          { name: 'expiresAfter', type: 'uint64' },
+          { name: 'data', type: 'bytes' },
+        ],
+      },
+    ],
+    outputs: [{ name: 'result', type: 'bytes' }],
+    stateMutability: 'nonpayable',
+  },
+  // Batch execute
+  {
+    type: 'function',
+    name: 'executeBatch',
+    inputs: [
+      {
+        name: 'actions',
+        type: 'tuple[]',
+        components: [
+          { name: 'actionType', type: 'uint8' },
+          { name: 'nonce', type: 'uint64' },
+          { name: 'expiresAfter', type: 'uint64' },
+          { name: 'data', type: 'bytes' },
+        ],
+      },
+    ],
+    outputs: [{ name: 'results', type: 'bytes[]' }],
+    stateMutability: 'nonpayable',
+  },
+  // Create market
+  {
+    type: 'function',
+    name: 'createMarket',
+    inputs: [
+      {
+        name: 'cfg',
+        type: 'tuple',
+        components: [
+          { name: 'baseAsset', type: 'bytes32' },
+          { name: 'quoteAsset', type: 'bytes32' },
+          { name: 'tickSizeX18', type: 'uint128' },
+          { name: 'lotSizeX18', type: 'uint128' },
+          { name: 'makerFeePpm', type: 'uint32' },
+          { name: 'takerFeePpm', type: 'uint32' },
+          { name: 'feedId', type: 'bytes32' },
+          { name: 'initialStatus', type: 'uint8' },
+        ],
+      },
+    ],
+    outputs: [{ name: 'marketId', type: 'uint32' }],
+    stateMutability: 'nonpayable',
+  },
+  // Get L1 (best bid/ask)
+  {
+    type: 'function',
+    name: 'getL1',
+    inputs: [{ name: 'marketId', type: 'uint32' }],
+    outputs: [
+      {
+        name: 'l1',
+        type: 'tuple',
+        components: [
+          { name: 'bestBidPxX18', type: 'uint128' },
+          { name: 'bestBidSzX18', type: 'uint128' },
+          { name: 'bestAskPxX18', type: 'uint128' },
+          { name: 'bestAskSzX18', type: 'uint128' },
+          { name: 'lastTradePxX18', type: 'uint128' },
+        ],
+      },
+    ],
+    stateMutability: 'view',
+  },
+  // Get market config
+  {
+    type: 'function',
+    name: 'getMarketConfig',
+    inputs: [{ name: 'marketId', type: 'uint32' }],
+    outputs: [
+      {
+        name: 'cfg',
+        type: 'tuple',
+        components: [
+          { name: 'baseAsset', type: 'bytes32' },
+          { name: 'quoteAsset', type: 'bytes32' },
+          { name: 'tickSizeX18', type: 'uint128' },
+          { name: 'lotSizeX18', type: 'uint128' },
+          { name: 'makerFeePpm', type: 'uint32' },
+          { name: 'takerFeePpm', type: 'uint32' },
+          { name: 'feedId', type: 'bytes32' },
+          { name: 'initialStatus', type: 'uint8' },
+        ],
+      },
+    ],
+    stateMutability: 'view',
+  },
+  // Get market status
+  {
+    type: 'function',
+    name: 'getMarketStatus',
+    inputs: [{ name: 'marketId', type: 'uint32' }],
+    outputs: [{ name: 'status', type: 'uint8' }],
+    stateMutability: 'view',
+  },
+] as const
+
+// ============================================================================
+// LXVault ABI (LP-9030) - Custody and Risk Engine
+// ============================================================================
+
+/**
+ * LXVault ABI (LP-9030)
+ * Balances, margin, collateral, liquidations
+ */
+export const LX_VAULT_ABI = [
+  // Deposit
+  {
+    type: 'function',
+    name: 'deposit',
+    inputs: [
+      { name: 'token', type: 'address' },
+      { name: 'amount', type: 'uint128' },
+      { name: 'subaccountId', type: 'uint8' },
+    ],
+    outputs: [],
+    stateMutability: 'nonpayable',
+  },
+  // Withdraw
+  {
+    type: 'function',
+    name: 'withdraw',
+    inputs: [
+      { name: 'token', type: 'address' },
+      { name: 'amount', type: 'uint128' },
+      { name: 'subaccountId', type: 'uint8' },
+    ],
+    outputs: [],
+    stateMutability: 'nonpayable',
+  },
+  // Transfer between subaccounts
+  {
+    type: 'function',
+    name: 'transfer',
+    inputs: [
+      { name: 'token', type: 'address' },
+      { name: 'amount', type: 'uint128' },
+      { name: 'fromSubaccount', type: 'uint8' },
+      { name: 'toSubaccount', type: 'uint8' },
+    ],
+    outputs: [],
+    stateMutability: 'nonpayable',
+  },
+  // Get balance
+  {
+    type: 'function',
+    name: 'getBalance',
+    inputs: [
+      {
+        name: 'account',
+        type: 'tuple',
+        components: [
+          { name: 'main', type: 'address' },
+          { name: 'subaccountId', type: 'uint8' },
+        ],
+      },
+      { name: 'token', type: 'address' },
+    ],
+    outputs: [{ name: 'balance', type: 'uint128' }],
+    stateMutability: 'view',
+  },
+  // Get position
+  {
+    type: 'function',
+    name: 'getPosition',
+    inputs: [
+      {
+        name: 'account',
+        type: 'tuple',
+        components: [
+          { name: 'main', type: 'address' },
+          { name: 'subaccountId', type: 'uint8' },
+        ],
+      },
+      { name: 'marketId', type: 'uint32' },
+    ],
+    outputs: [
+      {
+        name: 'position',
+        type: 'tuple',
+        components: [
+          { name: 'marketId', type: 'uint32' },
+          { name: 'side', type: 'uint8' },
+          { name: 'sizeX18', type: 'uint128' },
+          { name: 'entryPxX18', type: 'uint128' },
+          { name: 'unrealizedPnlX18', type: 'uint128' },
+          { name: 'accumulatedFundingX18', type: 'int128' },
+          { name: 'lastFundingTime', type: 'uint64' },
+        ],
+      },
+    ],
+    stateMutability: 'view',
+  },
+  // Get margin info
+  {
+    type: 'function',
+    name: 'getMargin',
+    inputs: [
+      {
+        name: 'account',
+        type: 'tuple',
+        components: [
+          { name: 'main', type: 'address' },
+          { name: 'subaccountId', type: 'uint8' },
+        ],
+      },
+    ],
+    outputs: [
+      {
+        name: 'info',
+        type: 'tuple',
+        components: [
+          { name: 'totalCollateralX18', type: 'uint128' },
+          { name: 'usedMarginX18', type: 'uint128' },
+          { name: 'freeMarginX18', type: 'uint128' },
+          { name: 'marginRatioX18', type: 'uint128' },
+          { name: 'maintenanceMarginX18', type: 'uint128' },
+          { name: 'liquidatable', type: 'bool' },
+        ],
+      },
+    ],
+    stateMutability: 'view',
+  },
+  // Check if liquidatable
+  {
+    type: 'function',
+    name: 'isLiquidatable',
+    inputs: [
+      {
+        name: 'account',
+        type: 'tuple',
+        components: [
+          { name: 'main', type: 'address' },
+          { name: 'subaccountId', type: 'uint8' },
+        ],
+      },
+    ],
+    outputs: [
+      { name: 'liquidatable', type: 'bool' },
+      { name: 'shortfall', type: 'uint128' },
+    ],
+    stateMutability: 'view',
+  },
+  // Liquidate
+  {
+    type: 'function',
+    name: 'liquidate',
+    inputs: [
+      {
+        name: 'account',
+        type: 'tuple',
+        components: [
+          { name: 'main', type: 'address' },
+          { name: 'subaccountId', type: 'uint8' },
+        ],
+      },
+      { name: 'marketId', type: 'uint32' },
+      { name: 'sizeX18', type: 'uint128' },
+    ],
+    outputs: [
+      {
+        name: 'result',
+        type: 'tuple',
+        components: [
+          {
+            name: 'liquidated',
+            type: 'tuple',
+            components: [
+              { name: 'main', type: 'address' },
+              { name: 'subaccountId', type: 'uint8' },
+            ],
+          },
+          {
+            name: 'liquidator',
+            type: 'tuple',
+            components: [
+              { name: 'main', type: 'address' },
+              { name: 'subaccountId', type: 'uint8' },
+            ],
+          },
+          { name: 'marketId', type: 'uint32' },
+          { name: 'sizeX18', type: 'uint128' },
+          { name: 'priceX18', type: 'uint128' },
+          { name: 'penaltyX18', type: 'uint128' },
+          { name: 'adlTriggered', type: 'bool' },
+        ],
+      },
+    ],
+    stateMutability: 'nonpayable',
+  },
+  // Get funding rate
+  {
+    type: 'function',
+    name: 'getFundingRate',
+    inputs: [{ name: 'marketId', type: 'uint32' }],
+    outputs: [
+      { name: 'rateX18', type: 'int128' },
+      { name: 'nextFundingTime', type: 'uint64' },
+    ],
+    stateMutability: 'view',
+  },
+] as const
+
+// ============================================================================
+// LXFeed ABI (LP-9040) - Price Feeds
+// ============================================================================
+
+/**
+ * LXFeed ABI (LP-9040)
+ * Mark price, index price, funding calculations
+ */
+export const LX_FEED_ABI = [
+  // Get mark price
+  {
+    type: 'function',
+    name: 'getMarkPrice',
+    inputs: [{ name: 'marketId', type: 'uint32' }],
+    outputs: [
+      {
+        name: 'mark',
+        type: 'tuple',
+        components: [
+          { name: 'indexPxX18', type: 'uint128' },
+          { name: 'markPxX18', type: 'uint128' },
+          { name: 'premiumX18', type: 'int128' },
+          { name: 'timestamp', type: 'uint64' },
+        ],
+      },
+    ],
+    stateMutability: 'view',
+  },
+  // Get index price
+  {
+    type: 'function',
+    name: 'getIndexPrice',
+    inputs: [{ name: 'marketId', type: 'uint32' }],
+    outputs: [
+      { name: 'priceX18', type: 'uint128' },
+      { name: 'timestamp', type: 'uint64' },
+    ],
+    stateMutability: 'view',
+  },
+  // Get funding rate
+  {
+    type: 'function',
+    name: 'getFundingRate',
+    inputs: [{ name: 'marketId', type: 'uint32' }],
+    outputs: [
+      { name: 'rateX18', type: 'int128' },
+      { name: 'nextFundingTime', type: 'uint64' },
+    ],
+    stateMutability: 'view',
+  },
+  // Get trigger price for order
+  {
+    type: 'function',
+    name: 'getTriggerPrice',
+    inputs: [
+      { name: 'marketId', type: 'uint32' },
+      { name: 'isBuy', type: 'bool' },
+    ],
+    outputs: [{ name: 'priceX18', type: 'uint128' }],
+    stateMutability: 'view',
+  },
+] as const
+
+// ============================================================================
+// LXOracle ABI (LP-9011) - Price Oracle
+// ============================================================================
+
+/**
+ * LXOracle ABI (LP-9011)
+ * Multi-source price aggregation
+ */
+export const LX_ORACLE_ABI = [
+  // Get price
+  {
+    type: 'function',
+    name: 'getPrice',
+    inputs: [
+      { name: 'baseToken', type: 'address' },
+      { name: 'quoteToken', type: 'address' },
+    ],
+    outputs: [
+      {
+        name: 'price',
+        type: 'tuple',
+        components: [
+          { name: 'price', type: 'uint256' },
+          { name: 'confidence', type: 'uint256' },
+          { name: 'timestamp', type: 'uint256' },
+          { name: 'source', type: 'uint8' },
+          { name: 'expo', type: 'int32' },
+        ],
+      },
+    ],
+    stateMutability: 'view',
+  },
+  // Get aggregated price
+  {
+    type: 'function',
+    name: 'getAggregatedPrice',
+    inputs: [
+      { name: 'baseToken', type: 'address' },
+      { name: 'quoteToken', type: 'address' },
+      { name: 'maxStaleness', type: 'uint256' },
+    ],
+    outputs: [
+      {
+        name: 'aggregated',
+        type: 'tuple',
+        components: [
+          { name: 'price', type: 'uint256' },
+          { name: 'minPrice', type: 'uint256' },
+          { name: 'maxPrice', type: 'uint256' },
+          { name: 'deviation', type: 'uint256' },
+          { name: 'numSources', type: 'uint256' },
+          { name: 'timestamp', type: 'uint256' },
+        ],
+      },
+    ],
+    stateMutability: 'view',
+  },
+  // Check if price is fresh
+  {
+    type: 'function',
+    name: 'isPriceFresh',
+    inputs: [
+      { name: 'baseToken', type: 'address' },
+      { name: 'quoteToken', type: 'address' },
+      { name: 'maxStaleness', type: 'uint256' },
+    ],
+    outputs: [{ name: 'fresh', type: 'bool' }],
+    stateMutability: 'view',
+  },
+] as const

package/src/precompile/addresses.ts

@@ -1,72 +1,153 @@
 /**
- * DEX Precompile Addresses
+ * LX Precompile Addresses (LP-Aligned)
  * Native Go implementation at EVM level
- * 
- * Lux Precompile Address Standard:
- * - Prefix format: 0xNNNN000000000000000000000000000000000000
- * - Range 0x0400-0x04FF is reserved for DEX precompiles
- * 
- * @see ~/work/lux/precompile/dex/module.go for implementation
+ *
+ * LX is the umbrella name for the Lux DEX stack:
+ * - AMM (Lux v4-style)
+ * - CLOB (Hyperliquid-style)
+ * - Vaults, Feeds, Routing
+ *
+ * LP-Aligned Address Format (LP-9015):
+ * - Address = 0x0000000000000000000000000000000000LPNUM
+ * - LP number directly visible as trailing hex digits
+ * - Example: LP-9010 → 0x0000...009010
+ *
+ * @see LP-9015 (Precompile Registry) for canonical spec
+ * @see ~/work/lux/precompile/dex/module.go for Go implementation
+ * @see ~/work/lux/lps/LPs/lp-9015-precompile-registry.md
  */
 import type { Address } from 'viem'
 
 /**
- * DEX Precompile contract addresses
- * These are native precompiles, not deployed contracts
+ * LX Precompile addresses (LP-9xxx range)
+ * LX prefix naming convention for developer-facing contracts
+ * Address format: 0x0000000000000000000000000000000000LPNUM
  */
-export const DEX_PRECOMPILES = {
+export const LX = {
   /**
-   * PoolManager (0x0400)
-   * Singleton managing all liquidity pools
+   * LXPool (LP-9010)
+   * v4 PoolManager-compatible core AMM
    * - Initialize pools
    * - Execute swaps
    * - Modify liquidity
    * - Flash accounting settlement
    */
-  POOL_MANAGER: '0x0400000000000000000000000000000000000000' as Address,
+  LX_POOL: '0x0000000000000000000000000000000000009010' as Address,
+
+  /**
+   * LXOracle (LP-9011)
+   * Multi-source price aggregation
+   * - Chainlink, Pyth, TWAP aggregation
+   * - Price feed validation
+   */
+  LX_ORACLE: '0x0000000000000000000000000000000000009011' as Address,
 
   /**
-   * SwapRouter (0x0401)
+   * LXRouter (LP-9012)
    * Optimized swap routing
    * - exactInputSingle / exactOutputSingle
    * - Multi-hop swaps
    * - Native LUX support
    */
-  SWAP_ROUTER: '0x0401000000000000000000000000000000000000' as Address,
+  LX_ROUTER: '0x0000000000000000000000000000000000009012' as Address,
 
   /**
-   * HooksRegistry (0x0402)
+   * LXHooks (LP-9013)
    * Hook contract registry
    * - Register hook contracts
    * - Query hook permissions
    */
-  HOOKS_REGISTRY: '0x0402000000000000000000000000000000000000' as Address,
+  LX_HOOKS: '0x0000000000000000000000000000000000009013' as Address,
 
   /**
-   * FlashLoan (0x0403)
+   * LXFlash (LP-9014)
    * Flash loan facility
    * - Borrow any token
    * - Repay in same transaction
    */
-  FLASH_LOAN: '0x0403000000000000000000000000000000000000' as Address,
+  LX_FLASH: '0x0000000000000000000000000000000000009014' as Address,
+
+  /**
+   * LXBook (LP-9020)
+   * Permissionless orderbooks + matching + advanced orders
+   * - Market factory (createMarket)
+   * - Order lifecycle (place/cancel/modify)
+   * - Advanced orders (trigger, TWAP)
+   * - Book views (L1, order info)
+   */
+  LX_BOOK: '0x0000000000000000000000000000000000009020' as Address,
 
   /**
-   * Lending (0x0410)
-   * Lending protocol
+   * LXVault (LP-9030)
+   * Balances, margin, collateral, liquidations
+   * - Token custody
+   * - Margin requirements
+   * - Position liquidations
    */
-  LENDING: '0x0410000000000000000000000000000000000000' as Address,
+  LX_VAULT: '0x0000000000000000000000000000000000009030' as Address,
 
   /**
-   * Liquid (0x0430)
-   * Liquid staking vaults
+   * LXFeed (LP-9040)
+   * Price feed aggregator
    */
-  LIQUID: '0x0430000000000000000000000000000000000000' as Address,
+  LX_FEED: '0x0000000000000000000000000000000000009040' as Address,
 
   /**
-   * Teleport (0x0440)
-   * Cross-chain bridge
+   * Teleport Bridge (LP-6010)
+   * Cross-chain asset teleportation
    */
-  TELEPORT: '0x0440000000000000000000000000000000000000' as Address,
+  TELEPORT: '0x0000000000000000000000000000000000006010' as Address,
+} as const
+
+/**
+ * Backwards compatibility - old naming convention
+ * @deprecated Use LX export instead
+ */
+export const DEX_PRECOMPILES = {
+  POOL_MANAGER: LX.LX_POOL,
+  ORACLE_HUB: LX.LX_ORACLE,
+  SWAP_ROUTER: LX.LX_ROUTER,
+  HOOKS_REGISTRY: LX.LX_HOOKS,
+  FLASH_LOAN: LX.LX_FLASH,
+  CLOB: LX.LX_BOOK,
+  VAULT: LX.LX_VAULT,
+  PRICE_FEED: LX.LX_FEED,
+  TELEPORT: LX.TELEPORT,
 } as const
 
+export type LxdexPrecompile = keyof typeof LX
 export type DexPrecompile = keyof typeof DEX_PRECOMPILES
+
+/**
+ * Generate precompile address from LP number
+ * @param lpNumber - The LP number (e.g., 9010)
+ * @returns The precompile address
+ */
+export function fromLP(lpNumber: number): Address {
+  return `0x${lpNumber.toString(16).padStart(40, '0')}` as Address
+}
+
+/**
+ * Extract LP number from precompile address
+ * @param address - The precompile address
+ * @returns The LP number
+ */
+export function toLP(address: Address): number {
+  return parseInt(address.slice(-4), 16)
+}
+
+/**
+ * Check if address is a DEX precompile (LP-9xxx range)
+ */
+export function isDEXPrecompile(address: Address): boolean {
+  const lp = toLP(address)
+  return lp >= 9000 && lp < 10000
+}
+
+/**
+ * Check if address is a Bridge precompile (LP-6xxx range)
+ */
+export function isBridgePrecompile(address: Address): boolean {
+  const lp = toLP(address)
+  return lp >= 6000 && lp < 7000
+}

package/src/precompile/index.ts

@@ -1,6 +1,17 @@
 /**
- * DEX Precompile Exports
- * Native Uniswap v4-style AMM at 0x0400-0x0403
+ * LX Precompile Exports (LP-Aligned)
+ *
+ * Native precompiles for Lux DEX stack:
+ * - LXPool (LP-9010): v4-style AMM PoolManager
+ * - LXOracle (LP-9011): Multi-source price aggregation
+ * - LXRouter (LP-9012): Optimized swap routing
+ * - LXHooks (LP-9013): Hook contract registry
+ * - LXFlash (LP-9014): Flash loan facility
+ * - LXBook (LP-9020): CLOB matching engine
+ * - LXVault (LP-9030): Custody and margin engine
+ * - LXFeed (LP-9040): Mark price and funding feeds
+ *
+ * Address format: 0x0000000000000000000000000000000000LPNUM
  */
 export * from './types'
 export * from './abis'