LX Wallet Architecture

+------------------+     +------------------+     +------------------+
|   User Device    |     |   LX API     |     |   Settlement     |
|                  |     |                  |     |                  |
|  +------------+  |     |  +------------+  |     |  +------------+  |
|  | Wallet SDK |  |---->|  | Auth Layer |  |---->|  | C-Chain    |  |
|  +------------+  |     |  +------------+  |     |  +------------+  |
|        |         |     |        |         |     |        |         |
|  +------------+  |     |  +------------+  |     |  +------------+  |
|  | Signer     |  |     |  | Order      |  |     |  | Warp Msg   |  |
|  +------------+  |     |  | Engine     |  |     |  +------------+  |
+------------------+     +------------------+     +------------------+

import { Client, WalletAdapter } from '@luxfi/trading';
import { MetaMaskAdapter } from '@luxfi/trading/wallets';

// Create client with wallet adapter
const wallet = new MetaMaskAdapter();
const client = new Client({
  endpoint: 'https://dex.lux.network',
  wallet: wallet
});

// Connect wallet
await client.connect();

// Sign and place order
const order = await client.placeOrder({
  symbol: 'BTC-USD',
  side: 'buy',
  type: 'limit',
  price: '50000',
  quantity: '1.0'
});

from lx_dex import Client
from lx_dex.wallets import Web3Wallet

# Create client with wallet
wallet = Web3Wallet(private_key=os.environ['PRIVATE_KEY'])
client = Client(
    endpoint='https://dex.lux.network',
    wallet=wallet
)

# Place signed order
order = client.place_order(
    symbol='BTC-USD',
    side='buy',
    type='limit',
    price='50000',
    quantity='1.0'
)

import (
    "github.com/luxfi/dex/sdk"
    "github.com/luxfi/dex/sdk/wallets"
)

// Create client with wallet
wallet, _ := wallets.NewPrivateKeyWallet(privateKey)
client := sdk.NewClient(&sdk.Config{
    Endpoint: "https://dex.lux.network",
    Wallet:   wallet,
})

// Place signed order
order, err := client.PlaceOrder(&sdk.Order{
    Symbol:   "BTC-USD",
    Side:     sdk.Buy,
    Type:     sdk.Limit,
    Price:    "50000",
    Quantity: "1.0",
})

// Request wallet connection
const accounts = await wallet.connect();
const address = accounts[0];

// Verify chain ID
const chainId = await wallet.getChainId();
if (chainId !== LUX_CHAIN_ID) {
  await wallet.switchChain(LUX_CHAIN_ID);
}

// Create authenticated session
const session = await client.createSession({
  address: address,
  expiry: Date.now() + 24 * 60 * 60 * 1000, // 24 hours
});

// Sign session message
const signature = await wallet.signMessage(session.message);

// Verify and activate session
const token = await client.verifySession(signature);

// Orders require EIP-712 typed data signature
const orderData = {
  domain: {
    name: 'LX',
    version: '1',
    chainId: LUX_CHAIN_ID,
    verifyingContract: DEX_CONTRACT_ADDRESS
  },
  types: {
    Order: [
      { name: 'symbol', type: 'string' },
      { name: 'side', type: 'uint8' },
      { name: 'price', type: 'uint256' },
      { name: 'quantity', type: 'uint256' },
      { name: 'nonce', type: 'uint256' },
      { name: 'expiry', type: 'uint256' }
    ]
  },
  message: order
};

const signature = await wallet.signTypedData(orderData);

interface WalletAdapter {
  // Connection
  connect(): Promise<string[]>;
  disconnect(): Promise<void>;
  isConnected(): boolean;

  // Account info
  getAddress(): Promise<string>;
  getChainId(): Promise<number>;
  getBalance(): Promise<bigint>;

  // Signing
  signMessage(message: string): Promise<string>;
  signTypedData(data: TypedData): Promise<string>;
  signTransaction(tx: Transaction): Promise<string>;

  // Events
  on(event: WalletEvent, handler: EventHandler): void;
  off(event: WalletEvent, handler: EventHandler): void;
}

type WalletEvent =
  | 'connect'
  | 'disconnect'
  | 'accountsChanged'
  | 'chainChanged'
  | 'error';

const LUX_MAINNET = {
  chainId: 96369,
  chainName: 'Lux Mainnet',
  nativeCurrency: {
    name: 'LUX',
    symbol: 'LUX',
    decimals: 18
  },
  rpcUrls: ['https://api.lux.network/ext/bc/C/rpc'],
  blockExplorerUrls: ['https://explorer.lux.network']
};

const LUX_TESTNET = {
  chainId: 96370,
  chainName: 'Lux Testnet',
  nativeCurrency: {
    name: 'LUX',
    symbol: 'LUX',
    decimals: 18
  },
  rpcUrls: ['https://api.testnet.lux.network/ext/bc/C/rpc'],
  blockExplorerUrls: ['https://testnet.explorer.lux.network']
};

import { WalletError, WalletErrorCode } from '@luxfi/trading/wallets';

try {
  await wallet.connect();
} catch (error) {
  if (error instanceof WalletError) {
    switch (error.code) {
      case WalletErrorCode.USER_REJECTED:
        console.log('User rejected connection');
        break;
      case WalletErrorCode.CHAIN_NOT_SUPPORTED:
        console.log('Please switch to Lux network');
        break;
      case WalletErrorCode.WALLET_NOT_FOUND:
        console.log('Please install a wallet');
        break;
      case WalletErrorCode.ALREADY_CONNECTED:
        console.log('Wallet already connected');
        break;
      default:
        console.error('Wallet error:', error.message);
    }
  }
}