degate-cli 1.0.0

package/.env.example

@@ -0,0 +1,10 @@
+# DeGate CLI Configuration
+
+# Your MetaMask / EOA private key (with 0x prefix)
+PRIVATE_KEY=0x...
+
+# Environment: dev | prod
+ENV=dev
+
+# Key nonce (default 1, only change if you've reset your account)
+KEY_NONCE=1

package/cli.js

@@ -0,0 +1,1082 @@
+#!/usr/bin/env node
+
+const { Command } = require('commander');
+const chalk = require('chalk');
+const Table = require('cli-table3');
+const ora = require('ora');
+const { Wallet: EthersWallet, utils: ethersUtils } = require('ethers');
+const bip39 = require('bip39');
+const { hdkey } = require('ethereumjs-wallet');
+const { sha256 } = require('ethereumjs-util');
+const { derivePath } = require('ed25519-hd-key');
+const { Keypair, VersionedMessage, VersionedTransaction } = require('@solana/web3.js');
+const nacl = require('tweetnacl');
+const axios = require('axios');
+const inquirer = require('inquirer');
+const path = require('path');
+const fs = require('fs');
+
+require('dotenv').config({ path: path.join(__dirname, '.env') });
+
+// ─── Config ───────────────────────────────────────────────────────────────────
+
+const ENV_CONFIG = {
+  dev: {
+    DG_API: 'https://dev-backend.degate.com',
+    DEGATE_VERSION: 'Dev',
+    EXCHANGE_ADDRESS: '0x37e6969e1E8ACB307c68063d93fD929354D06140',
+    DEX_CHAIN_ID: 17000,
+    SIGN_TEMPLATE: 'S3',
+    API_SIGN_VALID_ADDRESS: '0xC1D393b94b6dcE9732f86042609FD698A0B00164',
+  },
+  prod: {
+    DG_API: 'https://v1-mainnet-backend.degate.com',
+    DEGATE_VERSION: 'V1',
+    EXCHANGE_ADDRESS: '0x5859cCb16DC791f79AAFadD5B9768bC400797A29',
+    DEX_CHAIN_ID: 1,
+    SIGN_TEMPLATE: 'S3',
+    API_SIGN_VALID_ADDRESS: '',
+  },
+};
+
+function getConfig() {
+  const env = process.env.ENV || 'dev';
+  return ENV_CONFIG[env] || ENV_CONFIG.dev;
+}
+
+// ─── Crypto Utils ─────────────────────────────────────────────────────────────
+
+function formatSignDate(dateObj) {
+  const year = dateObj.getUTCFullYear();
+  const month = String(dateObj.getUTCMonth() + 1).padStart(2, '0');
+  const day = String(dateObj.getUTCDate()).padStart(2, '0');
+  const hours = String(dateObj.getUTCHours()).padStart(2, '0');
+  const minutes = String(dateObj.getUTCMinutes()).padStart(2, '0');
+  const seconds = String(dateObj.getUTCSeconds()).padStart(2, '0');
+  const milliseconds = String(dateObj.getUTCMilliseconds()).padStart(3, '0');
+  return `${year}-${month}-${day} ${hours}:${minutes}:${seconds}.${milliseconds} UTC`;
+}
+
+function getSignMsg(keyNonce) {
+  const cfg = getConfig();
+  return `DeGate: ${cfg.DEGATE_VERSION}\nNonce: ${keyNonce}`;
+}
+
+async function signEthereumMessage(message, privateKey) {
+  const wallet = new EthersWallet('0x' + privateKey);
+  return wallet.signMessage(message);
+}
+
+// ─── Key Derivation ───────────────────────────────────────────────────────────
+
+function deriveDGWallet(mnemonic) {
+  const seed = bip39.mnemonicToSeedSync(mnemonic);
+  const derivationPath = `m/44'/7999801'/0'/0/0`;
+  const hd = hdkey.fromMasterSeed(seed);
+  const wallet = hd.derivePath(derivationPath).getWallet();
+  const privateKey = wallet.getPrivateKey().toString('hex');
+  const ethWallet = new EthersWallet('0x' + privateKey);
+  return { chain: 'DGWallet', path: derivationPath, address: ethWallet.address, privateKey };
+}
+
+function deriveSolanaDA(mnemonic, exchangeAddress, time) {
+  const seed = bip39.mnemonicToSeedSync(mnemonic);
+  const derivationPath = `m/44'/501'/0'/0'`;
+  const derivedSeed = derivePath(derivationPath, seed.toString('hex')).key;
+  const keypair = Keypair.fromSeed(derivedSeed);
+  const address = keypair.publicKey.toBase58();
+  const privateKey = Buffer.from(keypair.secretKey).toString('hex');
+  const publicKey = Buffer.from(keypair.publicKey.toBytes()).toString('hex');
+  return { chain: 'SOLANA', path: derivationPath, address, publicKey, privateKey, time };
+}
+
+function deriveEthereumDA(mnemonic, exchangeAddress, time) {
+  const seed = bip39.mnemonicToSeedSync(mnemonic);
+  const derivationPath = `m/44'/60'/0'/0/0`;
+  const hd = hdkey.fromMasterSeed(seed);
+  const wallet = hd.derivePath(derivationPath).getWallet();
+  const privateKey = wallet.getPrivateKey().toString('hex');
+  const ethWallet = new EthersWallet('0x' + privateKey);
+  const signingKey = new ethersUtils.SigningKey('0x' + privateKey);
+  const publicKey = signingKey.publicKey.slice(2);
+  return { chain: 'ETHEREUM', path: derivationPath, address: ethWallet.address, publicKey, privateKey, time };
+}
+
+async function deriveAllKeys(eoaPrivateKey, keyNonce) {
+  const cfg = getConfig();
+  const keyMessage = getSignMsg(keyNonce);
+
+  const eoaWallet = new EthersWallet(eoaPrivateKey);
+  const eoaAddress = eoaWallet.address;
+  const signature = await eoaWallet.signMessage(keyMessage);
+
+  const L0Seed = sha256(Buffer.from(ethersUtils.arrayify(signature)));
+  const daSeed = sha256(Buffer.concat([L0Seed, Buffer.from('solana')]));
+  const mnemonic = bip39.entropyToMnemonic(daSeed);
+
+  const time = Date.now();
+  const dgWallet = deriveDGWallet(mnemonic);
+  const solanaDA = deriveSolanaDA(mnemonic, cfg.EXCHANGE_ADDRESS, time);
+  const ethereumDA = deriveEthereumDA(mnemonic, cfg.EXCHANGE_ADDRESS, time);
+
+  return {
+    eoaAddress,
+    mnemonic,
+    DGWallet: dgWallet,
+    SOLANA: solanaDA,
+    ETHEREUM: ethereumDA,
+    BASE: { ...ethereumDA, chain: 'BASE' },
+    da_owner: `${dgWallet.address}_0`,
+  };
+}
+
+// ─── Transaction Signing ──────────────────────────────────────────────────────
+
+const EVM_CHAINS = ['ETHEREUM', 'BASE', 'BSC', 'ARBITRUM', 'OPTIMISM', 'AVALANCHE', 'POLYGON'];
+
+function signSolanaTransaction(transactionData, mnemonic) {
+  const seed = bip39.mnemonicToSeedSync(mnemonic);
+  const derivedSeed = derivePath(`m/44'/501'/0'/0'`, seed.toString('hex')).key;
+  const keypair = Keypair.fromSeed(derivedSeed);
+
+  // 完全对齐 DgSolWallet.signTransaction 的两个分支：
+  // - hex → VersionedMessage.deserialize → sign → 返回 hex 签名（64 bytes）
+  // - base58 → VersionedTransaction.deserialize → sign → 返回完整 base58 signed tx
+  const isHex = /^[0-9a-fA-F]+$/.test(transactionData);
+  if (isHex) {
+    const msgBytes = Buffer.from(transactionData, 'hex');
+    const message = VersionedMessage.deserialize(msgBytes);
+    const tx = new VersionedTransaction(message);
+    tx.sign([keypair]);
+    return Buffer.from(tx.signatures[0]).toString('hex');
+  } else {
+    const txBytes = Buffer.from(ethersUtils.base58.decode(transactionData));
+    const tx = VersionedTransaction.deserialize(txBytes);
+    tx.sign([keypair]);
+    return ethersUtils.base58.encode(tx.serialize());
+  }
+}
+
+async function signEVMTransaction(transactionData, mnemonic) {
+  const seed = bip39.mnemonicToSeedSync(mnemonic);
+  const hd = hdkey.fromMasterSeed(seed);
+  const walletKey = hd.derivePath(`m/44'/60'/0'/0/0`).getWallet();
+  const privateKey = walletKey.getPrivateKey().toString('hex');
+
+  if (typeof transactionData === 'string') {
+    // raw hex digest → sign directly（与 dg-wallet/src/da/ethereum/index.ts 一致）
+    const signingKey = new ethersUtils.SigningKey('0x' + privateKey);
+    const rawDataHex = transactionData.startsWith('0x') ? transactionData : '0x' + transactionData;
+    const messageBytes = ethersUtils.arrayify(rawDataHex);
+    const signature = signingKey.signDigest(messageBytes);
+    const { r, s, v } = signature;
+    const normalizedV = (v >= 27 ? v - 27 : v).toString().padStart(2, '0');
+    return `${normalizedV}${r.slice(2).toLowerCase()}${s.slice(2).toLowerCase()}`;
+  }
+
+  // transaction object → 完整签名（对齐 DgEVMWallet.signTransaction）
+  const ethWallet = new EthersWallet('0x' + privateKey);
+  const txParams = { ...transactionData };
+  if (txParams.type !== undefined) txParams.type = Number(txParams.type);
+  const signedTx = await ethWallet.signTransaction(txParams);
+  return signedTx;
+}
+
+async function signTransaction(chain, transactionData, mnemonic) {
+  if (chain === 'SOLANA') {
+    return signSolanaTransaction(transactionData, mnemonic);
+  }
+  if (EVM_CHAINS.includes(chain)) {
+    return signEVMTransaction(transactionData, mnemonic);
+  }
+  throw new Error(`Unsupported chain: ${chain}`);
+}
+
+// ─── API Client ───────────────────────────────────────────────────────────────
+
+function createApiClient(jwtToken) {
+  const cfg = getConfig();
+  const client = axios.create({
+    baseURL: cfg.DG_API,
+    timeout: 30000,
+    headers: {
+      'Content-Type': 'application/json;charset=utf-8',
+      source: 'degate_cli',
+      ...(jwtToken ? { Authorization: `Bearer ${jwtToken}` } : {}),
+    },
+  });
+
+  client.interceptors.response.use(
+    (resp) => {
+      const { data, code, message } = resp?.data ?? {};
+      if (code !== 0) throw { code, message, data };
+      return { data, code, message };
+    },
+    (error) => {
+      const { code, message } = error?.response?.data ?? {};
+      throw { code, message: message || error.message };
+    }
+  );
+
+  return client;
+}
+
+async function getAccessToken(dgWalletPrivateKey) {
+  const time = new Date();
+  const keyMessage = `Sign to view\n${formatSignDate(time)}`;
+  const signature = await signEthereumMessage(keyMessage, dgWalletPrivateKey);
+  const dgWallet = new EthersWallet('0x' + dgWalletPrivateKey);
+
+  const client = createApiClient();
+  const resp = await client.post('/order-book-api/intent/access/token', {
+    wallet_id: dgWallet.address,
+    time: time.valueOf(),
+    ecdsa_signature: signature,
+    account_index: 0,
+  });
+  return resp.data.token;
+}
+
+async function fetchChainInfo(client) {
+  const resp = await client.get('/order-book-api/intent/chains');
+  const { chains } = resp.data;
+  return (chains || []).filter(d => d.gas_token?.token_id).map(d => ({
+    chain: d.chain_name,
+    chainCode: d.chain_code,
+    isFungibleChain: d.is_support_fungible_usdc,
+    isEvmChain: d.is_evm_chain,
+    chainId: d.chain_id,
+    quoteToken: d.quote_token,
+    gasToken: d.gas_token,
+    solverAddress: null,
+    gasAddress: null,
+  }));
+}
+
+async function fetchChainConfig(client) {
+  const resp = await client.get('/intent-omni/get_app_config_template');
+  return resp.data;
+}
+
+async function getSolverAddresses(client) {
+  const [chainInfo, chainConfig] = await Promise.all([
+    fetchChainInfo(client),
+    fetchChainConfig(client),
+  ]);
+
+  const configs = JSON.parse(chainConfig.data);
+  const result = {};
+  chainInfo.forEach(d => {
+    const config = configs.chains?.find(c => c.name === d.chain) || {};
+    result[d.chain] = {
+      solver: config.solverAddress || '',
+      gas: config.gasAddress || '',
+      chainId: config.chainId,
+      isEvmChain: d.isEvmChain,
+      gasToken: d.gasToken || null,
+    };
+  });
+  return { solverMap: result, chainInfo, chainConfig: configs };
+}
+
+async function fetchDAOwner(eoaAddress) {
+  const client = createApiClient();
+  try {
+    const resp = await client.get('/order-book-api/intent/account', {
+      params: { l0_address: eoaAddress },
+    });
+    return resp.data?.owner || '';
+  } catch (err) {
+    if (err.code === 100000) return '';
+    throw err;
+  }
+}
+
+async function fetchRegisteredDAs(authClient) {
+  try {
+    const resp = await authClient.get('/order-book-api/intent/daAddress');
+    const { key_nonce_when_addr_generate, addresses } = resp.data || {};
+    const das = {};
+    (addresses || []).forEach(item => {
+      const info = item.chain_addresses_info?.[0] || {};
+      das[item.chain_name?.toUpperCase()] = {
+        chain: item.chain_name?.toUpperCase(),
+        address: info.address,
+        publicKey: info.public_key,
+        path: info.address_path,
+      };
+    });
+    return { keyNonce: key_nonce_when_addr_generate, das };
+  } catch {
+    return { keyNonce: null, das: {} };
+  }
+}
+
+async function signSolanaMessage(message, privateKey) {
+  const keyPair = Keypair.fromSecretKey(Buffer.from(privateKey, 'hex'));
+  const messageBytes = new TextEncoder().encode(message);
+  const signature = nacl.sign.detached(messageBytes, keyPair.secretKey);
+  return Buffer.from(signature).toString('hex');
+}
+
+async function registerDAs(authClient, { eoaAddress, keys, keyNonce }) {
+  const cfg = getConfig();
+  const time = keys.SOLANA.time || Date.now();
+
+  const solSig = await signSolanaMessage(
+    cfg.EXCHANGE_ADDRESS + '-' + time,
+    keys.SOLANA.privateKey
+  );
+  const ethSig = await signEthereumMessage(
+    cfg.EXCHANGE_ADDRESS + '-' + time,
+    keys.ETHEREUM.privateKey
+  );
+
+  const chainDAs = {
+    SOLANA: { ...keys.SOLANA, signature: solSig },
+    ETHEREUM: { ...keys.ETHEREUM, signature: ethSig },
+    BASE: { ...keys.ETHEREUM, chain: 'BASE', signature: ethSig },
+    DGWallet: keys.DGWallet,
+  };
+
+  const addresses = Object.values(chainDAs)
+    .filter(d => d?.address && d.chain !== 'DGWallet')
+    .map(d => d.address)
+    .join(',');
+  const daKeyMessage = `0,${addresses}\nTime: ${formatSignDate(new Date(time))}`;
+  const walletDaSig = await signEthereumMessage(daKeyMessage, keys.DGWallet.privateKey);
+
+  const daAddresses = Object.entries(chainDAs)
+    .filter(([, d]) => d?.chain && d.chain !== 'DGWallet')
+    .map(([, d]) => ({
+      chain_name: d.chain.toUpperCase(),
+      chain_addresses_info: [{
+        public_key: d.publicKey,
+        address: d.address,
+        address_path: d.path,
+        sig: d.signature,
+      }],
+    }));
+
+  const data = {
+    l0_address: eoaAddress,
+    wallet_id: keys.DGWallet.address,
+    account_index: 0,
+    wallet_da_signature: walletDaSig,
+    addresses: daAddresses,
+    sig_time_stamp_in_msec: time,
+    key_nonce_when_addr_generate: keyNonce,
+  };
+
+  const resp = await authClient.post('/order-book-api/intent/daAddress', data);
+  return resp.data;
+}
+
+async function fetchProducts(client) {
+  const resp = await client.get('/order-book-api/turbo-range/products', {
+    params: { limit: 100, offset: 0 },
+  });
+  return resp.data.items || [];
+}
+
+async function fetchPositions(client, status = 'OPEN') {
+  const resp = await client.get('/order-book-api/intent/turboRange', {
+    params: { limit: 100, offset: 0, status },
+  });
+  return resp.data;
+}
+
+async function fetchPositionDetail(client, positionAddress) {
+  const resp = await client.get('/order-book-api/intent/turboRange/detail', {
+    params: { position: positionAddress },
+  });
+  return resp.data;
+}
+
+// ─── Intent Flow ──────────────────────────────────────────────────────────────
+
+async function intentTryCreate(client, order) {
+  const resp = await client.post('/order-book-api/intent/v2/compact_try_create', order, {
+    headers: { Version: '0.0.1' },
+  });
+  return resp.data;
+}
+
+async function intentSign(client, signData) {
+  const resp = await client.post('/order-book-api/intent/v2/sign', signData, {
+    headers: { Version: '0.0.1' },
+  });
+  return resp.data;
+}
+
+function verifyApiSign(message, sig) {
+  const cfg = getConfig();
+  if (!cfg.API_SIGN_VALID_ADDRESS) return true;
+  try {
+    const recovered = ethersUtils.verifyMessage(message, sig);
+    return recovered.toLowerCase() === cfg.API_SIGN_VALID_ADDRESS.toLowerCase();
+  } catch {
+    return false;
+  }
+}
+
+async function signAndSubmitIntent(client, tryResp, mnemonic, das) {
+  const intentItem = tryResp.result;
+  if (!intentItem) throw new Error('compact_try_create 未返回 result');
+
+  if (!verifyApiSign(intentItem.data, intentItem.signature)) {
+    throw new Error('API 签名验证失败');
+  }
+
+  const data = JSON.parse(intentItem.data);
+  const { action, add_on } = data;
+
+  const addOnTxs = (add_on || []).reduce((re, t) => re.concat(t.more_transactions || []), []);
+  const allTxs = (action?.more_transactions || []).concat(addOnTxs);
+
+  const myTxs = allTxs.filter(t => {
+    const daAddr = das[t.chain]?.address?.toLowerCase();
+    return daAddr && t.signers?.some(s => s?.toLowerCase() === daAddr);
+  });
+
+  if (!myTxs.length) throw new Error('没有需要签名的交易');
+
+  const txHashes = {};
+  const signatures = await Promise.all(myTxs.map(async tx => {
+    const sig = await signTransaction(tx.chain, tx.data, mnemonic);
+    if (tx.chain === 'SOLANA') {
+      // Solana tx hash = 已签名 tx 的第一个 signature（base58）
+      try {
+        const signedTxBytes = Buffer.from(ethersUtils.base58.decode(sig));
+        const signedTx = VersionedTransaction.deserialize(signedTxBytes);
+        txHashes[tx.transaction_uuid] = ethersUtils.base58.encode(signedTx.signatures[0]);
+      } catch {}
+    } else if (EVM_CHAINS.includes(tx.chain) && typeof sig === 'string' && sig.startsWith('0x')) {
+      // EVM tx hash = keccak256(signed RLP bytes)
+      try {
+        txHashes[tx.transaction_uuid] = ethersUtils.keccak256(ethersUtils.arrayify(sig));
+      } catch {}
+    }
+    return { uuid: tx.transaction_uuid, signature: sig };
+  }));
+
+  const signResp = await intentSign(client, {
+    uuid: intentItem.uuid,
+    expand_signatures: signatures,
+  });
+
+  return { ...signResp, txHashes };
+}
+
+// ─── Wallet Session ───────────────────────────────────────────────────────────
+
+const SESSION_FILE = path.join(__dirname, '.session.json');
+
+function saveSession(session) {
+  fs.writeFileSync(SESSION_FILE, JSON.stringify(session, null, 2));
+}
+
+function loadSession() {
+  if (!fs.existsSync(SESSION_FILE)) return null;
+  try {
+    return JSON.parse(fs.readFileSync(SESSION_FILE, 'utf8'));
+  } catch { return null; }
+}
+
+async function buildSession(privateKey, keyNonce = 1, env = 'dev') {
+  if (env) process.env.ENV = env;
+  const spinner = ora('派生密钥...').start();
+  try {
+    const keys = await deriveAllKeys(privateKey, keyNonce);
+
+    spinner.text = '获取 Access Token...';
+    const jwt = await getAccessToken(keys.DGWallet.privateKey);
+    const client = createApiClient(jwt);
+
+    spinner.text = '获取 DA Owner...';
+    const da_owner = await fetchDAOwner(keys.eoaAddress) || `${keys.DGWallet.address}_0`;
+
+    spinner.text = '检查 DA 注册状态...';
+    const { das: registeredDAs } = await fetchRegisteredDAs(client);
+    const needsSync = !registeredDAs.SOLANA?.address || !registeredDAs.ETHEREUM?.address;
+    if (needsSync) {
+      spinner.text = '注册 DA 地址到后端...';
+      await registerDAs(client, { eoaAddress: keys.eoaAddress, keys, keyNonce });
+    }
+
+    spinner.text = '获取链配置...';
+    const { solverMap } = await getSolverAddresses(client);
+
+    const session = {
+      env,
+      eoaAddress: keys.eoaAddress,
+      da_owner,
+      dgWalletAddress: keys.DGWallet.address,
+      dgWalletPrivateKey: keys.DGWallet.privateKey,
+      solanaAddress: keys.SOLANA.address,
+      ethereumDAAddress: keys.ETHEREUM.address,
+      mnemonic: keys.mnemonic,
+      jwt,
+      solverMap,
+      jwtCreatedAt: Date.now(),
+      das: {
+        SOLANA: { address: keys.SOLANA.address, privateKey: keys.SOLANA.privateKey },
+        ETHEREUM: { address: keys.ETHEREUM.address, privateKey: keys.ETHEREUM.privateKey },
+        BASE: { address: keys.ETHEREUM.address, privateKey: keys.ETHEREUM.privateKey },
+        BSC: { address: keys.ETHEREUM.address, privateKey: keys.ETHEREUM.privateKey },
+        ARBITRUM: { address: keys.ETHEREUM.address, privateKey: keys.ETHEREUM.privateKey },
+        OPTIMISM: { address: keys.ETHEREUM.address, privateKey: keys.ETHEREUM.privateKey },
+        AVALANCHE: { address: keys.ETHEREUM.address, privateKey: keys.ETHEREUM.privateKey },
+        POLYGON: { address: keys.ETHEREUM.address, privateKey: keys.ETHEREUM.privateKey },
+      },
+    };
+    saveSession(session);
+    spinner.succeed('认证成功');
+
+    console.log(chalk.gray(`  EOA: ${keys.eoaAddress}`));
+    console.log(chalk.gray(`  DGWallet: ${keys.DGWallet.address}`));
+    console.log(chalk.gray(`  DA Owner: ${da_owner}`));
+    console.log(chalk.gray(`  Solana DA: ${keys.SOLANA.address}`));
+    return session;
+  } catch (err) {
+    spinner.fail('认证失败');
+    console.error(chalk.red(err.message || JSON.stringify(err)));
+    process.exit(1);
+  }
+}
+
+async function ensureSession() {
+  let session = loadSession();
+  if (session) {
+    if (session.env) process.env.ENV = session.env;
+    return session;
+  }
+
+  const pk = process.env.PRIVATE_KEY;
+  if (pk) {
+    const keyNonce = parseInt(process.env.KEY_NONCE || '1', 10);
+    return buildSession(pk, keyNonce, process.env.ENV || 'dev');
+  }
+
+  console.log(chalk.yellow('未找到 session，请先运行: node cli.js setup'));
+  process.exit(1);
+}
+
+async function getAuthClient(session) {
+  const ONE_HOUR = 60 * 60 * 1000;
+  let jwt = session.jwt;
+
+  if (Date.now() - (session.jwtCreatedAt || 0) > ONE_HOUR) {
+    const spinner = ora('刷新 Access Token...').start();
+    try {
+      jwt = await getAccessToken(session.dgWalletPrivateKey);
+      session.jwt = jwt;
+      session.jwtCreatedAt = Date.now();
+      saveSession(session);
+      spinner.succeed('Token 已刷新');
+    } catch (err) {
+      spinner.fail('Token 刷新失败，请重新 init');
+      throw err;
+    }
+  }
+
+  return createApiClient(jwt);
+}
+
+// ─── Explorer Utils ───────────────────────────────────────────────────────────
+
+const EVM_EXPLORERS = {
+  ETHEREUM: { mainnet: 'https://etherscan.io/tx/', testnet: 'https://sepolia.etherscan.io/tx/' },
+  BASE:     { mainnet: 'https://basescan.org/tx/', testnet: 'https://sepolia.basescan.org/tx/' },
+  BSC:      { mainnet: 'https://bscscan.com/tx/', testnet: 'https://testnet.bscscan.com/tx/' },
+  ARBITRUM: { mainnet: 'https://arbiscan.io/tx/', testnet: 'https://sepolia.arbiscan.io/tx/' },
+  OPTIMISM: { mainnet: 'https://optimistic.etherscan.io/tx/', testnet: 'https://sepolia-optimism.etherscan.io/tx/' },
+  AVALANCHE:{ mainnet: 'https://snowtrace.io/tx/', testnet: 'https://testnet.snowtrace.io/tx/' },
+  POLYGON:  { mainnet: 'https://polygonscan.com/tx/', testnet: 'https://amoy.polygonscan.com/tx/' },
+};
+
+function buildExplorerUrl(chain, txHash) {
+  const cfg = getConfig();
+  const isProd = cfg.DEX_CHAIN_ID === 1;
+  if (chain === 'SOLANA') {
+    return `https://solscan.io/tx/${txHash}${isProd ? '' : '?cluster=devnet'}`;
+  }
+  const exp = EVM_EXPLORERS[chain];
+  if (exp) return (isProd ? exp.mainnet : exp.testnet) + txHash;
+  return null;
+}
+
+// ─── Commands ─────────────────────────────────────────────────────────────────
+
+async function cmdSetup() {
+  console.log(chalk.cyan.bold('\n🔐 DeGate CLI Setup\n'));
+
+  const existing = loadSession();
+  if (existing) {
+    const { overwrite } = await inquirer.prompt([{
+      type: 'confirm',
+      name: 'overwrite',
+      message: `已有 session (${existing.eoaAddress})，要覆盖吗?`,
+      default: false,
+    }]);
+    if (!overwrite) {
+      console.log(chalk.gray('已取消'));
+      return;
+    }
+  }
+
+  const answers = await inquirer.prompt([
+    {
+      type: 'password',
+      name: 'privateKey',
+      message: '输入你的 EOA 私钥 (MetaMask 私钥):',
+      mask: '*',
+      validate: (v) => {
+        const key = v.startsWith('0x') ? v : '0x' + v;
+        try { new EthersWallet(key); return true; } catch { return '私钥格式不对'; }
+      },
+    },
+    {
+      type: 'list',
+      name: 'env',
+      message: '选择环境:',
+      choices: [
+        { name: 'Dev  (dev-backend.degate.com)', value: 'dev' },
+        { name: 'Prod (v1-mainnet-backend.degate.com)', value: 'prod' },
+      ],
+      default: 'dev',
+    },
+    {
+      type: 'number',
+      name: 'keyNonce',
+      message: 'Key Nonce (首次注册填 1):',
+      default: 1,
+    },
+  ]);
+
+  const pk = answers.privateKey.startsWith('0x') ? answers.privateKey : '0x' + answers.privateKey;
+  await buildSession(pk, answers.keyNonce, answers.env);
+  console.log(chalk.green('\n✅ Setup 完成! 现在可以使用 products / deposit / withdraw 等命令'));
+}
+
+async function cmdProducts() {
+  const session = await ensureSession();
+  const client = await getAuthClient(session);
+  const spinner = ora('获取产品列表...').start();
+
+  try {
+    const products = await fetchProducts(client);
+    spinner.stop();
+
+    if (!products.length) {
+      console.log(chalk.yellow('暂无产品'));
+      return;
+    }
+
+    const table = new Table({
+      head: ['#', 'Pool', 'Chain', 'Price', '7d APY', 'Range', 'Fee', 'Pool Address'].map(h => chalk.cyan(h)),
+      style: { head: [] },
+    });
+
+    products.forEach((p, i) => {
+      const baseSymbol = p.token_a?.symbol || '?';
+      const quoteSymbol = p.token_b?.symbol || '?';
+      const chain = p.chain_name || '-';
+      const price = parseFloat(p.current_price || 0).toFixed(p.priceDecimals || 4);
+      const apy = p.week_apr ? `${parseFloat(p.week_apr).toFixed(2)}%` : '-';
+      const range = `${p.price_percentage_min || 0}%-${p.price_percentage_max || 0}%`;
+      const fee = p.fee_percentage ? `${p.fee_percentage}%` : '-';
+      table.push([
+        i + 1,
+        `${baseSymbol}/${quoteSymbol}`,
+        chain,
+        price,
+        apy,
+        range,
+        fee,
+        p.pool_address?.slice(0, 16) + '...',
+      ]);
+    });
+
+    console.log(chalk.bold('\n📊 Turbo Range 产品列表\n'));
+    console.log(table.toString());
+    console.log(chalk.gray(`\n共 ${products.length} 个产品`));
+  } catch (err) {
+    spinner.fail('获取产品失败');
+    console.error(chalk.red(err.message || JSON.stringify(err)));
+  }
+}
+
+async function cmdDeposit(options) {
+  const session = await ensureSession();
+  const client = await getAuthClient(session);
+
+  const spinner = ora('获取产品信息...').start();
+  try {
+    const products = await fetchProducts(client);
+    let product;
+
+    if (options.pool) {
+      product = products.find(p =>
+        p.pool_address?.toLowerCase() === options.pool.toLowerCase() ||
+        p.token_a?.symbol?.toLowerCase() === options.pool.toLowerCase()
+      );
+    } else if (options.index) {
+      product = products[parseInt(options.index, 10) - 1];
+    }
+
+    if (!product) {
+      spinner.fail('未找到产品，请用 --pool <address> 或 --index <num>');
+      return;
+    }
+
+    const currentPrice = parseFloat(product.current_price);
+    const chain = product.chain_name;
+    const poolAddress = product.pool_address;
+    const amount = options.amount;
+    const showDecimals = product.priceDecimals || 4;
+
+    if (!amount) {
+      spinner.fail('请指定 --amount');
+      return;
+    }
+
+    let minPrice, maxPrice;
+    if (options.range) {
+      const rangePct = parseFloat(options.range) / 100;
+      minPrice = (currentPrice * (1 - rangePct)).toFixed(showDecimals);
+      maxPrice = (currentPrice * (1 + rangePct)).toFixed(showDecimals);
+    } else if (options.min && options.max) {
+      minPrice = options.min;
+      maxPrice = options.max;
+    } else {
+      spinner.fail('请指定 --range <百分比> 或 --min/--max');
+      return;
+    }
+
+    const solver = session.solverMap[chain] || {};
+    const da = session.das[chain];
+    if (!da) {
+      spinner.fail(`不支持的链: ${chain}`);
+      return;
+    }
+
+    const usdcToken = product.token_b;
+    const decimals = usdcToken?.decimals || 6;
+    const volume = ethersUtils.parseUnits(amount, decimals).toString();
+    const usdcChain = usdcToken.chain || chain;
+    const usdcDa = session.das[usdcChain] || da;
+    const gasToken = solver.gasToken;
+
+    const intentOrder = {
+      owner: session.da_owner,
+      intent: {
+        modifiable: false,
+        type: 'LP_DEPOSIT',
+        chain,
+        gas_payer_address: solver.gas || '',
+        token_out: [{
+          chain: usdcChain,
+          token: usdcToken.code,
+          address: usdcDa.address,
+          amount: volume,
+          decimals,
+          side: 'OUT',
+        }],
+        extra_data: {
+          fee_address: solver.solver || '',
+          caller: da.address,
+          deposit_amount: volume,
+          token_mint: usdcToken.code,
+          fee_percent: `${product.fee_percentage || 0}`,
+          zap_in: {
+            pool: poolAddress,
+            slippage: `${product.price_slippage || '0.01'}`,
+            deposit_token_mint: usdcToken.code,
+            user_da: da.address,
+            deposit_amount: volume,
+            tick_upper_price: maxPrice,
+            tick_lower_price: minPrice,
+            token_a: product.token_a.code,
+            token_b: product.token_b.code,
+          },
+        },
+      },
+      gas_payment_token: gasToken ? { chain: gasToken.chain, token: gasToken.code } : undefined,
+    };
+
+    spinner.text = `开仓: ${product.token_a?.symbol}/${product.token_b?.symbol} | ${amount} USDC | 区间 ${minPrice}-${maxPrice}`;
+
+    if (options.verbose) {
+      spinner.stop();
+      console.log(chalk.yellow('\n[VERBOSE] 注册的 DA 地址:'));
+      const { das: regDAs } = await fetchRegisteredDAs(client);
+      Object.entries(regDAs).forEach(([ch, d]) => {
+        console.log(chalk.gray(`  ${ch}: ${d.address} (path: ${d.path})`));
+      });
+      console.log(chalk.yellow('\n[VERBOSE] 本地派生 DA 地址:'));
+      Object.entries(session.das).forEach(([ch, d]) => {
+        console.log(chalk.gray(`  ${ch}: ${d.address}`));
+      });
+      console.log(chalk.yellow('\n[VERBOSE] Intent Order:'));
+      console.log(chalk.gray(JSON.stringify(intentOrder, null, 2)));
+      spinner.start();
+    }
+
+    const tryResp = await intentTryCreate(client, intentOrder);
+
+    spinner.text = '签名交易...';
+    const signResp = await signAndSubmitIntent(client, tryResp, session.mnemonic, session.das);
+
+    spinner.succeed('开仓成功！');
+
+    const txHash = Object.values(signResp?.txHashes || {})[0];
+    const explorerUrl = txHash ? buildExplorerUrl(chain, txHash) : null;
+
+    const resultTable = new Table({ style: { head: [] } });
+    resultTable.push(
+      { '产品': `${product.token_a?.symbol}/${product.token_b?.symbol}` },
+      { '链': chain },
+      { '金额': `${amount} USDC` },
+      { '价格区间': `${minPrice} - ${maxPrice}` },
+      { '当前价格': currentPrice.toFixed(showDecimals) },
+      { 'Intent ID': signResp?.intent?.intent_id || '-' },
+      { '状态': chalk.green('SUCCESS') },
+    );
+    if (txHash) {
+      resultTable.push({ 'TxHash': txHash });
+      resultTable.push({ 'Explorer': chalk.cyan(explorerUrl) });
+    }
+    console.log('\n' + resultTable.toString());
+
+    return signResp;
+  } catch (err) {
+    spinner.fail('开仓失败');
+    console.error(chalk.red(`code: ${err.code}, message: ${err.message}`));
+    if (err.data) console.error(chalk.gray(JSON.stringify(err.data, null, 2)));
+  }
+}
+
+async function cmdPositions(options) {
+  const session = await ensureSession();
+  const client = await getAuthClient(session);
+  const spinner = ora('获取持仓...').start();
+
+  try {
+    const status = options.closed ? 'CLOSED' : 'OPEN';
+    const resp = await fetchPositions(client, status);
+    const positions = resp.positions || [];
+    spinner.stop();
+
+    if (!positions.length) {
+      console.log(chalk.yellow(`暂无${status === 'OPEN' ? '活跃' : '已关闭'}持仓`));
+      return;
+    }
+
+    const table = new Table({
+      head: ['#', 'Pool', 'Position', 'Range', 'Value', 'Yield', 'APY', 'Status'].map(h => chalk.cyan(h)),
+      style: { head: [] },
+    });
+
+    positions.forEach((p, i) => {
+      const baseSymbol = p.token_a?.symbol || '?';
+      const quoteSymbol = p.token_b?.symbol || '?';
+      const poolName = `${baseSymbol}/${quoteSymbol}`;
+      const posAddr = (p.position || '').slice(0, 16) + '...';
+      const range = `${p.tick_lower || '-'} - ${p.tick_upper || '-'}`;
+      const totalYield = p.total_yields || p.total_yield_usd;
+      const value = p.position_value ? `$${parseFloat(p.position_value).toFixed(2)}` : '-';
+      const yield_ = totalYield ? `$${parseFloat(totalYield).toFixed(4)}` : '-';
+      const apy = p.apy ? `${parseFloat(p.apy).toFixed(2)}%` : '-';
+      table.push([i + 1, poolName, posAddr, range, value, yield_, apy, p.status]);
+    });
+
+    console.log(chalk.bold(`\n📈 ${status === 'OPEN' ? '活跃' : '已关闭'}持仓\n`));
+    console.log(table.toString());
+    console.log(chalk.gray(`\n共 ${positions.length} 个持仓`));
+
+    if (status === 'OPEN') {
+      console.log(chalk.gray('\n使用 withdraw --index <序号> 或 withdraw --position <address> 来平仓'));
+    }
+  } catch (err) {
+    spinner.fail('获取持仓失败');
+    console.error(chalk.red(err.message || JSON.stringify(err)));
+  }
+}
+
+async function cmdWithdraw(options) {
+  const session = await ensureSession();
+  const client = await getAuthClient(session);
+
+  let positionAddress = options.position;
+
+  // --index 选择
+  if (!positionAddress && options.index) {
+    const spinner = ora('获取持仓列表...').start();
+    const resp = await fetchPositions(client, 'OPEN');
+    const positions = resp.positions || [];
+    spinner.stop();
+    const idx = parseInt(options.index, 10) - 1;
+    if (idx < 0 || idx >= positions.length) {
+      console.log(chalk.red(`序号 ${options.index} 不存在，共 ${positions.length} 个活跃持仓`));
+      return;
+    }
+    positionAddress = positions[idx].position;
+  }
+
+  // 无参数：交互式选择
+  if (!positionAddress) {
+    const spinner = ora('获取持仓列表...').start();
+    const resp = await fetchPositions(client, 'OPEN');
+    const positions = resp.positions || [];
+    spinner.stop();
+
+    if (!positions.length) {
+      console.log(chalk.yellow('暂无活跃持仓'));
+      return;
+    }
+
+    const { selected } = await inquirer.prompt([{
+      type: 'list',
+      name: 'selected',
+      message: '选择要平仓的持仓:',
+      choices: positions.map((p, i) => {
+        const base = p.token_a?.symbol || '?';
+        const quote = p.token_b?.symbol || '?';
+        const value = p.position_value ? `$${parseFloat(p.position_value).toFixed(2)}` : '-';
+        const apy = p.apy ? `${parseFloat(p.apy).toFixed(2)}%` : '-';
+        return {
+          name: `[${i + 1}] ${base}/${quote}  ${value}  APY ${apy}  ${p.position}`,
+          value: p.position,
+        };
+      }),
+    }]);
+    positionAddress = selected;
+  }
+
+  const spinner = ora('获取持仓详情...').start();
+  try {
+    const detail = await fetchPositionDetail(client, positionAddress);
+    const position = { ...detail, ...(detail.position || {}) };
+
+    if (!position.pool_address) {
+      spinner.fail('未找到该持仓');
+      return;
+    }
+
+    const chain = position.chain_name || position.chain;
+    const solver = session.solverMap[chain] || {};
+    const da = session.das[chain];
+    if (!da) {
+      spinner.fail(`不支持的链: ${chain}`);
+      return;
+    }
+
+    const products = await fetchProducts(client);
+    const product = products.find(p => p.pool_address?.toLowerCase() === position.pool_address?.toLowerCase());
+
+    const usdcCode = product?.token_b?.code || position.token_b?.code;
+    const convertToUsdc = options.convertUsdc !== false;
+    const gasToken = solver.gasToken;
+
+    const intentOrder = {
+      owner: session.da_owner,
+      intent: {
+        chain,
+        type: 'LP_WITHDRAW',
+        gas_payer_address: solver.gas || '',
+        token_out: [],
+        extra_data: {
+          pool: position.pool_address,
+          caller: da.address,
+          convert_to_usdc: convertToUsdc,
+          nft_mint: positionAddress,
+          fee_address: solver.solver || '',
+          fee_percent: `${product?.fee_percentage || 0}`,
+          token_mint: usdcCode,
+          slippage: `${product?.price_slippage || '0.01'}`,
+        },
+      },
+      gas_payment_token: gasToken ? { chain: gasToken.chain, token: gasToken.code } : undefined,
+    };
+
+    spinner.text = '提交 withdraw...';
+    const tryResp = await intentTryCreate(client, intentOrder);
+
+    spinner.text = '签名交易...';
+    const signResp = await signAndSubmitIntent(client, tryResp, session.mnemonic, session.das);
+
+    spinner.succeed('平仓成功！');
+
+    const txHash = Object.values(signResp?.txHashes || {})[0];
+    const explorerUrl = txHash ? buildExplorerUrl(chain, txHash) : null;
+
+    const resultTable = new Table({ style: { head: [] } });
+    resultTable.push(
+      { 'Position': positionAddress.slice(0, 20) + '...' },
+      { 'Pool': position.pool_name || position.pool_address?.slice(0, 20) },
+      { '链': chain },
+      { '转换为USDC': convertToUsdc ? '是' : '否' },
+      { 'Intent ID': signResp?.intent?.intent_id || '-' },
+      { '状态': chalk.green('SUCCESS') },
+    );
+    if (txHash) {
+      resultTable.push({ 'TxHash': txHash });
+      resultTable.push({ 'Explorer': chalk.cyan(explorerUrl) });
+    }
+    console.log('\n' + resultTable.toString());
+
+    return signResp;
+  } catch (err) {
+    spinner.fail('平仓失败');
+    console.error(chalk.red(err.message || JSON.stringify(err)));
+    if (err.data) console.error(chalk.gray(JSON.stringify(err.data, null, 2)));
+  }
+}
+
+// ─── CLI Program ──────────────────────────────────────────────────────────────
+
+const program = new Command();
+
+program
+  .name('degate-cli')
+  .description('DeGate Turbo Range CLI - 开仓/平仓工具')
+  .version('1.0.0');
+
+program
+  .command('setup')
+  .description('交互式初始化：输入私钥，自动派生 DA + 获取 JWT')
+  .action(cmdSetup);
+
+program
+  .command('products')
+  .description('查看 Turbo Range 产品列表')
+  .action(cmdProducts);
+
+program
+  .command('deposit')
+  .description('开仓 (LP_DEPOSIT)')
+  .option('--pool <address>', '产品 pool 地址或 token symbol')
+  .option('--index <num>', '产品编号（从 products 列表获取）')
+  .option('--amount <usdc>', 'USDC 金额')
+  .option('--range <percent>', '快捷区间百分比（如 5 = 当前价格 ±5%）')
+  .option('--min <price>', '最低价格（自定义区间）')
+  .option('--max <price>', '最高价格（自定义区间）')
+  .option('--verbose', '打印完整请求/响应数据')
+  .action(cmdDeposit);
+
+program
+  .command('positions')
+  .description('查看持仓')
+  .option('--closed', '查看已关闭持仓')
+  .action(cmdPositions);
+
+program
+  .command('withdraw')
+  .description('平仓 (LP_WITHDRAW)')
+  .option('--position <address>', '持仓地址 (position address)')
+  .option('--index <num>', '持仓序号（从 positions 列表获取）')
+  .option('--no-convert-usdc', '不转换为 USDC')
+  .action(cmdWithdraw);
+
+program.parse();

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "degate-cli",
+  "version": "1.0.0",
+  "description": "DeGate Turbo Range CLI - deposit/withdraw LP positions across Solana & EVM chains",
+  "main": "cli.js",
+  "bin": {
+    "degate-cli": "./cli.js"
+  },
+  "scripts": {
+    "start": "node cli.js"
+  },
+  "files": [
+    "cli.js",
+    ".env.example",
+    "README.md"
+  ],
+  "keywords": [
+    "degate",
+    "defi",
+    "lp",
+    "solana",
+    "evm",
+    "turbo-range",
+    "cli"
+  ],
+  "author": "coptercc793",
+  "license": "MIT",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "@solana/web3.js": "^1.95.0",
+    "axios": "^1.7.0",
+    "bip39": "^3.1.0",
+    "chalk": "^4.1.2",
+    "cli-table3": "^0.6.5",
+    "commander": "^12.0.0",
+    "dotenv": "^16.4.0",
+    "ed25519-hd-key": "^1.3.0",
+    "ethereumjs-util": "^7.1.5",
+    "ethereumjs-wallet": "^1.0.2",
+    "ethers": "^5.7.2",
+    "inquirer": "^8.2.6",
+    "ora": "^5.4.1",
+    "tweetnacl": "^1.0.3"
+  }
+}