Data Schemas

interface Chain {
  id: number;              // Chain ID (e.g., 1 for Ethereum)
  key: string;             // Short identifier (e.g., "eth")
  name: string;            // Display name (e.g., "Ethereum")
  chainType: ChainType;    // "EVM" | "SVM" | "UTXO" | "MVM"
  coin: string;            // Native token symbol (e.g., "ETH")
  mainnet: boolean;        // true if mainnet
  logoURI: string;         // Chain logo URL
  metamask?: MetaMaskConfig;
}

type ChainType = "EVM" | "SVM" | "UTXO" | "MVM";

interface Token {
  address: string;         // Contract address
  symbol: string;          // Token symbol (e.g., "USDC")
  name: string;            // Full name (e.g., "USD Coin")
  decimals: number;        // Decimal places (e.g., 6)
  chainId: number;         // Chain this token is on
  priceUSD?: string;       // Current USD price
  logoURI?: string;        // Token logo URL
}

0x0000000000000000000000000000000000000000

interface Quote {
  id: string;                    // Unique quote identifier
  type: "lifi";                  // Always "lifi"
  tool: string;                  // Bridge/DEX used
  toolDetails: ToolDetails;      // Tool metadata
  action: Action;                // Transfer details
  estimate: Estimate;            // Cost and output estimates
  transactionRequest: TxRequest; // Ready-to-sign transaction
}

interface Action {
  fromChainId: number;       // Source chain
  toChainId: number;         // Destination chain
  fromToken: Token;          // Source token
  toToken: Token;            // Destination token
  fromAmount: string;        // Input amount (smallest unit)
  slippage: number;          // Slippage tolerance (decimal)
  fromAddress: string;       // Sender address
  toAddress: string;         // Recipient address
}

interface Estimate {
  fromAmount: string;           // Input amount
  toAmount: string;             // Expected output amount
  toAmountMin: string;          // Minimum guaranteed (slippage)
  approvalAddress: string;      // Spender for token approval
  executionDuration: number;    // Estimated seconds
  feeCosts: FeeCost[];          // Protocol fees
  gasCosts: GasCost[];          // Gas costs
}

interface TransactionRequest {
  to: string;           // Contract address
  data: string;         // Encoded call data
  value: string;        // Native token amount (hex)
  gasLimit: string;     // Gas limit (hex)
  gasPrice?: string;    // Suggested gas price (hex)
  chainId: number;      // Chain ID for signing
}

// Hex to decimal
const gasLimit = parseInt(tx.gasLimit, 16);
const value = BigInt(tx.value);

// Decimal to hex
const hexValue = '0x' + amount.toString(16);

interface Status {
  transactionId: string;      // Unique transfer ID
  sending: TransferInfo;      // Source chain info
  receiving?: TransferInfo;   // Destination chain info
  status: StatusType;         // Current status
  substatus?: SubstatusType;  // Detailed status (when DONE)
  tool: string;               // Bridge used
  error?: string;             // Error message (if failed)
}

type StatusType = "NOT_FOUND" | "PENDING" | "DONE" | "FAILED";
type SubstatusType = "COMPLETED" | "PARTIAL" | "REFUNDED";

NOT_FOUND → PENDING → DONE (COMPLETED | PARTIAL | REFUNDED)
                   ↘ FAILED

type Order = "FASTEST" | "CHEAPEST";

type ChainType = "EVM" | "SVM" | "UTXO" | "MVM";

Pattern: ^0x[a-fA-F0-9]{40}$
Example: 0x552008c0f6870c2f77e5cC1d2eb9bdff03e30Ea0

Format: String containing non-negative integer
Example: "10000000" (10 USDC)

Format: Number (decimal)
Example: 0.005 (0.5%)
Range: 0.001 to 0.5

Pattern: ^0x[a-fA-F0-9]{64}$
Example: 0xabc123...def456 (66 characters total)

const quoteValidation = {
  fromChain: {
    type: 'integer',
    required: true,
    min: 1
  },
  toChain: {
    type: 'integer', 
    required: true,
    min: 1
  },
  fromToken: {
    type: 'string',
    required: true,
    pattern: /^(0x[a-fA-F0-9]{40}|[A-Z0-9]+)$/  // Address or symbol
  },
  toToken: {
    type: 'string',
    required: true,
    pattern: /^(0x[a-fA-F0-9]{40}|[A-Z0-9]+)$/
  },
  fromAmount: {
    type: 'string',
    required: true,
    pattern: /^[0-9]+$/,  // Positive integer string
    min: '1'
  },
  fromAddress: {
    type: 'string',
    required: true,
    pattern: /^0x[a-fA-F0-9]{40}$/
  },
  slippage: {
    type: 'number',
    required: false,
    default: 0.005,
    min: 0.001,
    max: 0.5
  }
};

curl "https://li.quest/v1/docs-json" > lifi-openapi.json