┌─────────────────────────────────────────────────────────────────────────────────────────┐
│                          LUX PRECOMPILE ARCHITECTURE                                    │
├─────────────────────────────────────────────────────────────────────────────────────────┤
│                                                                                         │
│  POST-QUANTUM CRYPTOGRAPHY              THRESHOLD SIGNATURES                            │
│  ┌─────────────┐ ┌─────────────┐        ┌─────────────┐ ┌─────────────┐               │
│  │   ML-DSA    │ │   SLH-DSA   │        │    FROST    │ │  CGGMP21    │               │
│  │   0x0006    │ │   0x0007    │        │   0x000C    │ │   0x000D    │               │
│  │ FIPS 204    │ │ FIPS 205    │        │  Schnorr    │ │   ECDSA     │               │
│  └─────────────┘ └─────────────┘        └─────────────┘ └─────────────┘               │
│  ┌─────────────┐ ┌─────────────┐        ┌─────────────┐ ┌─────────────┐               │
│  │   ML-KEM    │ │  PQCrypto   │        │  Ringtail   │ │     LSS     │               │
│  │   0x0008    │ │   0x0009    │        │   0x000B    │ │   0x000E    │               │
│  │ FIPS 203    │ │ Multi-algo  │        │ PQ Thresh   │ │  Shamir SS  │               │
│  └─────────────┘ └─────────────┘        └─────────────┘ └─────────────┘               │
│                                                                                         │
│  CROSS-CHAIN & CONSENSUS                DEX PRECOMPILES                                │
│  ┌─────────────┐ ┌─────────────┐        ┌─────────────┐ ┌─────────────┐               │
│  │    Warp     │ │   Quasar    │        │PoolManager  │ │   Hooks     │               │
│  │   0x0005    │ │   0x000A    │        │   0x0400    │ │   0x0402    │               │
│  │ BLS Aggr    │ │ Quantum Fin │        │ Singleton   │ │  Callbacks  │               │
│  └─────────────┘ └─────────────┘        └─────────────┘ └─────────────┘               │
│  ┌─────────────┐ ┌─────────────┐                                                       │
│  │     BLS     │ │ secp256r1   │        ZK PRECOMPILES (EIP-1108, EIP-2537)           │
│  │   0x000F    │ │   0x0010    │        ┌─────────────┐ ┌─────────────┐               │
│  │  BLS12-381  │ │  P-256 Sig  │        │  BN254 ZK   │ │ BLS12-381   │               │
│  └─────────────┘ └─────────────┘        │  0x06-0x08  │ │ 0x0b-0x11   │               │
│                                         └─────────────┘ └─────────────┘               │
└─────────────────────────────────────────────────────────────────────────────────────────┘

import "@luxfi/contracts/precompile/interfaces/IMLDSA.sol";

// Verify post-quantum signature
IMLDSA mldsa = IMLDSA(0x0200000000000000000000000000000000000006);
bool valid = mldsa.verify(publicKey, message, signature);

// Using library with revert on failure
MLDSALib.verifyOrRevert(publicKey, message, signature);

import "@luxfi/contracts/precompile/interfaces/IMLKEM.sol";

// Encapsulate shared secret
IMLKEM mlkem = IMLKEM(0x0200000000000000000000000000000000000008);
(bytes memory ciphertext, bytes32 sharedSecret) = mlkem.encapsulate(publicKey);

// Decapsulate on recipient side
bytes32 recoveredSecret = mlkem.decapsulate(privateKey, ciphertext);

import "@luxfi/contracts/precompile/interfaces/ISLHDSA.sol";

ISLHDSA slhdsa = ISLHDSA(0x0200000000000000000000000000000000000007);
bool valid = slhdsa.verify(publicKey, message, signature);

import "@luxfi/contracts/precompile/interfaces/IFROST.sol";

// Verify 2-of-3 threshold signature
IFROST frost = IFROST(0x020000000000000000000000000000000000000C);
bool valid = frost.verify(
    2,              // threshold (t)
    3,              // total signers (n)
    publicKey,      // 32-byte aggregated key
    messageHash,    // 32-byte message hash
    signature       // 64-byte Schnorr signature
);

// Using library
FROSTLib.verifyOrRevert(2, 3, publicKey, messageHash, signature);

import "@luxfi/contracts/precompile/interfaces/ICGGMP21.sol";

// Verify 3-of-5 threshold ECDSA
ICGGMP21 cggmp = ICGGMP21(0x020000000000000000000000000000000000000D);
bool valid = cggmp.verify(
    3,              // threshold
    5,              // total signers
    publicKey,      // 65-byte uncompressed pubkey
    messageHash,    // 32-byte message hash
    signature       // 65-byte ECDSA signature (r, s, v)
);

import "@luxfi/contracts/precompile/interfaces/IRingtailThreshold.sol";

// Verify quantum-resistant threshold signature
IRingtailThreshold ringtail = IRingtailThreshold(0x020000000000000000000000000000000000000B);
bool valid = ringtail.verify(
    3,              // threshold
    5,              // total parties
    publicKey,      // aggregated lattice public key
    messageHash,    // message hash
    signature       // lattice signature (~4KB)
);

import "@luxfi/contracts/precompile/interfaces/IWarp.sol";

// Get current blockchain ID
IWarp warp = IWarp(0x0200000000000000000000000000000000000005);
bytes32 chainId = warp.getBlockchainID();

// Send cross-chain message
bytes32 messageId = warp.sendWarpMessage(payload);

// Receive verified message on destination
(IWarp.WarpMessage memory msg, bool valid) = warp.getVerifiedWarpMessage(0);
require(valid, "Message not verified");

import "@luxfi/contracts/precompile/interfaces/IQuasar.sol";

IQuasar quasar = IQuasar(0x020000000000000000000000000000000000000A);

// Get quantum-finalized block
bytes32 finalizedBlock = quasar.getQuantumFinalizedBlock();

// Verify quantum finality proof
bool valid = quasar.verifyQuantumFinality(blockHash, proof);

import "@luxfi/contracts/precompile/interfaces/dex/IPoolManager.sol";
import "@luxfi/contracts/precompile/interfaces/dex/Types.sol";

IPoolManager poolManager = IPoolManager(0x0400);

// Initialize a new pool
PoolKey memory key = PoolKey({
    currency0: Currency.wrap(address(tokenA)),
    currency1: Currency.wrap(address(tokenB)),
    fee: 3000,           // 0.30%
    tickSpacing: 60,
    hooks: address(0)    // no hooks
});

int24 tick = poolManager.initialize(key, sqrtPriceX96, "");

// Execute swap within lock context
poolManager.lock(abi.encode(swapData));

import "@luxfi/contracts/precompile/interfaces/dex/IHooks.sol";

contract MyHook is BaseHook {
    constructor(address _poolManager) BaseHook(_poolManager) {}

    function getHookPermissions() public pure override returns (HookPermissions) {
        return HookPermissionsLib.fromBitmap(
            1 << 6 |  // beforeSwap
            1 << 7    // afterSwap
        );
    }

    function beforeSwap(
        PoolKey calldata key,
        SwapParams calldata params,
        bytes calldata hookData
    ) external override returns (uint24 feeOverride) {
        // Custom pre-swap logic
        return 0; // no fee override
    }
}

// ECADD - Point addition
(bool success, bytes memory result) = address(0x06).staticcall(
    abi.encodePacked(x1, y1, x2, y2)
);

// ECMUL - Scalar multiplication
(bool success, bytes memory result) = address(0x07).staticcall(
    abi.encodePacked(x, y, scalar)
);

// ECPAIRING - Pairing check
(bool success, bytes memory result) = address(0x08).staticcall(pairingInput);

// G1ADD - BLS12-381 G1 point addition
(bool success, bytes memory result) = address(0x0b).staticcall(g1Input);

// PAIRING - BLS12-381 pairing
(bool success, bytes memory result) = address(0x10).staticcall(pairingInput);

contracts/crypto/precompiles/
├── IMLDSA.sol           # ML-DSA (FIPS 204)
├── ISLHDSA.sol          # SLH-DSA (FIPS 205)
├── IMLKEM.sol           # ML-KEM (FIPS 203)
├── IPQCrypto.sol        # Multi-PQ operations
├── IFROST.sol           # Schnorr threshold
├── ICGGMP21.sol         # ECDSA threshold
├── IRingtailThreshold.sol # PQ threshold
├── ILSS.sol             # Lattice secret sharing
├── IWarp.sol            # Cross-chain messaging
├── IQuasar.sol          # Quantum consensus
├── IBLS.sol             # BLS12-381 operations
├── ISecp256r1.sol       # P-256 signatures
└── dex/
    ├── Types.sol        # DEX types (Currency, PoolKey, etc.)
    ├── IPoolManager.sol # Singleton pool manager
    ├── IHooks.sol       # Hook interface + BaseHook
    └── ILRC20Minimal.sol # Minimal token interface

// Post-quantum
import "@luxfi/contracts/precompile/interfaces/IMLDSA.sol";
import "@luxfi/contracts/precompile/interfaces/IMLKEM.sol";

// Threshold
import "@luxfi/contracts/precompile/interfaces/IFROST.sol";
import "@luxfi/contracts/precompile/interfaces/ICGGMP21.sol";

// Cross-chain
import "@luxfi/contracts/precompile/interfaces/IWarp.sol";

// DEX
import "@luxfi/contracts/precompile/interfaces/dex/IPoolManager.sol";
import "@luxfi/contracts/precompile/interfaces/dex/IHooks.sol";