const legend = new LegendBase({
  mode: "sandbox",
	normalizeEvents: true,
  /**
   * 错误处理回调
   * @param {Object} error - 错误对象
   * @param {string} error.code - 错误代码
   * @param {string} error.message - 错误信息
   */
  onError: (error) => {
    alert(error.message)
  },

  /**
  * 支付流程回调
  * @param {string} status - 支付状态
  *   终态：success | pending | failed | cancelled
  *   中间态（仅 Apple Pay / Google Pay 原生按钮流程）：clicked | authorizing | processing
  */
  onPay: (status, paymentData) => {
    // 在这里处理支付逻辑
    console.log('支付状态:', status);
    console.log('相关支付数据', paymentData)
  },
})

// 使用 SDK
try {
  await legend.someMethod();
} catch (error) {
  // 错误会通过 onError 回调处理，这里可以不用重复处理
}

// —— 终态 ——

// success
{ status: "success", data: any }

// pending
{ status: "pending" }

// failed
{
  status: "failed",
  code: string,
  message: string,
  errors: object
}

// cancelled —— 用户主动取消支付
{
  status: "cancelled",
  provider: "applepay" | "googlepay",
  reason?: string   // 目前为 "user_abort"
}

// —— 中间态（仅 Apple Pay / Google Pay 原生按钮流程触发）——

// clicked —— 用户点击了 Apple Pay / Google Pay 按钮
{ status: "clicked", provider: "applepay" | "googlepay" }

// authorizing —— 支付 sheet 即将弹起，等待用户授权
{ status: "authorizing", provider: "applepay" | "googlepay" }

// processing —— 用户已授权，正在向 Legend 下单
{ status: "processing", provider: "applepay" | "googlepay" }

{
  status: "error",
  code: string,
  message: string,
  errors: object
}

const resp = await legend.authorize(authConfig));

// 使用服务端返回的加签数据调用授权方法
const resp = await legend.authorize({
  timestamp: data.timestamp, // 来自服务端的时间戳
  signature: data.signature, // 来自服务端的数字签名
  appId: data["APP-ID"], // 应用ID
  appKey: data["APP-KEY"], // 应用密钥
  appUid: data["APP-UID"], // 用户ID
  appUrl: data["APP-URL"], // 回调URL
  appEmail: data["APP-EMAIL"], // 用户邮箱
  appPhone: data["APP-PHONE"], // 用户手机号
});

console.log("授权响应:", resp);
console.log("KYC 状态", resp.kyc_status);

{
  "token_type": "Bearer",
  "expires_in": 3600,
  "access_token": "eyJ0eXAiOiJKV1QiLCJhbGciOiJSUzI1NiIsImp0aSI6IjdjNjk0NzBlYzM0NzA4MTM2YmZiMjEwYjZmYWYwOTk4YTYzMThmMDkwNDdhNTg0MDU3NzNlYmRlMDUwM2M4ZGViZDJhMTBmNDliMjczN2NlIn0...", // 完整的JWT令牌
  "user_preference": {
    "default_fiat": "EUR",
    "skip_bank_disclaimer": true,
    "skip_wire_disclaimer": true,
    "banner": []
  },
  "kyc_status": "Approved", // KYC认证状态
  "account_type": "Individual", // 账户类型
  "account_email": "[email protected]", // 账户邮箱
  "account_status": "active", // 账户状态
  "expires_at": "2023-03-21 09:09:51", // 令牌过期时间
  "next_kyc_step": "questionnaire", // 下一步KYC步骤
  "exchange_config": {
    "auto_withdrawal": true,
    "trade_confirmation_popup": "The purchased coins will arrive in your exchange wallet in 30mins - 1hour.",
    "minimum_trading_size": "40",
    "exchange_name": "PHEMEX",
    "logo_url": "https://legendtrading.com/img/logo-partners/phemex.png",
    "allowed_payment_methods": ["wire", "creditcard"],
    "user_max_ach_deposit": "1000",
    "allowed_fiat_deposit_methods": ["wire", "ach"],
    "allowed_fiat_withdraw_methods": ["wire"],
    "disable_modify_wallet": false,
    "no_sell": false,
    "app_type": "CEX",
    "allow_usd_wire_transfer": "off"
  },
  "user_info": {
    "edd": {}, // 增强尽职调查信息
    "rfi": {}  // 信息请求信息
  }
}

const state = legend.getState();

balance: {
  crypto_exchange: {    // 交易所加密货币余额
    [asset: string]: string
  },
  crypto: {            // 主钱包加密货币余额  
    [asset: string]: string
  },
  fiat: {              // 法币余额
    [asset: string]: string
  }
}

// 获取完整状态对象
const state = legend.getState();

// 检查 KYC 状态
console.log("KYC 状态:", state.kycStatus); // "Approved"

// 获取用户邮箱
console.log("用户邮箱:", state.accountEmail); // "[email protected]"

// 检查令牌过期时间
console.log("令牌过期:", state.expiresAt); // "2023-12-06 03:27:43"

const state = legend.getState();

// 检查法币余额
console.log("法币余额:", state.balance.fiat);
// 输出: { USD: "1000.00", EUR: "500.00" }

// 检查加密货币余额
console.log("加密货币余额:", state.balance.crypto);
// 输出: { BTC: "0.5", ETH: "2.3" }

const state = legend.getState();

// 检查是否支持信用卡支付
const canUseCreditCard = state.exchangeConfig.allowed_payment_methods.includes('creditcard');
console.log("支持信用卡:", canUseCreditCard); // true

// 检查最小交易金额
const minTradeSize = parseFloat(state.exchangeConfig.minimum_trading_size);
console.log("最小交易金额:", minTradeSize); // 40

const state = legend.getState();

switch (state.kycStatus) {
  case "Approved":
    console.log("KYC 已通过，可以正常交易");
    break;
  case "Pending":
    console.log("KYC 审核中，下一步:", state.nextKycStep);
    break;
  case "Rejected":
    console.log("KYC 被拒绝，请联系客服");
    break;
  default:
    console.log("未知 KYC 状态");
}

const profile = await legend.getAddressFromKyc();

// 获取 KYC 中的主要地址信息
const profile = await legend.getAddressFromKyc();
console.log("从 KYC 获取的主要地址: \n%o", profile);

// 输出示例:
// {
//   "name": "Yao 1 Ji",
//   "date_of_birth": "1988-08-08",
//   "address_line_1": "1329 Wiley Oak Dr",
//   "address_line_2": null,
//   "city": "Jarrettsville",
//   "country": "United States",
//   "country_iso2_code": "US",
//   "state": "California",
//   "zipcode": "21084-1953",
//   "registration_path": "deposit"
// }

const resp = await legend.createBillingAddress(addressData);

// 使用从 KYC 获取的地址设置新账单地址
const profile = await legend.getAddressFromKyc();
const resp = await legend.createBillingAddress(profile);

console.log("设置新账单地址并获取 UUID: \n%o", resp.uuid);
// 输出示例: "a1b2c3d4-e5f6-7890-abcd-ef1234567890"

// 或者创建自定义地址
const customAddress = {
  name: "Zhang San",
  date_of_birth: "1990-01-01",
  address_line_1: "123 Main Street",
  address_line_2: "Apt 4B",
  city: "New York",
  state: "New York",
  country: "United States",
  country_iso2_code: "US",
  zipcode: "10001",
  registration_path: "deposit"
};

const customResp = await legend.createBillingAddress(customAddress);
console.log("自定义地址设置结果:", customResp);
// 输出示例:
// {
//  "result": "success",
//   "message": "New billing address added.",
//   "uuid": "581bd72d-5091-4447-ad63-40f388d5794d"
// }

// 获取全部支付方式
const paymentMethods = await legend.getAllPaymentMethods();
console.log("所有支付方式: \n%o", paymentMethods);

// 根据交易对获取支付方式
const tradePaymentMethods = await legend.getPaymentMethodsByTrade({
  pair: "USDTUSD",  // 交易对
  side: "buy",      // 交易方向: "buy" 或 "sell"
});
console.log("交易相关支付方式: \n%o", tradePaymentMethods);

<!-- 信用卡号输入框 -->
<div class="frame-another-input"></div>

<!-- 支付表单容器 -->
<section class="frame-wrapper">
  <div class="frame-card-number"></div>   <!-- 卡号 -->
  <div class="frame-expiry-date"></div>   <!-- 有效期 -->
  <div class="frame-cvv"></div>           <!-- CVV -->
  <button class="btn-submit">提交</button> <!-- 提交按钮 -->
</section>

<!-- 3DS 认证 iframe -->
<iframe class="frame-3ds" title="3D Secure 认证"></iframe>

// 首先设置账单地址（必需）
const addressResult = await legend.createBillingAddress(profile);
const billingUuid = addressResult.uuid;

// 事件处理函数
const handleFrameEvents = (type) => (...args) => {
  console.log(`事件类型: ${type}`, ...args);
  
  // 处理表单验证状态
  if (type === "FRAME_VALIDATION_CHANGED") {
    const $frame = document.querySelector(`.frame-${args[0].element}`);
    if (args[0].isValid || args[0].isEmpty) {
      $frame.classList.remove("error");
    } else {
      $frame.classList.add("error");
    }
  }
  
  // 处理特定事件
  switch (type) {
    case "CARD_TOKENIZED":
      console.log("卡片令牌化成功");
      break;
    case "CARD_TOKENIZATION_FAILED":
      console.error("卡片令牌化失败");
      break;
    case "READY":
      console.log("支付框架准备就绪");
      break;
  }
};

try {
  const result = await legend.addPaymentMethod({
    // 必需参数
    uuidAddress: billingUuid, // 使用 setBillingAddress() 返回的 UUID
    btnSubmitSelector: ".btn-submit",
    frame3DsSelector: ".frame-3ds",
    
    // 3DS 认证回调
    showFrame3Ds: () => {
      console.log("显示 3DS 认证窗口");
      document.querySelector(".frame-3ds").style.display = "block";
    },
    hideFrame3Ds: () => {
      console.log("隐藏 3DS 认证窗口");
      document.querySelector(".frame-3ds").style.display = "none";
    },
    
    // 卡片字段配置
    cardNumber: {
      frameSelector: ".frame-another-input",
    },
    expiryDate: {
      // 使用默认配置
    },
    cvv: {
      // 使用默认配置
    },
    // 样式定制-推荐 styles和style配置一个即可
    styles: {
       "input": {
          "color": "black",
          "font-weight": "bold",
          "font-size": "20px",
          "letter-spacing": "3px"
        },
        "input#pan": {
          "font-size": "24px"
        },
        "input.is-valid": {
          "color": "green"
        },
        "input.is-invalid": {
          "color": "red"
        },
        "input.is-onfocus": {
          "color": "black"
        }
    },
    // 样式定制-已过时但兼容 
    style: {
      placeholder: {
        base: {
          color: "#ff2052",
          fontSize: "15px"
        }
      }
    },
    
    // 事件监听
    events: {
      CARD_BIN_CHANGED: handleFrameEvents("CARD_BIN_CHANGED"),
      CARD_SUBMITTED: handleFrameEvents("CARD_SUBMITTED"),
      CARD_TOKENIZED: handleFrameEvents("CARD_TOKENIZED"),
      CARD_TOKENIZATION_FAILED: handleFrameEvents("CARD_TOKENIZATION_FAILED"),
      CARD_VALIDATION_CHANGED: handleFrameEvents("CARD_VALIDATION_CHANGED"),
      FRAME_ACTIVATED: handleFrameEvents("FRAME_ACTIVATED"),
      FRAME_FOCUS: handleFrameEvents("FRAME_FOCUS"),
      FRAME_BLUR: handleFrameEvents("FRAME_BLUR"),
      FRAME_VALIDATION_CHANGED: handleFrameEvents("FRAME_VALIDATION_CHANGED"),
      PAYMENT_METHOD_CHANGED: handleFrameEvents("PAYMENT_METHOD_CHANGED"),
      READY: handleFrameEvents("READY"),
    },
  });
  
  console.log("添加支付方式成功: \n%o", result);
  
} catch (error) {
  console.error("添加支付方式失败: ", error);
}

// 删除支付方式
const result = await legend.removePaymentMethod({ 
  payment_method_id: "pm_123456789"  // 支付方式ID
});
console.log("删除支付方式结果: \n%o", result);

const legend = new LegendBase({
 /**
  * 支付流程回调
  * @param {string} status - 支付状态(success|pending|failed)
  */
  onPay: (status, paymentData) => {
    // 在这里处理支付逻辑
    console.log('支付状态:', status);
    console.log(‘相关支付数据’,paymentData)
  },
});

legend.on("legend:payment-success", (event) => {
  console.log("支付成功: \n%o", event.data);
  // 处理成功逻辑，如更新UI、跳转页面等
});

legend.on("legend:payment-failed", (event) => {
  console.error("支付失败:", event);
  // 示例事件数据:
  // {
  //   subject: "Unable to verify your card due to insufficient funds or credits.",
  //   message: "Please try a different card."
  // }
  alert(`支付失败: ${event.message}`);
});

legend.on("legend:payment-pending", (event) => {
  console.log("支付处理中: \n%o", event);
  // 显示处理中状态
});

legend.on("legend:payment-error", (event) => {
  console.error("支付错误: \n%o", event);
  // 处理系统错误
});

// recommended crypto friendly banks
const resp = await legend.queryRecommendedBanks({
  currency: "USD",
  country_iso2_code: "US"
});
console.log("recommended banks: \n%o", resp);

async function addCreditCard() {
  try {
    // 1. 设置账单地址
    const address = await legend.getAddressFromKyc();
    const addressResult = await legend.createBillingAddress(address);
    
    // 2. 添加支付方式
    const paymentResult = await legend.addPaymentMethod({
      uuidAddress: addressResult.uuid,
      btnSubmitSelector: ".btn-submit",
      frame3DsSelector: ".frame-3ds",
      showFrame3Ds: () => document.querySelector(".frame-3ds").style.display = "block",
      hideFrame3Ds: () => document.querySelector(".frame-3ds").style.display = "none",
      cardNumber: { frameSelector: ".frame-card-number" },
      expiryDate: {},
      cvv: {},
      events: {
        CARD_TOKENIZED: () => console.log("卡片添加成功"),
        CARD_TOKENIZATION_FAILED: (error) => console.error("卡片添加失败", error)
      }
    });
    
    console.log("支付方式添加成功:", paymentResult);
    return paymentResult;
    
  } catch (error) {
    console.error("添加支付方式失败:", error);
    throw error;
  }
}

const quote = await legend.quoteByFiat(quoteParams);

// 基于法币金额询价（买入 USDT）
const quote = await legend.quoteByFiat({
  pair: "USDTUSD",
  payment_method_id: "pm_123456789",
  side: "buy",
  size: 50,  // 50 USD
});

console.log("法币询价结果: \n%o", quote);

// 输出示例:
// {
//   created: "2025-10-09T08:43:36.785355Z",
//   pair: "USDTUSD",
//   price: "1.00530",
//   quantity: 47.4983,
//   processing_fee: "0.75",
//   network_fee: 1.5,
//   side: "buy",
//   size: 50
// }

const orderResult = await legend.orderByFiat(orderParams);

// 执行法币交易（买入 USDT）
const resp = await legend.orderByFiat({
  frame3DsSelector: ".frame-3ds",
  showFrame3Ds: () => {
    console.log("显示 3DS 验证窗口");
    document.querySelector(".frame-3ds").style.display = "block";
  },
  hideFrame3Ds: () => {
    console.log("隐藏 3DS 验证窗口");
    document.querySelector(".frame-3ds").style.display = "none";
  },
  app_state: "user_123_session_001", // 用于关联订单的任意字符串
  network: "ETH",
  pair: "USDTUSD",
  payment_method_id: "pm_123456789",
  side: "buy",
  size: 50,
  cvv: "123", // 从用户输入获取
});

console.log("交易执行结果: \n%o", resp);

// 输出示例:
// {
//   trade_id: "e792990b-9b79-423e-824e-bf125bd90e2a",
//   quantity: 47.498,
//   price: 1.00531,
//   pair: "USDTUSD",
//   side: "buy",
//   created: "2025-10-09T09:05:47.020480Z",
//   network_fee: 1.5,
//   processing_fee: "0.75",
//   size: 50
// }

<!-- 3DS 认证容器 -->
<div class="frame-3ds" style="display: none;">
  <!-- 3DS 认证 iframe 将在此渲染 -->
</div>

<!-- CVV 输入框（如果需要用户输入） -->
<div class="cvv-input-container">
  <label for="cvv">信用卡安全码 (CVV)</label>
  <input type="password" id="cvv" maxlength="4" placeholder="123">
</div>

async function executeTrade(tradeConfig) {
  try {
    const {
      amount,
      paymentMethodId,
      cryptoAsset = "USDT",
      network = "ETH",
      cvv
    } = tradeConfig;

    // 1. 先进行询价
    const quote = await legend.quoteByFiat({
      pair: `${cryptoAsset}USD`,
      payment_method_id: paymentMethodId,
      side: "buy",
      size: amount
    });

    console.log("询价结果:", quote);

    // 2. 执行交易
    const orderResult = await legend.orderByFiat({
      frame3DsSelector: ".frame-3ds",
      showFrame3Ds: () => {
        console.log("显示 3DS 认证");
        document.querySelector(".frame-3ds").classList.add("active");
      },
      hideFrame3Ds: () => {
        console.log("隐藏 3DS 认证");
        document.querySelector(".frame-3ds").classList.remove("active");
      },
      app_state: `trade_${Date.now()}_${cryptoAsset}`,
      network: network,
      pair: `${cryptoAsset}USD`,
      payment_method_id: paymentMethodId,
      side: "buy",
      size: amount,
      cvv: cvv
    });

    console.log("交易成功:", orderResult);
    return orderResult;

  } catch (error) {
    console.error("交易执行失败:", error);
    throw error;
  }
}

// 使用示例
const tradeResult = await executeTrade({
  amount: 100,
  paymentMethodId: "pm_123456789",
  cryptoAsset: "USDT",
  network: "ETH",
  cvv: "123"
});

const legend = new LegendBase({
 /**
  * 支付流程回调
  * @param {string} status - 支付状态(success|pending|failed)
  */
  onPay: (status, paymentData) => {
    // 在这里处理支付逻辑
    console.log('支付状态:', status);
    console.log(‘相关支付数据’,paymentData)
  },
});

/**
 * 支付流程回调
 * @param {string} status - 支付状态
 *   终态：'success' | 'pending' | 'failed' | 'cancelled'
 *   中间态：'clicked' | 'authorizing' | 'processing'
 * @param {Object} paymentData - 支付数据，根据状态不同数据结构有所差异
 */
onPay: (status, paymentData) => {
  // 处理支付状态变化
}

{
  "target": "checkout-redirect",
  "status": "success",
  "message": "Card added successfully.",
  "data": {
    "trade_id": "0ad4c41d-c76c-4a25-8343-7a0ae96786b3", // 交易ID
    "quantity": 47.4961,     // 成交数量
    "price": 1.00535,        // 成交价格
    "pair": "USDTUSD",       // 交易对
    "side": "buy",           // 买卖方向 (buy/sell)
    "created": "2025-07-13T03:19:38.549313Z", // 创建时间
    "network_fee": 1.5,      // 网络费用
    "processing_fee": "0.75", // 处理费用
    "size": 50               // 订单大小
  }
}

onPay: (status, paymentData) => {
  if (status === 'success') {
    console.log('支付成功!');
    console.log('交易ID:', paymentData.data.trade_id);
    console.log('成交数量:', paymentData.data.quantity);
    console.log('总费用:', paymentData.data.network_fee + parseFloat(paymentData.data.processing_fee));
    
    // 显示成功页面，更新订单状态等
    showSuccessPage(paymentData.data);
  }
}

{
  "target": "checkout-redirect",
  "status": "pending",
  "subject": "Trade In Progress",
  "message": "Your order is being processed, please check again later.",
  "data": {
    "target": "checkout-redirect",
    "status": "pending"
  }
}

onPay: (status, paymentData) => {
  if (status === 'pending') {
    console.log('支付处理中...');
    
    // 显示加载状态，防止用户重复提交
    showLoadingState('支付处理中，请稍候...');
  }
}

{
  "target": "checkout-redirect",
  "status": "failed",
  "subject": "Trade Failed", // 错误主题
  "message": "Please try again later.", // 错误详情
  "data": {
    "target": "checkout-redirect",
    "status": "failed",
    "subject": "Unable to verify your card.",
    "message": "There's an issue with your card. Please try another one."
  }
}

// message 列表

Please try again later.

Unable to verify your card.

Unable to fetch 3DS init data.

3DS verification failed.

Unable to fetch 3DS result data.

Unable to authenticate your payment.

Payment rejected

There's an issue with your card. Please check your card details or try a different card.

Your transaction was declined due to insufficient funds or spending limits. Please check your balance or contact your bank.

This transaction was declined for security reasons. Please contact your bank to verify and approve the transaction.

Your card issuer does not support crypto transaction. Please try a different card or payment method.

We're experiencing a temporary technical issue. Please try again in a few minutes.

Your transaction was blocked due to security and risk control policies. Please try again later or use a different payment method.

Card holder name do not match our record.

onPay: (status, paymentData) => {
  if (status === 'failed') {
    console.log('支付失败:', paymentData.subject);
    console.log('失败原因:', paymentData.message);
    
    // 显示错误提示给用户
    showErrorModal({
      title: paymentData.subject,
      message: paymentData.message
    });
  }
}

{
  "status": "cancelled",
  "provider": "googlepay",
  "reason": "user_abort"
}

onPay: (status, paymentData) => {
  if (status === 'cancelled') {
    // 用户主动取消不是错误，不要弹错误提示
    setLoading(false);
    showToast('支付已取消');
    enableRetryButton();
  }
}

{
  "status": "clicked",
  "provider": "googlepay"
}

onPay: (status, paymentData) => {
  if (status === 'clicked') {
    setLoading(true);
    disablePayButton();  // 防止重复点击
  }
}

{
  "status": "authorizing",
  "provider": "applepay"
}

onPay: (status, paymentData) => {
  if (status === 'authorizing') {
    // 支付 sheet 会遮住页面，此处可选择关闭页面 loading
    setLoading(false);
  }
}

{
  "status": "processing",
  "provider": "googlepay"
}

onPay: (status, paymentData) => {
  if (status === 'processing') {
    setLoading(true, '正在处理支付，请稍候…');
  }
}

const legend = new LegendBase({
  onPay: (status, paymentData) => {
    switch (status) {
      // ——— 中间态：仅 Apple Pay / Google Pay 原生按钮流程 ———
      case 'clicked':
        // 用户刚点下按钮，立刻给反馈
        setLoading(true);
        disablePayButton();
        break;

      case 'authorizing':
        // 支付 sheet 即将弹起，会遮住页面，可选关闭 loading
        setLoading(false);
        break;

      case 'processing':
        // 用户已授权，正在下单 —— Sandbox 环境可能耗时 20-40 秒
        setLoading(true, '正在处理支付，请稍候…');
        break;

      // ——— 终态 ———
      case 'success':
        // 支付成功处理
        setLoading(false);
        console.log('🎉 支付成功! 交易ID:', paymentData.data.trade_id);
        updateOrderStatus('completed', paymentData.data);
        redirectToSuccessPage();
        break;
        
      case 'pending':
        // 支付处理中
        setLoading(false);
        console.log('⏳ 支付处理中...');
        showProcessingOverlay();
        break;
        
      case 'failed':
        // 支付失败
        setLoading(false);
        console.log('❌ 支付失败:', paymentData.message);
        showErrorMessage(paymentData.subject, paymentData.message);
        enableRetryButton();
        break;

      case 'cancelled':
        // 用户主动取消 —— 不是错误，不要弹错误提示
        setLoading(false);
        console.log('用户取消了支付:', paymentData.provider);
        showToast('支付已取消');
        enableRetryButton();
        break;
        
      default:
        console.warn('未知的支付状态:', status);
    }
  }
});

{
  "code":422,
  "message": "Unauthenticated",
  "errors": {
    "signature": "Unauthenticated"
  }
}

{
  "code":422,
  "message": "Timestamp is not valid.",
  "errors": {
    "timestamp": "Timestamp is not valid."
  }
}

{
  "code": 422,
  "message": "The parent id field is required.",
  "errors": {
    "parent_id": ["The parent id field is required."]
  }
}

{
  "code": 422,
  "message": "The selected residential is invalid.",
  "errors": {
    "residential": ["The selected residential is invalid."]
  }
}

{
  "code": 422,
  "message": "The city is not allowed.",
  "errors": {
    "city": ["The city is not allowed."]
  }
}

{
  "code": 422,
  "message": "The country field is required when country iso2 code is not present.",
  "errors": {
    "country": [
      "The country field is required when country iso2 code is not present."
    ]
  }
}

{
  "code": 422,
  "message": "The country iso2 code must be 2 characters.",
  "errors": {
    "country_iso2_code": ["The country iso2 code must be 2 characters."]
  }
}

{
  "code": 422,
  "message": "The address line 1 field is required.",
  "errors": {
    "address_line_1": ["The address line 1 field is required."]
  }
}

{
  "code": 422,
  "message": "The state field is required.",
  "errors": {
    "state": ["The state field is required."]
  }
}

{
  "code": 422,
  "message": "The data field is required.",
  "errors": {
    "data": ["The data field is required."]
  }
}

{
  "code": 422,
  "message": "The data.token field is required.",
  "errors": {
    "data.token": ["The data.token field is required."]
  }
}

{
  "code": 422,
  "message": "The currency field is required.",
  "errors": {
    "currency": ["The currency field is required."]
  }
}

{
  "code": 422,
  "message": "The billing address field is required.",
  "errors": {
    "billing_address": ["You are not the owner of this model."]
  }
}

{
  "code": 422,
  "message": "The selected billing address is invalid.",
  "errors": {
    "billing_address": ["The selected billing address is invalid."]
  }
}

{
  "code": 403,
  "message": "To complete the verification process for your account, please check your email. We have sent instructions on how to finalize the verification of your latest deposits/withdrawals.",
  "error_code": "RFI_REQUIRED",
  "errors": {
    "rfi": ["RFI required"]
  },
  "data": {
    "url": "",
    "email": "",
    "grace_period_end_timestamp": null
  }
}

{
"code": 403,  
"message": "To complete the verification process for your account, please check your email. We have sent instructions on how to finalize the verification of your latest deposits/withdrawals.",
  "error_code": "EDD_REQUIRED",
  "errors": {
    "edd": ["EDD required"]
  },
  "data": {
    "email": ""
  }
}

{
  "code":500,
  "message": "Card rejected.",
  "error_code": "card_rejected",
  "errors": {
    "trade": ["Card rejected."]
  }
}

{
  "code":503,
  "message": "Account suspended - Please contact [email protected]",
  "error": "Account suspended - Please contact [email protected]"
}

{
  "success": "false",
  "code": "101100",
  "message": "Due to compliance reasons, we are unable to offer services to users from this region.",
  "metadata": {
    "ip": "1.1.1.1",
    "country": "AF"
  }
}

// 触发场景: WorldPay createTokenBySession API 调用失败
{
  "code": "305101",
  "message": "Please try again later."
}

// 触发场景: 绑卡时 CVV 验证失败
{
  "code": "305102",
  "message": "Unable to verify your card."
}

// 触发场景: init3DS API 调用失败
{
  "code": "305103",
  "message": "Unable to fetch 3DS init data."
}

// 触发场景: 3DS 验证失败（枚举定义）
{
  "code": "305104",
  "message": "3DS verification failed."
}

// 触发场景: get3DSResult API 调用失败
{
  "code": "305105",
  "message": "Unable to fetch 3DS result data."
}

// 触发场景: authenticate3DS / processChallenged3DS / get3DSResult 认证结果为失败
{
  "code": "305106",
  "message": "Unable to authenticate your payment."
}

// 触发场景: 超出信用卡交易限额
{
  "code": "305100",
  "message": "If you'd like to request for an increase in your trading limit please contact [email protected]"
}

// 触发场景: 支付时无具体结果码的兜底失败
{
  "code": "305108",
  "message": "Payment rejected"
}

// 触发场景: CVV 错误、卡号无效、卡已过期等卡信息问题
{
  "code": "305110",
  "message": "There's an issue with your card. Please check your card details or try a different card."
}

// 触发场景: 余额不足或超出消费限额
{
  "code": "305111",
  "message": "Your transaction was declined due to insufficient funds or spending limits. Please check your balance or contact your bank."
}

// 触发场景: 银行欺诈拦截或安全风险
{
  "code": "305112",
  "message": "This transaction was declined for security reasons. Please contact your bank to verify and approve the transaction."
}

// 触发场景: 发卡行不支持加密货币交易
{
  "code": "305113",
  "message": "Your card issuer does not support crypto transaction. Please try a different card or payment method."
}

// 触发场景: WorldPay 网关技术错误或超时
{
  "code": "305114",
  "message": "We're experiencing a temporary technical issue. Please try again in a few minutes."
}

// 触发场景: FraudSight 风险评分过高
{
  "code": "305115",
  "message": "Your transaction was blocked due to security and risk control policies. Please try again later or use a different payment method."
}

// 触发场景: 持卡人姓名与 KYC 记录不匹配
{
  "code": "305116",
  "message": "Card holder name do not match our record."
}

// 触发场景: getBinData API 调用失败
{
  "code": "305107",
  "message": "Unable to fetch BIN data."
}

// 触发场景: getDisputeAccessToken API 调用失败
{
  "code": "305109",
  "message": "Unable to get dispute access token"
}

// 触发场景: 手动维护开关启用
{
  "code": "305199",
  "message": "The service is currently under maintenance. Please try again later."
}

const legend = new LegendBase({
  onError: (error) => {
    console.error('SDK 错误:', error);
    
    // 根据错误代码进行分类处理
    switch (error.code) {
      case '101100':
        // 区域限制错误
        showBlockingError({
          title: '服务不可用',
          message: error.message,
          type: 'regional_restriction'
        });
        break;
        
      case 401:
      case 422:
        if (error.message.includes('Unauthenticated')) {
          // 认证错误
          handleAuthenticationError();
        } else if (error.errors) {
          // 参数验证错误
          handleValidationError(error.errors);
        } else {
          // 其他 4xx 错误
          showWarningToast(error.message);
        }
        break;
        
      case 500:
      case 502:
      case 503:
        // 服务器错误
        showServerError(error.message);
        break;
        
      default:
        // 未知错误
        showGenericError(error.message);
    }
  }
});

// 处理参数验证错误的辅助函数
function handleValidationErrors(errors) {
  const errorMessages = [];
  
  for (const [field, messages] of Object.entries(errors)) {
    if (Array.isArray(messages)) {
      errorMessages.push(...messages);
    } else {
      errorMessages.push(messages);
    }
  }
  
  if (errorMessages.length > 0) {
    showValidationErrorModal(errorMessages.join('\n'));
  }
}

const legend = new LegendBase({
  onError: (error) => {
    console.error('SDK 错误:', error);
  },
  onPay: (status, paymentData) => {
    console.log('支付状态:', status);
    console.log('支付数据:', paymentData);
  },
  onAuthChange: (status) => {
    console.log('KYC认证状态:', status);
  }
});

// bind events
legend.on("*", (type, e) => {
  console.log("custom event dispatched: \n[%o], %o", type, e);
});

legend.on("legend:payment-success", (e) => {
  // 在 addPaymentMethod() 方法或者 orderByFiat() 方法运行时触发。
  // 表示支付成功，添加卡片时的支付验证成功。
  console.log("legend:payment-success: \n%o", e);
  // {
  //   data: {
  //     "trade_id": "0ad4c41d-c76c-4a25-8343-7a0ae96786b3",
  //     "quantity": 47.4961,
  //     "price": 1.00535,
  //     "pair": "USDTUSD",
  //     "side": "buy",
  //     "created": "2025-07-13T03:19:38.549313Z",
  //     "network_fee": 1.5,
  //     "processing_fee": "0.75",
  //     "size": 50
  //   }
  // }

  // {
  //   "target": "checkout-redirect",
  //   "status": "success",
  //   "message": "Card added successfully.",
  //   "data": {}
  // }
});
legend.on("legend:payment-failed", (e) => {
  // 在 addPaymentMethod() 方法或者 orderByFiat() 方法运行时触发。
  // 表示支付失败，添加卡片时的支付验证失败。
  console.log("legend:payment-failed: \n%o", e);
  // {
  //   "target": "checkout-redirect",
  //   "status": "failed",
  //   "subject": "Unable to verify your card.",
  //   "message": "There’s an issue with your card. Please try another one."
  // }
});
legend.on("legend:payment-pending", (e) => {
  // 在 addPaymentMethod() 方法或者 orderByFiat() 方法运行时触发。
  // 表示支付或者添加卡片时的支付验证没有完成，等待外部服务的响应
  console.log("legend:payment-pending: \n%o", e);
});
legend.on("legend:payment-error", (e) => {
  // 在 addPaymentMethod() 方法或者 orderByFiat() 方法运行时触发。
  // 表示支付或者添加卡片时的支付验证发生错误。
  console.log("legend:payment-error: \n%o", e);
  // {
  //   "target": "checkout-redirect",
  //   "status": "failed",
  //   "subject": "Unable to verify your card.",
  //   "message": "There’s an issue with your card. Please try another one."
  // }
  // 也有另一种字符串格式的错误消息，需要检查数据类型
  // "Card form invalid"
});

legend.on("legend:payment-cancelled", (e) => {
  // 在 Apple Pay / Google Pay 原生按钮流程中，用户主动关闭支付 sheet 时触发。
  // 属于终态事件。旧版本中该场景走 legend:payment-error，现已拆分独立。
  console.log("legend:payment-cancelled: \n%o", e);
  // { provider: "googlepay", reason: "user_abort" }
});

legend.on("legend:payment-clicked", (e) => {
  // 用户点击 Apple Pay / Google Pay 按钮时触发（中间态）。
  console.log("legend:payment-clicked: \n%o", e);
  // { provider: "googlepay" }
});

legend.on("legend:payment-authorizing", (e) => {
  // 支付 sheet 即将弹起、等待用户授权时触发（中间态）。
  console.log("legend:payment-authorizing: \n%o", e);
  // { provider: "googlepay" }
});

legend.on("legend:payment-processing", (e) => {
  // 用户已在支付 sheet 中授权，SDK 正在向 Legend 下单时触发（中间态）。
  // Sandbox 环境该阶段实测耗时 20-40 秒，建议在此显示 loading。
  console.log("legend:payment-processing: \n%o", e);
  // { provider: "googlepay" }
});

legend.on("legend:add-payment-method", (e) => {
  // 在 addPaymentMethod() 方法执行完成，添加成功之后触发。
  console.log("legend:add-payment-method: \n%o", e);
  // {
  //   "type": "CREDIT",
  //   "entry": "",
  // }
});

legend.on("legend:frame-3ds", (e) => {
  // 在 addPaymentMethod() 方法或者 orderByFiat() 方法运行中遇到 3DS 验证时触发。
  // 表示需要显示或隐藏 3DS 验证的弹窗元素。
  // 也可以在调用方法时传入 showFrame3Ds 和 hideFrame3Ds 参数完成。
  console.log("legend:frame-3ds: \n%o", e);
  // { visible: true }
});

legend.on("legend:kyc-connect", (e) => {
  // 在实例调用 authorize() 方法之后触发，可以用来确认当前用户的 KYC 状态。
  // 也可以手动调用实例中的 getState() 方法，读取 kycStatus 确认 KYC 状态。
  console.log("legend:kyc-connect: \n%o", e);
  // { status: "Approved" }
});

legend.on("cancel-payment-method", (e) => {
  // 通常不需要处理这个取消事件，SDK 内部用于集成时兼容不同交互流程。
  // 表示取消了上一次的 addPaymentMethod() 方法的调用。
  console.log("cancel-payment-method: \n%o", e);
  // { status: "cancel" }
});