/**

 * ethers.js v6：Provider 读取 + Signer 写入

 */

import { ethers } from "ethers"; // 概念性展示，不依赖任何库

// 1. Provider：连接以太坊（只读）

const infuraUrl = "https://mainnet.infura.io/v3/YOUR_KEY";

const provider = new ethers.JsonRpcProvider(infuraUrl);

// 读取

const balance = await provider.getBalance("0xd8dA...");

const blockNumber = await provider.getBlockNumber();

// 2. Signer：签名交易（需要私钥或钱包）

const privateKey = "0x...";

const signer = new ethers.Wallet(privateKey, provider);

// 写入：转账 0.1 ETH

const tx = await signer.sendTransaction({

  to: "0xRecipient...",

  value: ethers.parseEther("0.1"), // 100000000000000000n

});

const receipt = await tx.wait(); // 等待确认

// 3. 合约交互：自动编码 ABI

const erc20ABI = [

  "function balanceOf(address) view returns (uint256)",

  "function transfer(address,uint256) returns (bool)",

  "event Transfer(address,address,uint256)",

];

const token = new ethers.Contract(tokenAddress, erc20ABI, signer);

const myBalance = await token.balanceOf(signer.address);

const tx2 = await token.transfer("0xFriend...", 1000n);

/**

 * Viem：现代前端与链交互的范式

 * 核心概念：Client = Provider + 可选的 Wallet（Account）

 */

// 纯 TypeScript 模拟，展示 Viem 的设计哲学

// 1. 创建可读的公共 client（无需钱包）

interface PublicClient {

  chain: { id: number; name: string };

  transport: { url: string };

  async getBalance(address: string): Promise<bigint>;

  async getBlockNumber(): Promise<bigint>;

  async readContract(params: any): Promise<any>;

  async getGasPrice(): Promise<bigint>;

}

// 2. 创建可写的 wallet client（需要 Account）

interface WalletClient {

  account: { address: string; privateKey?: string };

  chain: { id: number };

  async sendTransaction(params: any): Promise<string>;

  async writeContract(params: any): Promise<string>;

  async signMessage(message: string): Promise<string>;

}

// 设计差异对比

function compareEthersVsViem() {

  // ethers.js: 一个 Contract 对象，内部持有 provider/signer

  // 所有操作都通过 Contract 对象，方便但类型松散

  

  // Viem: 分离到函数级，每个操作独立调用

  // 读合约：readContract({ address, abi, functionName, args })

  // 写合约：writeContract({ ... })

  // 纯粹函数式，更容易 tree-shake 和类型推断

  

  return "Viem wins on: size(21KB), strict types, no class state, explicit function calls";

}

// Viem 风格的合约交互（TypeScript 模拟）

async function viemStyleRead(

  client: PublicClient,

  tokenAddress: string,

  userAddress: string,

): Promise<bigint> {

  return client.readContract({

    address: tokenAddress as `0x${string}`,

    abi: [

      {

        name: "balanceOf",

        type: "function",

        stateMutability: "view",

        inputs: [{ name: "account", type: "address" }],

        outputs: [{ type: "uint256" }],

      },

    ],

    functionName: "balanceOf",

    args: [userAddress],

  });

}

// 对比：读合约（不涉及状态变更）vs 写合约（需要签名）

// 在 Viem 中，这是两个完全独立的函数调用，<FunctionName> 是类型 infer 的

// 错误：如果写合约时用了 readContract，TypeScript 编译期就捕获

console.log(compareEthersVsViem());

/**

 * 钱包连接的 TypeScript 模拟

 * 展示 EIP-1102, EIP-6963 和现代连接模式

 */

// === 阶段 1: 传统注入（EIP-1102）

interface WindowEthereum {

  async request(args: { method: string; params?: any }): Promise<any>;

  on(event: string, handler: (args: any) => void): void;

  removeListener(event: string, handler: any): void;

  selectedAddress: string | null;

  isMetaMask?: boolean;

}

async function legacyConnect(): Promise<string[]> {

  // 检查 window.ethereum（已被覆盖风险）

  const eth = (window as any).ethereum as WindowEthereum;

  if (!eth) throw new Error("No wallet installed");

  

  // EIP-1102: 请求用户授权连接

  const accounts = await eth.request({

    method: "eth_requestAccounts",

    params: [],

  });

  // 返回已授权地址列表

  return accounts; // ["0x...", ...]

}

// === 阶段 2: EIP-6963 多钱包发现

interface EIP6963Provider {

  info: {

    uuid: string;           // 唯一标识

    name: string;           // 钱包名称

    icon: string;           // base64 icon

    rdns: string;           // 反向域名（如 com.metamask）

  };

  provider: WindowEthereum; // 实际 EIP-1193 provider

}

class WalletDiscovery {

  private providers: Map<string, EIP6963Provider> = new Map();

  

  discover(): Promise<EIP6963Provider[]> {

    return new Promise((resolve) => {

      const providers: EIP6963Provider[] = [];

      

      // 监听 announce 事件

      const onAnnounce = (event: any) => {

        const detail: EIP6963Provider = event.detail;

        if (!this.providers.has(detail.info.uuid)) {

          this.providers.set(detail.info.uuid, detail);

          providers.push(detail);

        }

      };

      

      window.addEventListener("eip6963:announceProvider", onAnnounce);

      

      // 主动请求所有钱包重新 announce

      setTimeout(() => {

        window.dispatchEvent(new Event("eip6963:requestProvider"));

      }, 100);

      

      // 3 秒后返回收集到的钱包

      setTimeout(() => {

        window.removeEventListener("eip6963:announceProvider", onAnnounce);

        resolve(providers);

      }, 3000);

    });

  }

  

  async connectByUUID(uuid: string): Promise<string[]> {

    const p = this.providers.get(uuid);

    if (!p) throw new Error("Wallet not discovered");

    return p.provider.request({ method: "eth_requestAccounts", params: [] });

  }

}

// 示例使用

async function multiWalletDemo() {

  const discovery = new WalletDiscovery();

  const wallets = await discovery.discover();

  console.log("发现钱包:", wallets.map(w => w.info.name));

  

  // 用户选择后连接

  const mm = wallets.find(w => w.info.rdns === "io.metamask");

  if (mm) {

    const accounts = await mm.provider.request({ method: "eth_requestAccounts" });

    console.log("MetaMask 地址:", accounts[0]);

  }

}

console.log("钱包发现机制已定义");

/**

 * 账户抽象（ERC-4337）核心：用户的"账户"是一个智能合约

 */

interface SmartWallet {

  // 传统 EOA：address = keccak256(publicKey)[12:]

  // 4337 智能账户：address = CREATE2 部署的合约地址

  

  address: string;

  

  // 入口点合约（所有 4337 交易都通过它）

  entryPoint: "0x5FF137D4b0FDCD49DcA30c7CF57E578a026d2789";

  

  // 验证逻辑可以是：签名、M-of-N 多签、社交恢复、Session Key...

  async validateUserOp(userOp: UserOperation): Promise<ValidationData>;

}

interface UserOperation {

  sender: string;           // 4337 智能账户地址

  nonce: bigint;

  initCode?: string;        // 首次部署账户的字节码

  callData: string;         // 实际调用

  signature: string;        // 签名（不验证 sender 地址，验证自定义逻辑）

  paymaster?: string;       // 可选的代付方

}

function calculate4337Address(

  factory: string,

  salt: bigint,

  initCodeHash: string,

): string {

  // 与 CREATE2 相同公式

  return "0x" + BigInt(

    "0x" + keccak256("0xFF" + factory + salt.toString(16).padStart(64, '0') + initCodeHash)

  ).toString(16).slice(-40).padStart(40, '0');

}

// 关键优势：

// 1. 用户无需知道"私钥"——可以邮箱+验证码控制账户

// 2. 批量交易（一次签名，10 次操作）

// 3. 社交恢复（3 个朋友 = 恢复账户）

// 4. 免 gas 支付（paymaster 代付）

console.log("ERC-4337 智能钱包：签名 = 任何可验证逻辑，不限于 secp256k1");

/**

 * Gas 价格估算与交易构造

 */

interface TransactionRequest {

  to: string;

  data: string;

  value: bigint;

  maxFeePerGas: bigint;

  maxPriorityFeePerGas: bigint;

  gasLimit: bigint;

  nonce: number;

  chainId: number;

}

class GasEstimator {

  // EIP-1559 的 baseFee 由网络根据区块容量动态调整：

  // target = 15M gas/block（上限 30M）

  // 如果区块超过 target，baseFee 增加最多 12.5%

  // 如果低于，baseFee 减少最多 12.5%

  

  async estimate1559Fees(blockUtilization: number): Promise<{[key: string]: bigint}> {

    const currentBaseFee = 20n * 10n**9n; // 20 gwei (示例)

    const target = 0.5; // 50% 利用率 = 稳定

    

    // baseFee 变化公式 (简化)

    let newBaseFee: bigint;

    if (blockUtilization > 0.5) {

      // 拥堵：baseFee 增加

      const increase = 1n + BigInt(Math.floor((blockUtilization - 0.5) * 1000));

      newBaseFee = currentBaseFee * increase / 1000n;

    } else {

      // 空闲：baseFee 减少

      const decrease = 1n - BigInt(Math.floor((0.5 - blockUtilization) * 1000));

      newBaseFee = currentBaseFee * decrease / 1000n;

    }

    

    const priorityFee = 2n * 10n**9n; // 2 gwei 小费

    const maxFee = newBaseFee * 2n + priorityFee; // 余量

    

    return {

      baseFee: newBaseFee,

      maxPriorityFeePerGas: priorityFee,

      maxFeePerGas: maxFee,

    };

  }

  

  // gas 限制估算（调用节点的 gasEstimate 模拟执行）

  async estimateGasLimit(tx: Partial<TransactionRequest>): Promise<bigint> {

    // 模拟：简单 ETH 转账 21,000 gas

    if (!tx.data || tx.data === '0x') return 21000n;

    // 合约调用：通常 50K-500K 不等

    return 150000n; // 示例

  }

}

// 自动构造交易

async function buildTransaction(args: {

  to: string;

  value?: bigint;

  data?: string;

  priority?: 'low' | 'normal' | 'high';

}): Promise<TransactionRequest> {

  const estimator = new GasEstimator();

  const fees = await estimator.estimate1559Fees(0.7); // 70% 利用率 = 轻度拥堵

  const gasLimit = await estimator.estimateGasLimit(args);

  

  // 根据 priority 调整小费

  const multiplier = { low: 0.8, normal: 1.0, high: 2.0 }[args.priority || 'normal'];

  

  return {

    to: args.to,

    data: args.data || '0x',

    value: args.value || 0n,

    maxFeePerGas: fees.maxFeePerGas * BigInt(Math.floor(multiplier * 100)) / 100n,

    maxPriorityFeePerGas: fees.maxPriorityFeePerGas * BigInt(Math.floor(multiplier * 100)) / 100n,

    gasLimit,

    nonce: 42, // 实际需要 eth_getTransactionCount

    chainId: 1,

  };

}

console.log("Gas 估算器已定义");

/**

 * 交易状态追踪 + 乐观更新

 */

type TxStatus = "initiated" | "pending" | "success" | "reverted" | "dropped";

interface TransactionState {

  hash: string;

  status: TxStatus;

  confirmations: number;

  receipt?: {

    gasUsed: bigint;

    logs: any[];

    status: string; // "0x1" = success, "0x0" = revert

  };

}

class TransactionTracker {

  private transactions: Map<string, TransactionState> = new Map();

  private listeners: Set<(txs: TransactionState[]) => void> = new Set();

  

  // 乐观更新：前端先假设成功

  async optimisticallySend(

    sendFn: () => Promise<string>,  // 返回 txHash

    preview: () => void,            // 先更新 UI

  ): Promise<string> {

    preview(); // 立即更新UI（乐观）

    const hash = await sendFn();   // 但实际还要等待链上确认

    

    this.transactions.set(hash, {

      hash,

      status: "pending",

      confirmations: 0,

    });

    

    this.pollForConfirmation(hash);

    return hash;

  }

  

  private async pollForConfirmation(hash: string) {

    for (let i = 0; i < 60; i++) { // 最多等 5 分钟

      await new Promise(r => setTimeout(r, 5000));

      

      try {

        const receipt = await this.fetchReceipt(hash);

        if (receipt) {

          const status: TxStatus = receipt.status === "0x1" ? "success" : "reverted";

          this.transactions.set(hash, {

            hash,

            status,

            confirmations: 1, // 后续可增加

            receipt,

          });

          this.notifyListeners();

          

          if (status === "reverted") {

            // 回滚乐观更新

            this.rollbackPreview(hash);

          }

          return;

        }

      } catch {

        // 继续轮询

      }

    }

    

    // 超时：标记为 dropped

    this.transactions.set(hash, { hash, status: "dropped", confirmations: 0 });

  }

  

  private fetchReceipt(hash: string): Promise<any> {

    // 实际调用 eth_getTransactionReceipt

    return Promise.resolve({ gasUsed: 145000n, logs: [], status: "0x1" });

  }

  

  private rollbackPreview(hash: string) {

    console.log("Transaction reverted, rolling back UI:", hash);

  }

  

  private notifyListeners() {

    const txs = Array.from(this.transactions.values());

    for (const cb of this.listeners) cb(txs);

  }

  

  subscribe(cb: (txs: TransactionState[]) => void) {

    this.listeners.add(cb);

    return () => this.listeners.delete(cb);

  }

}

// React 风格的自定义 hook（概念性展示）

function useSendTransaction() {

  const [status, setStatus] = React.useState<TxStatus>("initiated");

  

  async function send(tx: TransactionRequest) {

    setStatus("pending");

    try {

      // 实际签名广播

      const hash = "0x...";

      setStatus("success");

      return hash;

    } catch (e) {

      setStatus("dropped");

      throw e;

    }

  }

  

  return { send, status };

}

/**

 * 事件驱动的状态同步模式

 */

interface EthersContract {

  on(event: string, handler: (...args: any[]) => void): void;

  removeAllListeners(event?: string): void;

  queryFilter(event: string, fromBlock: number, toBlock: number): Promise<any[]>;

}

class EventSyncManager {

  private contract: EthersContract;

  private lastBlock: number = 0;

  private handlers: Map<string, Function[]> = new Map();

  private active: boolean = true;

  

  constructor(contract: EthersContract) {

    this.contract = contract;

  }

  

  // 实时事件监听器

  subscribe(eventName: string, handler: (event: any) => void) {

    this.contract.on(eventName, (...args) => {

      if (!this.active) return;

      const parsed = this.parseEvent(eventName, args);

      handler(parsed);

    });

    

    // 必须清理：避免内存泄漏

    return () => this.contract.removeAllListeners(eventName);

  }

  

  // 历史回溯（当用户首次打开页面时）

  async backfill(eventName: string, fromBlock: number): Promise<any[]> {

    const events = await this.contract.queryFilter(eventName, fromBlock, 'latest');

    return events.map(e => this.parseEvent(eventName, e.args));

  }

  

  // 组合：先回溯历史 + 再监听新事件

  async sync(eventName: string, fromBlock: number, handler: (e: any) => void) {

    const historical = await this.backfill(eventName, fromBlock);

    for (const e of historical) handler(e);

    

    const cleanup = this.subscribe(eventName, handler);

    return cleanup;

  }

  

  private parseEvent(name: string, rawArgs: any[]): any {

    return { name, args: rawArgs, timestamp: Date.now() };

  }

  

  // 组件卸载时清理！

  destroy() {

    this.active = false;

    this.contract.removeAllListeners();

  }

}

// React 键实践

function useContractSync(contract: EthersContract, eventName: string) {

  const [events, setEvents] = React.useState<any[]>([]);

  const manager = new EventSyncManager(contract);

  

  React.useEffect(() => {

    // 清理函数：组件卸载时取消所有监听

    return manager.sync(eventName, 0, (e: any) => {

      setEvents(prev => [...prev, e]);

    });

  }, [contract, eventName]);

  

  return events;

}

/**

 * GraphQL 查询：获取聚合数据而不手动同步

 */

interface SubgraphQuery {

  // 查询 Aave 的所有借贷池活动和 TVL

  query: string;

  endpoint: string; // 如 https://api.thegraph.com/subgraphs/name/aave/protocol-v3

}

// 比手动解析事件更强大的查询能力

const AAVE_OVERVIEW_QUERY = `

  {

    reserves(first: 10, orderBy: totalATokenSupply, orderDirection: desc) {

      id

      name

      symbol

      decimals

      totalATokenSupply

      totalBorrowed

      liquidityRate

      variableBorrowRate

    }

  }

`;

// 对比：

// 手动监听 Pool.Borrow 事件 → 需要在前端做聚合和

// GraphQL 查询 → 索引器已做好聚合，前端直接消费

// 劣势：The Graph 的索引有 5-30s 延迟，不是实时的

/**

 * IPFS 的内容寻址（简化模拟）

 */

function sha256(data: string): string {

  // 简化哈希演示

  let h = 0;

  for (let i = 0; i < data.length; i++) {

    h = ((h << 5) - h + data.charCodeAt(i)) | 0;

  }

  return h.toString(16).padStart(64, '0');

}

function computeCID(data: string): string {

  const hash = sha256(data);

  // IPFS 使用 CIDv1 多格式编码：

  // 0x12 = sha2-256, 0x20 = 32 字节, 0x01 = CIDv1, 0x55 = raw

  return "bafybei" + hash.slice(0, 44); // 简化 base32 前缀

}

// 关键特性：相同数据 => 相同 CID

const cid1 = computeCID("Hello World");

const cid2 = computeCID("Hello World");

console.log("CID 匹配:", cid1 === cid2, cid1);

// 即使文件名不同，内容一样，CID 也一样

const cid3 = computeCID("Hello World");

console.log("内容相同 CID 相同:", cid1 === cid3);

/**

 * IPFS 上传（前端概念模拟）

 */

interface IPFSPinataResponse {

  IpfsHash: string;     // CID

  PinSize: number;      // 字节数

  Timestamp: string;

}

async function uploadToIPFS(

  apiKey: string,

  secret: string,

  file: File,

): Promise<string> {

  const formData = new FormData();

  formData.append("file", file);

  

  // Pinata 的 pinning 服务

  const res = await fetch("https://api.pinata.cloud/pinning/pinFileToIPFS", {

    method: "POST",

    headers: {

      Authorization: `Bearer ${await signJWT(apiKey, secret)}`,

    },

    body: formData,

  });

  

  const data: IPFSPinataResponse = await res.json();

  // 返回的 CID 就是 URI: ipfs://{IpfsHash}

  return `ipfs://${data.IpfsHash}`;

}

// 选择 Gateway

function resolveIPFSUri(uri: string): string {

  if (uri.startsWith("ipfs://")) {

    const cid = uri.replace("ipfs://", "");

    // 选择可靠的 Gateway

    return `https://cloudflare-ipfs.com/ipfs/${cid}`;

    // 备选: https://ipfs.io/ipfs/${cid}

    // 备选: https://gateway.pinata.cloud/ipfs/${cid}

  }

  return uri;

}

function signJWT(_apiKey: string, _secret: string): Promise<string> {

  return Promise.resolve("mock-jwt-token");

}

console.log("IPFS URI 示例:", resolveIPFSUri("ipfs://Qmdemo.../metadata.json"));

/**

 * Arweave 上传（概念模拟）

 */

interface ArweaveTransaction {

  id: string;            // 交易 ID 同时作为访问地址

  data: string;          // 文件内容（base64）

  tags: { name: string; value: string }[]; // 元数据标签

  reward: bigint;        // 存储费用

  signature?: string;

}

async function uploadToArweave(

  fileContent: string,

  fileType: string,

): Promise<string> {

  const arweave = {

    // ANS-110 标准标签

    tags: [

      { name: "Content-Type", value: fileType },

      { name: "App-Name", value: "MyDApp" },

      { name: "App-Version", value: "1.0.0" },

    ],

    // 费用 = 数据大小 × 当前 AR 价格 × 永久存储成本模型

    async getPrice(dataSize: number): Promise<bigint> {

      return BigInt(dataSize) * 10000n; // 简化

    },

  };

  

  const price = await arweave.getPrice(fileContent.length);

  console.log(`Storage cost: ${price} winston (${Number(price) / 1e12} AR)`);

  

  // 签名并提交到 Arweave 网络

  const txId = "abc123...";

  return `https://arweave.net/${txId}`; // 永久可访问

}

// NFT 元数据标准：指向 Arweave 永久 URI

const artMetadata = {

  name: "Digital Art #1",

  description: "...",

  image: "https://arweave.net/txId_of_image",  // 永久图片

  animation_url: "https://arweave.net/txId_of_glb", // 永久 3D 模型

};

console.log("Arweave: 存一次，永远可用");

/**

 * 多链配置管理（TypeScript 骨架）

 */

interface ChainConfig {

  id: number;

  name: string;

  rpcUrl: string;

  currency: { name: string; symbol: string; decimals: number };

  explorer: string;

  contracts: { [name: string]: string }; // 已部署合约地址映射

  isTestnet: boolean;

}

const chains: Record<string, ChainConfig> = {

  mainnet: {

    id: 1,

    name: "Ethereum",

    rpcUrl: "https://eth-mainnet.g.alchemy.com/v2/...",

    currency: { name: "Ether", symbol: "ETH", decimals: 18 },

    explorer: "https://etherscan.io",

    contracts: {

      token: "0x6B1754...", // DAI on mainnet

      aavePool: "0x87870B...",

    },

    isTestnet: false,

  },

  arbitrum: {

    id: 42161,

    name: "Arbitrum One",

    rpcUrl: "https://arb-mainnet.g.alchemy.com/v2/...",

    currency: { name: "Ether", symbol: "ETH", decimals: 18 },

    explorer: "https://arbiscan.io",

    contracts: {

      token: "0xDA1000...", // DAI on Arbitrum

      aavePool: "0x794a61...",

    },

    isTestnet: false,

  },

  base: {

    id: 8453,

    name: "Base",

    rpcUrl: "https://base-mainnet.g.alchemy.com/v2/...",

    currency: { name: "Ether", symbol: "ETH", decimals: 18 },

    explorer: "https://basescan.org",

    contracts: {

      token: "0x50c572...", // DAI on Base

    },

    isTestnet: false,

  },

  sepolia: {

    id: 11155111,

    name: "Sepolia",

    rpcUrl: "https://eth-sepolia.g.alchemy.com/v2/...",

    currency: { name: "SepoliaETH", symbol: "ETH", decimals: 18 },

    explorer: "https://sepolia.etherscan.io",

    contracts: {

      token: "0x123abc...",

    },

    isTestnet: true,

  },

};

// 切换链

async function switchChain(targetChainId: number, wallet: any) {

  try {

    await wallet.request({

      method: "wallet_switchEthereumChain",

      params: [{ chainId: "0x" + targetChainId.toString(16) }], // 0x1, 0xa4b1 (42161)

    });

  } catch (error: any) {

    // 如果链未安装，需要先添加

    if (error.code === 4902) {

      const chain = Object.values(chains).find(c => c.id === targetChainId);

      await wallet.request({

        method: "wallet_addEthereumChain",

        params: [{

          chainId: "0x" + targetChainId.toString(16),

          chainName: chain?.name,

          rpcUrls: [chain?.rpcUrl],

          nativeCurrency: chain?.currency,

          blockExplorerUrls: [chain?.explorer],

        }],

      });

    }

  }

}

console.log("多链配置已定义");

/**

 * 跨链交易状态追踪

 */

interface CrossChainTx {

  id: string;

  sourceChain: number;    // 源链 ID

  targetChain: number;    // 目标链 ID

  status: "sending" | "waiting_attestation" | "delivered" | "completed" | "failed";

  sourceTxHash: string;   // 源链交易哈希

  targetTxHash?: string;  // 目标链执行哈希（有延迟）

  estimatedTime: number;  // 秒

  progress: number;       // 0-100%

}

class CrossChainTracker {

  private txs: Map<string, CrossChainTx> = new Map();

  private listeners = new Set<(tx: CrossChainTx) => void>();

  

  // 用户发起桥接

  async initiateBridge(from: number, to: number, amount: bigint, token: string): Promise<string> {

    const txId = crypto.randomUUID(); // 简化 ID

    

    this.txs.set(txId, {

      id: txId,

      sourceChain: from,

      targetChain: to,

      status: "sending",

      sourceTxHash: "",

      estimatedTime: 120, // 2 分钟估计

      progress: 0,

    });

    

    // 简化流程模拟

    setTimeout(() => this.updateStatus(txId, "waiting_attestation", 10), 2000);

    setTimeout(() => this.updateStatus(txId, "delivered", 80), 60000);

    setTimeout(() => this.updateStatus(txId, "completed", 100), 120000);

    

    return txId;

  }

  

  private updateStatus(id: string, status: CrossChainTx["status"], progress: number) {

    const tx = this.txs.get(id);

    if (!tx) return;

    tx.status = status;

    tx.progress = progress;

    for (const cb of this.listeners) cb({ ...tx });

  }

  

  subscribe(txId: string, cb: (tx: CrossChainTx) => void) {

    this.listeners.add(cb);

    return () => this.listeners.delete(cb);

  }

  

  getStatusText(tx: CrossChainTx): string {

    const map: Record<string, string> = {

      sending: "正在发送源链交易...",

      waiting_attestation: "等待目标链验证...",

      delivered: "已到达目标链，确认中...",

      completed: "✅ 完成！",

      failed: "❌ 失败",

    };

    return map[tx.status];

  }

}

// LayerZero SDK 风格的调用层

interface LZSendParam {

  dstEid: number;           // 目标端点 ID (Endpoint ID)

  to: string;               // 目标地址

  amount: bigint;

  minAmount: bigint;        // 防止滑点

  extraOptions: string;     // 额外选项（gas 空投等）

  composeMsg: string;       // 可携带额外消息

  oftCmd: string;           // 命令

}

// 现代跨链桥 SDK 简化高层调用：

// send(srcChain, dstChain, token, amount, recipient)

// 抽象掉 Wormhole VAA / LayerZero 消息包 / 中继器验证 等底层

console.log("跨链架构：锁定-证明-铸造/释放");