做市商指南¶

import { Wallet, TypedDataDomain, randomBytes } from "ethers";
import { mkdirSync, writeFileSync } from "node:fs";

const API     = "https://api.testnet.sera.cx/api/v1";
const DOMAIN: TypedDataDomain = {
  name: "Sera",
  version: "1",
  chainId: 11155111,                                              // Sepolia
  verifyingContract: "0x83475A1bD98a8DC2DCd507A747e4DC85da241D6e",
};

const PRIVATE_KEY = "0x...你的钱包私钥...";                         // 签名者
const API_KEY     = "sera_...";                                    // 见 身份验证
const API_SECRET  = "...";
const wallet      = new Wallet(PRIVATE_KEY);
const OWNER       = wallet.address;

const AUTH = { "Authorization": `Bearer ${API_KEY}:${API_SECRET}` };

const ORDER_TYPES = {
  Order: [
    { name: "user",                 type: "address" },
    { name: "expiration",           type: "uint48"  },
    { name: "feeBps",               type: "uint48"  },
    { name: "recipient",            type: "address" },
    { name: "fromToken",            type: "address" },
    { name: "toToken",              type: "address" },
    { name: "fromAmount",           type: "uint256" },
    { name: "toAmount",             type: "uint256" },
    { name: "initialDepositAmount", type: "uint256" },
    { name: "uuid",                 type: "uint256" },
  ],
};

const CANCEL_ORDER_TYPES = {
  CancelOrder: [
    { name: "owner",   type: "address" },
    { name: "orderId", type: "uint256" },
  ],
};

const healthResponse = await fetch(`${API}/health`);
if (!healthResponse.ok) throw new Error(`health: ${healthResponse.status}`);
const EXECUTOR_ID = BigInt((await healthResponse.json()).executor_id);

function composeUuid(
  orderId: string,
  executorId: bigint = EXECUTOR_ID,
  legId: bigint = 0n,
  groupUuid: string | null = null,
): bigint {
  const oid  = BigInt("0x" + orderId.replace(/-/g, ""));
  const gsrc = groupUuid ? BigInt("0x" + groupUuid.replace(/-/g, "")) : oid;
  const gid  = gsrc >> 16n;                                       // 128 位中的最高 112 位
  return (executorId << 252n) | (oid << 124n) | (gid << 12n) | legId;
}

function newOrderId(): string {
  const b = randomBytes(16);
  b[6] = (b[6] & 0x0f) | 0x40;                                    // version 4
  b[8] = (b[8] & 0x3f) | 0x80;                                    // RFC 4122 variant
  const h = Buffer.from(b).toString("hex");
  return `${h.slice(0,8)}-${h.slice(8,12)}-${h.slice(12,16)}-${h.slice(16,20)}-${h.slice(20,32)}`;
}

const marketsResponse = await fetch(`${API}/markets`);
if (!marketsResponse.ok) throw new Error(`markets: ${marketsResponse.status}`);
const MARKET = (await marketsResponse.json()).markets.find((m: any) =>
  [m.base_symbol, m.quote_symbol].sort().join("/") === "EURC/USDC");
if (!MARKET) throw new Error("No active USDC/EURC market");
const BASE = { address: MARKET.base_address, decimals: MARKET.base_decimals };
const QUOTE = { address: MARKET.quote_address, decimals: MARKET.quote_decimals };

async function placeOrder(
  side: "bid" | "ask",
  base: { address: string; decimals: number },
  quote: { address: string; decimals: number },
  amount: string,
  price: string,
  expiration: number,
) {
  const orderId  = newOrderId();
  const uuidInt  = composeUuid(orderId);                           // deployment executor ID

  const previewResponse = await fetch(`${API}/orders/preview`, {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({
      owner_address: OWNER, side, amount, price, order_type: "limit",
      from_address: base.address, to_address: quote.address,
      order_id: orderId, uuid_int: uuidInt.toString(), expiration,
    }),
  });
  if (!previewResponse.ok) throw new Error(JSON.stringify(await previewResponse.json()));
  const preview = await previewResponse.json();
  const signature = await wallet.signTypedData(DOMAIN, preview.eip712_types, preview.eip712_order);

  const wire = {
    owner_address: OWNER,
    side, amount: preview.normalized_amount, price: preview.normalized_price, order_type: "limit",
    from_address: base.address,                                    // base，不是 spend
    to_address:   quote.address,                                   // quote，不是 receive
    order_id:     orderId,
    uuid_int:     uuidInt.toString(),
    signature,
    expiration,
  };
  mkdirSync("order-requests", { recursive: true, mode: 0o700 });
  const savedPath = `order-requests/${orderId}.json`;
  writeFileSync(savedPath, JSON.stringify(wire), { flag: "wx", mode: 0o600 });
  console.log(`Saved order request: ${savedPath}`);
  const r = await fetch(`${API}/orders`, {
    method: "POST",
    headers: { ...AUTH, "Content-Type": "application/json" },
    body: JSON.stringify(wire),
  });
  if (r.status !== 201) {
    const detail = (await r.json()).detail;
    throw new Error(`HTTP ${r.status}, order ${orderId}: ${JSON.stringify(detail)}`);
  }
  return { order_id: orderId, uuid_int: uuidInt.toString() };
}

const placed = await placeOrder("bid", BASE, QUOTE, "1000", "1",
                                Math.floor(Date.now() / 1000) + 3600);
console.log("placed:", placed);

async function cancelOrder(orderId: string, uuidInt: bigint): Promise<void> {
  const signature = await wallet.signTypedData(
    DOMAIN, CANCEL_ORDER_TYPES,
    { owner: OWNER, orderId: uuidInt },
  );
  const r = await fetch(`${API}/orders/cancel`, {
    method: "POST",
    headers: { ...AUTH, "Content-Type": "application/json" },
    body: JSON.stringify({
      owner_address: OWNER,
      order_id: orderId,
      uuid_int: uuidInt.toString(),
      signature,
    }),
  });
  if (r.status === 429) throw new Error("撤单冷却中 — 稍后重试");
  if (!r.ok) throw new Error(`撤单失败: ${r.status}`);
}

await cancelOrder(placed.order_id, BigInt(placed.uuid_int));

async function getMid(pair: string): Promise<number> {
  // 接入你自己的报价源 — 内部服务、Bloomberg、Refinitiv、
  // 聚合器 REST API 等等。返回 quote-per-base
  // （例如 EURC/USDC = 1.085）。
  throw new Error("接入你的报价源。");
}

const SPREAD_BPS = 5;                                              // 单侧
const DRIFT_BPS  = 3;
const POLL_MS    = 2_000;
const QTY        = "1000";                                         // 每侧的 base 数量

type Live = { order_id: string; uuid_int: bigint } | null;
let openBid: Live = null, openAsk: Live = null, lastMid: number | null = null;

const sleep = (ms: number) => new Promise(r => setTimeout(r, ms));

while (true) {
  try {
    const mid = await getMid(MARKET.symbol);
    if (lastMid !== null &&
        Math.abs(mid - lastMid) / lastMid * 10_000 <= DRIFT_BPS) {
      await sleep(POLL_MS); continue;
    }

    if (openBid) await cancelOrder(openBid.order_id, openBid.uuid_int);
    if (openAsk) await cancelOrder(openAsk.order_id, openAsk.uuid_int);
    openBid = openAsk = null;

    const half   = SPREAD_BPS / 10_000;
    const bidPx  = (mid * (1 - half)).toFixed(4);
    const askPx  = (mid * (1 + half)).toFixed(4);
    const expiry = Math.floor(Date.now() / 1000) + 3600;

    const pb = await placeOrder("bid", BASE, QUOTE, QTY, bidPx, expiry);
    openBid = { order_id: pb.order_id, uuid_int: BigInt(pb.uuid_int) };
    const pa = await placeOrder("ask", BASE, QUOTE, QTY, askPx, expiry);
    openAsk = { order_id: pa.order_id, uuid_int: BigInt(pa.uuid_int) };
    lastMid = mid;
  } catch (e) {
    console.error("loop paused; reconcile saved orders before restarting:", e);
    break;
  }
  await sleep(POLL_MS);
}

async function placeVlBatch(legs: {
  side: "bid" | "ask";
  base:  { address: string; decimals: number };
  quote: { address: string; decimals: number };
  amount: string;
  price:  string;
  expiration: number;
}[]): Promise<{ order_ids: string[]; [key: string]: unknown }> {
  const leg0Uuid = newOrderId();                                   // group_id 的来源
  const signedLegs: any[] = [];
  for (let i = 0; i < legs.length; i++) {
    const leg = legs[i];
    const orderId  = i === 0 ? leg0Uuid : newOrderId();
    const uuidInt  = composeUuid(orderId, EXECUTOR_ID, BigInt(i), leg0Uuid);

    const previewResponse = await fetch(`${API}/orders/preview`, {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({
        owner_address: OWNER, side: leg.side, amount: leg.amount, price: leg.price,
        order_type: "limit", from_address: leg.base.address, to_address: leg.quote.address,
        order_id: orderId, uuid_int: composeUuid(orderId).toString(), expiration: leg.expiration,
      }),
    });
    if (!previewResponse.ok) throw new Error(JSON.stringify(await previewResponse.json()));
    const preview = await previewResponse.json();
    const orderStruct = { ...preview.eip712_order, uuid: uuidInt.toString() };
    const signature = await wallet.signTypedData(DOMAIN, preview.eip712_types, orderStruct);
    signedLegs.push({
      owner_address: OWNER,
      side: leg.side, amount: preview.normalized_amount, price: preview.normalized_price,
      order_type: "limit",
      from_address: leg.base.address,
      to_address:   leg.quote.address,
      order_id:     orderId,
      uuid_int:     uuidInt.toString(),
      signature, expiration: leg.expiration,
    });
  }

  const wire = { orders: signedLegs };
  mkdirSync("vl-requests", { recursive: true, mode: 0o700 });
  const savedPath = `vl-requests/${leg0Uuid}.json`;
  writeFileSync(savedPath, JSON.stringify(wire), { flag: "wx", mode: 0o600 });
  console.log(`Saved VL request: ${savedPath}`);
  const r = await fetch(`${API}/orders/vl/batch`, {
    method: "POST",
    headers: { ...AUTH, "Content-Type": "application/json" },
    body: JSON.stringify(wire),
  });
  if (!r.ok) throw new Error(`VL batch failed: ${r.status}`);
  const body = await r.json();
  return body;
}