@continuumdao/ctm-mpc-defi 0.2.24 → 0.2.26

package/dist/protocols/evm/arcus/index.js

@@ -0,0 +1,1970 @@
+import { parseAbi, getAddress, createPublicClient, http, erc20Abi, hashMessage, encodeFunctionData, defineChain, parseGwei, serializeTransaction, keccak256, hashTypedData, stringToHex } from 'viem';
+import { createHash } from 'crypto';
+import { getClientIdFromKeyGenResult, fetchChainFeeParams, gasLimitFromEstimateAndChainConfig, gweiToDecimalString, proposalTxParamsToFeeSnapshot, alignEip1559FeesWithLatestBase } from '@continuumdao/continuum-node-sdk';
+
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/protocols/evm/arcus/support.ts
+var support_exports = {};
+__export(support_exports, {
+  ARCUS_SUPPORTED_CHAIN_IDS: () => ARCUS_SUPPORTED_CHAIN_IDS,
+  arcusApiMetaBaseUrl: () => arcusApiMetaBaseUrl,
+  arcusPerpApiBaseUrl: () => arcusPerpApiBaseUrl,
+  arcusSpotIndexerBaseUrl: () => arcusSpotIndexerBaseUrl,
+  isArcusChainSupported: () => isArcusChainSupported
+});
+function isArcusChainSupported(chainId) {
+  return ARCUS_SUPPORTED_CHAIN_IDS.includes(chainId);
+}
+function arcusPerpApiBaseUrl(_chainId) {
+  return "https://api.arcus.xyz";
+}
+function arcusSpotIndexerBaseUrl(_chainId) {
+  return "https://indexer.spot.arcus.xyz";
+}
+function arcusApiMetaBaseUrl(_chainId) {
+  return "https://api.arcus.xyz/v1/api-meta";
+}
+var ARCUS_SUPPORTED_CHAIN_IDS;
+var init_support = __esm({
+  "src/protocols/evm/arcus/support.ts"() {
+    ARCUS_SUPPORTED_CHAIN_IDS = [4663];
+  }
+});
+
+// src/protocols/evm/arcus/constants.ts
+var ARCUS_PROTOCOL_ID, ARCUS_DEFAULT_OHLCV_INTERVAL, ARCUS_DEFAULT_LOOKBACK_DAYS, ARCUS_MAX_CANDLE_COUNT, ARCUS_DEFAULT_CANDLE_COUNT, ARCUS_PERP_OHLCV_INTERVALS, ARCUS_SPOT_OHLCV_INTERVALS, ARCUS_PERP_INTERVAL_MS, ARCUS_SPOT_INTERVAL_SEC, ARCUS_USDG_ADDRESS_4663;
+var init_constants = __esm({
+  "src/protocols/evm/arcus/constants.ts"() {
+    ARCUS_PROTOCOL_ID = "arcus";
+    ARCUS_DEFAULT_OHLCV_INTERVAL = "1h";
+    ARCUS_DEFAULT_LOOKBACK_DAYS = 14;
+    ARCUS_MAX_CANDLE_COUNT = 1500;
+    ARCUS_DEFAULT_CANDLE_COUNT = 200;
+    ARCUS_PERP_OHLCV_INTERVALS = [
+      "1m",
+      "3m",
+      "5m",
+      "15m",
+      "30m",
+      "1h",
+      "2h",
+      "4h",
+      "8h",
+      "12h",
+      "1d",
+      "3d",
+      "1w"
+    ];
+    ARCUS_SPOT_OHLCV_INTERVALS = ["1m", "5m", "15m", "1h", "1d"];
+    ARCUS_PERP_INTERVAL_MS = {
+      "1m": 6e4,
+      "3m": 18e4,
+      "5m": 3e5,
+      "15m": 9e5,
+      "30m": 18e5,
+      "1h": 36e5,
+      "2h": 72e5,
+      "4h": 144e5,
+      "8h": 288e5,
+      "12h": 432e5,
+      "1d": 864e5,
+      "3d": 2592e5,
+      "1w": 6048e5
+    };
+    ARCUS_SPOT_INTERVAL_SEC = {
+      "1m": 60,
+      "5m": 300,
+      "15m": 900,
+      "1h": 3600,
+      "1d": 86400
+    };
+    ARCUS_USDG_ADDRESS_4663 = "0x5fc5360D0400a0Fd4f2af552ADD042D716F1d168";
+  }
+});
+
+// src/protocols/evm/arcus/api.ts
+var api_exports = {};
+__export(api_exports, {
+  arcusFetchAccount: () => arcusFetchAccount,
+  arcusFetchAccountLeverages: () => arcusFetchAccountLeverages,
+  arcusFetchAllMids: () => arcusFetchAllMids,
+  arcusFetchApiKeys: () => arcusFetchApiKeys,
+  arcusFetchOpenOrders: () => arcusFetchOpenOrders,
+  arcusFetchPerpCandles: () => arcusFetchPerpCandles,
+  arcusFetchPerpMarkets: () => arcusFetchPerpMarkets,
+  arcusFetchPerpOhlcvRange: () => arcusFetchPerpOhlcvRange,
+  arcusFetchPositions: () => arcusFetchPositions,
+  arcusFetchSpotOhlcvRange: () => arcusFetchSpotOhlcvRange,
+  arcusFetchSpotOverview: () => arcusFetchSpotOverview,
+  arcusFetchSpotTokenCandles: () => arcusFetchSpotTokenCandles,
+  arcusMapPerpCandles: () => arcusMapPerpCandles,
+  arcusMapSpotCandles: () => arcusMapSpotCandles,
+  arcusResolvePerpOhlcvWindow: () => arcusResolvePerpOhlcvWindow
+});
+async function arcusJsonGet(url) {
+  const res = await fetch(url, { headers: { Accept: "application/json" } });
+  const text = await res.text();
+  let body = null;
+  if (text.trim()) {
+    try {
+      body = JSON.parse(text);
+    } catch {
+      throw new Error(`Arcus API returned non-JSON (${res.status}): ${text.slice(0, 200)}`);
+    }
+  }
+  if (!res.ok) {
+    const err = body && typeof body === "object" && body !== null && "error" in body ? String(body.error) : text.slice(0, 200);
+    throw new Error(`Arcus API ${res.status}: ${err}`);
+  }
+  return body;
+}
+function arcusMapPerpCandles(raw) {
+  return (raw ?? []).map((c) => ({
+    timestampMs: Math.floor(c.openTime / 1e3),
+    open: c.open,
+    high: c.high,
+    low: c.low,
+    close: c.close,
+    volume: c.volume ?? "0",
+    ...c.isFinal != null ? { isFinal: c.isFinal } : {}
+  }));
+}
+async function arcusFetchPerpMarkets(args) {
+  const base = arcusPerpApiBaseUrl(args.chainId);
+  const data = await arcusJsonGet(`${base}/v1/markets`);
+  return { markets: data.markets ?? [] };
+}
+async function arcusFetchPerpCandles(args) {
+  const base = arcusPerpApiBaseUrl(args.chainId);
+  const toMicros = args.toMicros ?? Date.now() * 1e3;
+  const countback = Math.min(args.countback ?? ARCUS_DEFAULT_CANDLE_COUNT, ARCUS_MAX_CANDLE_COUNT);
+  const params = new URLSearchParams({
+    market: args.market.trim(),
+    timeframe: args.timeframe,
+    to: String(toMicros),
+    countback: String(countback)
+  });
+  if (args.fromMicros != null) {
+    params.delete("countback");
+    params.set("from", String(args.fromMicros));
+  }
+  const data = await arcusJsonGet(`${base}/v1/candles?${params}`);
+  return { candles: arcusMapPerpCandles(data.candles) };
+}
+function arcusResolvePerpOhlcvWindow(args) {
+  const endTimeMs = args.endTimeMs ?? Date.now();
+  const intervalMs = ARCUS_PERP_INTERVAL_MS[args.interval] ?? ARCUS_PERP_INTERVAL_MS["15m"];
+  let startTimeMs;
+  if (args.startTimeMs != null) {
+    startTimeMs = args.startTimeMs;
+  } else if (args.lookbackHours != null && args.lookbackHours > 0) {
+    startTimeMs = endTimeMs - args.lookbackHours * 36e5;
+  } else {
+    const days = args.lookbackDays ?? 14;
+    startTimeMs = endTimeMs - days * 864e5;
+  }
+  const spanBars = Math.ceil((endTimeMs - startTimeMs) / intervalMs) + 1;
+  const countback = Math.min(
+    args.candleCount ?? spanBars,
+    ARCUS_MAX_CANDLE_COUNT
+  );
+  return { startTimeMs, endTimeMs, countback };
+}
+async function arcusFetchPerpOhlcvRange(args) {
+  const interval = args.interval ?? ARCUS_DEFAULT_OHLCV_INTERVAL;
+  const window = arcusResolvePerpOhlcvWindow({ ...args, interval });
+  const { candles } = await arcusFetchPerpCandles({
+    chainId: args.chainId,
+    market: args.market,
+    timeframe: interval,
+    toMicros: window.endTimeMs * 1e3,
+    fromMicros: args.startTimeMs != null ? window.startTimeMs * 1e3 : void 0,
+    countback: window.countback
+  });
+  const sorted = [...candles].sort((a, b) => a.timestampMs - b.timestampMs);
+  return {
+    market: args.market.trim(),
+    interval,
+    marketKind: "perp",
+    startTimeMs: sorted[0]?.timestampMs ?? window.startTimeMs,
+    endTimeMs: sorted[sorted.length - 1]?.timestampMs ?? window.endTimeMs,
+    expectedBars: window.countback,
+    candleCount: sorted.length,
+    latestCandle: sorted[sorted.length - 1] ?? null,
+    candles: sorted,
+    fetchedAtMs: Date.now(),
+    dataSource: "arcus"
+  };
+}
+async function arcusFetchAccountLeverages(args) {
+  const base = arcusPerpApiBaseUrl(args.chainId);
+  const params = new URLSearchParams({ address: args.address.trim() });
+  if (args.accountIndex != null) {
+    params.set("accountIndex", String(args.accountIndex));
+  }
+  const data = await arcusJsonGet(`${base}/v1/leverages?${params}`);
+  return { leverages: data.leverages ?? [] };
+}
+async function arcusFetchAllMids(args) {
+  const base = arcusPerpApiBaseUrl(args.chainId);
+  const data = await arcusJsonGet(`${base}/v1/mids`);
+  return data?.mids ?? {};
+}
+async function arcusFetchAccount(args) {
+  const base = arcusPerpApiBaseUrl(args.chainId);
+  const params = new URLSearchParams({ address: args.address.trim() });
+  return arcusJsonGet(`${base}/v1/account?${params}`);
+}
+async function arcusFetchPositions(args) {
+  const base = arcusPerpApiBaseUrl(args.chainId);
+  const params = new URLSearchParams({ address: args.address.trim() });
+  return arcusJsonGet(`${base}/v1/positions?${params}`);
+}
+async function arcusFetchOpenOrders(args) {
+  const base = arcusPerpApiBaseUrl(args.chainId);
+  const params = new URLSearchParams({ address: args.address.trim() });
+  return arcusJsonGet(`${base}/v1/openOrders?${params}`);
+}
+async function arcusFetchApiKeys(args) {
+  const base = arcusPerpApiBaseUrl(args.chainId);
+  const params = new URLSearchParams({ address: args.address.trim() });
+  return arcusJsonGet(`${base}/v1/getApiKeys?${params}`);
+}
+async function arcusFetchSpotOverview(args) {
+  const base = arcusApiMetaBaseUrl(args.chainId);
+  const data = await arcusJsonGet(`${base}/spot/overview`);
+  return { tokens: Array.isArray(data) ? data : [] };
+}
+function arcusMapSpotCandles(raw) {
+  return (raw ?? []).map((c) => ({
+    timestampMs: c.t * 1e3,
+    open: String(c.o),
+    high: String(c.h),
+    low: String(c.l),
+    close: String(c.c),
+    volume: c.volume != null ? String(c.volume) : "0"
+  }));
+}
+async function arcusFetchSpotTokenCandles(args) {
+  const { arcusSpotIndexerBaseUrl: arcusSpotIndexerBaseUrl2 } = await Promise.resolve().then(() => (init_support(), support_exports));
+  const base = arcusSpotIndexerBaseUrl2(args.chainId);
+  const addr = args.tokenAddress.trim();
+  const params = new URLSearchParams({
+    resolution: args.resolution ?? "1h",
+    networkId: String(args.chainId)
+  });
+  if (args.fromSec != null) params.set("from", String(args.fromSec));
+  if (args.toSec != null) params.set("to", String(args.toSec));
+  if (args.limit != null) {
+    const toSec = args.toSec ?? Math.floor(Date.now() / 1e3);
+    const resSec = { "1m": 60, "5m": 300, "15m": 900, "1h": 3600, "1d": 86400 }[args.resolution ?? "1h"] ?? 3600;
+    params.set("from", String(toSec - args.limit * resSec));
+    params.set("to", String(toSec));
+  }
+  const data = await arcusJsonGet(`${base}/token-candles/${addr}?${params}`);
+  const candles = arcusMapSpotCandles(data.candles);
+  return {
+    tokenAddress: data.address ?? addr,
+    candles: [...candles].sort((a, b) => a.timestampMs - b.timestampMs)
+  };
+}
+async function arcusFetchSpotOhlcvRange(args) {
+  let tokenAddress = args.tokenAddress?.trim();
+  let ticker = args.ticker?.trim();
+  if (!tokenAddress) {
+    const { tokens } = await arcusFetchSpotOverview({ chainId: args.chainId });
+    const match = tokens.find(
+      (t) => ticker && t.ticker.toUpperCase() === ticker.toUpperCase() || tokenAddress && t.contractAddress.toLowerCase() === tokenAddress.toLowerCase()
+    );
+    if (!match) throw new Error(`Arcus spot token not found for ${ticker ?? tokenAddress ?? "unknown"}.`);
+    tokenAddress = match.contractAddress;
+    ticker = match.ticker;
+  }
+  const interval = args.interval ?? "1h";
+  const lookbackDays = args.lookbackDays ?? 14;
+  const toSec = Math.floor(Date.now() / 1e3);
+  const fromSec = toSec - lookbackDays * 86400;
+  const { candles, tokenAddress: resolved } = await arcusFetchSpotTokenCandles({
+    chainId: args.chainId,
+    tokenAddress,
+    resolution: interval,
+    fromSec,
+    toSec,
+    limit: args.candleCount
+  });
+  return {
+    market: ticker ?? resolved,
+    tokenAddress: resolved,
+    interval,
+    marketKind: "spot",
+    startTimeMs: candles[0]?.timestampMs ?? fromSec * 1e3,
+    endTimeMs: candles[candles.length - 1]?.timestampMs ?? toSec * 1e3,
+    candleCount: candles.length,
+    latestCandle: candles[candles.length - 1] ?? null,
+    candles,
+    fetchedAtMs: Date.now(),
+    dataSource: "arcus"
+  };
+}
+var init_api = __esm({
+  "src/protocols/evm/arcus/api.ts"() {
+    init_constants();
+    init_support();
+  }
+});
+
+// src/core/registry.ts
+var modules = [];
+function registerProtocolModule(mod) {
+  const existing = modules.findIndex((m) => m.id === mod.id);
+  if (existing >= 0) {
+    modules[existing] = mod;
+  } else {
+    modules.push(mod);
+  }
+}
+
+// src/protocols/evm/arcus/index.ts
+init_support();
+init_support();
+init_constants();
+init_api();
+
+// src/protocols/evm/arcus/markets.ts
+init_api();
+var ARCUS_PERP_MARKET_STATUS_ONLINE = "ONLINE";
+function arcusIsPerpMarketOnline(status) {
+  return String(status ?? "").trim().toUpperCase() === ARCUS_PERP_MARKET_STATUS_ONLINE;
+}
+function arcusAssertPerpMarketOnline(market) {
+  if (!arcusIsPerpMarketOnline(market.status)) {
+    const label = market.status.trim() || "not ONLINE";
+    throw new Error(`Arcus perp market ${market.marketDisplayName} is ${label} and cannot be used for new orders.`);
+  }
+}
+var ROBINHOOD_CHAIN = {
+  id: 4663,
+  name: "Robinhood Chain",
+  nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
+  rpcUrls: { default: { http: ["https://rpc.mainnet.chain.robinhood.com"] } }
+};
+function arcusMaxLeverageFromInitialMarginFraction(initialMarginFraction) {
+  const imf = Number(initialMarginFraction);
+  if (!Number.isFinite(imf) || imf <= 0) return null;
+  return Math.max(1, Math.floor(1 / imf));
+}
+function formatArcusLeverageLabel(leverage) {
+  if (leverage == null || !Number.isFinite(leverage) || leverage <= 0) return null;
+  return `${Math.round(leverage)}x cross`;
+}
+function arcusLookupMidFromMids(mids, market) {
+  const resolved = market.trim();
+  if (!resolved) return "";
+  const base = resolved.replace(/-USD$/i, "");
+  return mids[resolved] ?? mids[base] ?? mids[`${base}-USD`] ?? "";
+}
+function parseArcusLeverageLabel(label) {
+  const match = String(label ?? "").match(/(\d+(?:\.\d+)?)/);
+  if (!match) return null;
+  const n = Number(match[1]);
+  return Number.isFinite(n) && n > 0 ? n : null;
+}
+function arcusResolveEffectiveLeverage(args) {
+  const entry = args.leverages.find((l) => l.marketDisplayName === args.marketDisplayName);
+  const marketRow = args.markets.find((m) => m.marketDisplayName === args.marketDisplayName);
+  const leverage = entry?.leverage ?? null;
+  return {
+    leverage,
+    leverageLabel: formatArcusLeverageLabel(leverage),
+    maxLeverage: arcusMaxLeverageFromInitialMarginFraction(marketRow?.initialMarginFraction)
+  };
+}
+async function arcusSearchPerpMarkets(args) {
+  const { arcusFetchPerpMarkets: arcusFetchPerpMarkets2 } = await Promise.resolve().then(() => (init_api(), api_exports));
+  const q = args.query.trim().toUpperCase();
+  const { markets } = await arcusFetchPerpMarkets2({ chainId: args.chainId });
+  const filtered = markets.filter(
+    (m) => m.marketDisplayName.toUpperCase().includes(q) || m.baseAsset.toUpperCase().includes(q) || String(m.marketId) === q
+  );
+  const limit = args.limit ?? 20;
+  return { markets: filtered.slice(0, limit), query: args.query };
+}
+async function arcusSearchSpotMarkets(args) {
+  const q = args.query.trim().toUpperCase();
+  const { tokens } = await arcusFetchSpotOverview({ chainId: args.chainId });
+  const filtered = tokens.filter(
+    (t) => t.ticker.toUpperCase().includes(q) || t.name.toUpperCase().includes(q) || t.contractAddress.toLowerCase().includes(q.toLowerCase())
+  );
+  const limit = args.limit ?? 20;
+  return { tokens: filtered.slice(0, limit), query: args.query };
+}
+async function arcusFetchSpotBalances(args) {
+  const executor = getAddress(args.executorAddress);
+  const { tokens } = await arcusFetchSpotOverview({ chainId: args.chainId });
+  const client = createPublicClient({
+    chain: ROBINHOOD_CHAIN,
+    transport: http(ROBINHOOD_CHAIN.rpcUrls.default.http[0])
+  });
+  const holdings = [];
+  for (const token of tokens) {
+    let addr;
+    try {
+      addr = getAddress(token.contractAddress);
+    } catch {
+      continue;
+    }
+    try {
+      const [balance, decimals] = await Promise.all([
+        client.readContract({ address: addr, abi: erc20Abi, functionName: "balanceOf", args: [executor] }),
+        client.readContract({ address: addr, abi: erc20Abi, functionName: "decimals" })
+      ]);
+      if (balance > 0n) {
+        const dec = Number(decimals);
+        const human = Number(balance) / 10 ** dec;
+        holdings.push({
+          ticker: token.ticker,
+          contractAddress: addr,
+          name: token.name,
+          balanceHuman: human.toString(),
+          decimals: dec
+        });
+      }
+    } catch {
+    }
+  }
+  return { holdings, executorAddress: executor };
+}
+function arcusResolvePerpMarketDisplayName(markets, query) {
+  const q = query.trim().toUpperCase();
+  if (!q) return null;
+  const exact = markets.find((m) => m.marketDisplayName.toUpperCase() === q);
+  if (exact) return exact.marketDisplayName;
+  const base = markets.find((m) => m.baseAsset.toUpperCase() === q);
+  if (base) return base.marketDisplayName;
+  const partial = markets.find((m) => m.marketDisplayName.toUpperCase().includes(q));
+  return partial?.marketDisplayName ?? null;
+}
+
+// src/protocols/evm/arcus/reads.ts
+init_api();
+init_constants();
+function wrapOhlcvEnvelope(ohlcv) {
+  return {
+    ohlcv,
+    dataSource: "arcus",
+    chainId: 4663
+  };
+}
+async function arcusFetchMarketsSummary(args) {
+  const { markets } = await arcusFetchPerpMarkets(args);
+  return {
+    markets: markets.map((m) => ({
+      marketDisplayName: m.marketDisplayName,
+      marketId: m.marketId,
+      baseAsset: m.baseAsset,
+      category: m.category,
+      status: m.status,
+      isOnline: arcusIsPerpMarketOnline(m.status),
+      maxLeverage: arcusMaxLeverageFromInitialMarginFraction(m.initialMarginFraction),
+      markPrice: m.markPrice ?? null
+    })),
+    marketKind: "perp"
+  };
+}
+async function arcusSearchMarketsSummary(args) {
+  return arcusSearchPerpMarkets(args);
+}
+async function arcusSpotFetchMarketsSummary(args) {
+  const { tokens } = await arcusFetchSpotOverview(args);
+  return {
+    tokens: tokens.map((t) => ({
+      ticker: t.ticker,
+      contractAddress: t.contractAddress,
+      name: t.name,
+      logoUrl: t.logoUrl ?? null,
+      price: t.quote?.price ?? null
+    })),
+    marketKind: "spot"
+  };
+}
+async function arcusSpotSearchMarketsSummary(args) {
+  return arcusSearchSpotMarkets(args);
+}
+async function arcusFetchOhlcvSummary(args) {
+  const { markets } = await arcusFetchPerpMarkets({ chainId: args.chainId });
+  const rawMarket = (args.market ?? args.coin ?? "").trim();
+  const resolved = arcusResolvePerpMarketDisplayName(markets, rawMarket) ?? (rawMarket.includes("-") ? rawMarket : rawMarket ? `${rawMarket.toUpperCase()}-USD` : "");
+  if (!resolved) throw new Error("Arcus perp market is required (market or coin).");
+  const ohlcv = await arcusFetchPerpOhlcvRange({ ...args, market: resolved });
+  return {
+    ...wrapOhlcvEnvelope(ohlcv),
+    resolvedMarket: resolved
+  };
+}
+async function arcusSpotFetchOhlcvSummary(args) {
+  const ticker = args.ticker ?? args.currencySymbol;
+  const ohlcv = await arcusFetchSpotOhlcvRange({
+    chainId: args.chainId,
+    tokenAddress: args.tokenAddress,
+    ticker,
+    interval: args.interval,
+    lookbackDays: args.lookbackDays,
+    candleCount: args.candleCount
+  });
+  return wrapOhlcvEnvelope(ohlcv);
+}
+async function arcusFetchMarketSnapshotSummary(args) {
+  const { markets } = await arcusFetchPerpMarkets({ chainId: args.chainId });
+  const rawMarket = (args.market ?? args.coin ?? "").trim();
+  const resolved = arcusResolvePerpMarketDisplayName(markets, rawMarket) ?? (rawMarket.includes("-") ? rawMarket : `${rawMarket.toUpperCase()}-USD`);
+  const mids = await arcusFetchAllMids({ chainId: args.chainId });
+  const mid = arcusLookupMidFromMids(mids, resolved);
+  const ohlcv = await arcusFetchPerpOhlcvRange({
+    chainId: args.chainId,
+    market: resolved,
+    interval: args.interval ?? ARCUS_DEFAULT_OHLCV_INTERVAL,
+    candleCount: args.candleLimit ?? 48
+  });
+  return {
+    snapshot: {
+      market: resolved,
+      midUsd: mid,
+      interval: ohlcv.interval,
+      latestCandle: ohlcv.latestCandle,
+      candles: ohlcv.candles,
+      candleCount: ohlcv.candleCount,
+      fetchedAtMs: Date.now()
+    },
+    resolvedMarket: resolved
+  };
+}
+function withAddress(args) {
+  return { ...args, address: args.executorAddress };
+}
+async function arcusFetchAccountSummary(args) {
+  const account = await arcusFetchAccount(withAddress(args));
+  return { account, executorAddress: args.executorAddress };
+}
+async function arcusFetchPositionsSummary(args) {
+  const data = await arcusFetchPositions(withAddress(args));
+  return { positions: data.positions ?? [], executorAddress: args.executorAddress };
+}
+async function arcusFetchOpenOrdersSummary(args) {
+  const data = await arcusFetchOpenOrders(withAddress(args));
+  return { orders: data.orders ?? [], executorAddress: args.executorAddress };
+}
+async function arcusFetchLeveragesSummary(args) {
+  const { leverages } = await arcusFetchAccountLeverages({
+    chainId: args.chainId,
+    address: args.executorAddress,
+    accountIndex: args.accountIndex
+  });
+  return { leverages, executorAddress: args.executorAddress };
+}
+async function arcusFetchOpenContextSummary(args) {
+  const addrArgs = withAddress(args);
+  const accountIndex = args.accountIndex ?? 0;
+  const [account, positions, orders, apiKeys, leveragesResult, marketsResult] = await Promise.all([
+    arcusFetchAccount(addrArgs).catch(() => null),
+    arcusFetchPositions(addrArgs).catch(() => ({ positions: [] })),
+    arcusFetchOpenOrders(addrArgs).catch(() => ({ orders: [] })),
+    arcusFetchApiKeys(addrArgs).catch(() => ({ apiKeys: [] })),
+    arcusFetchAccountLeverages({
+      chainId: args.chainId,
+      address: args.executorAddress,
+      accountIndex
+    }).catch(() => ({ leverages: [] })),
+    arcusFetchPerpMarkets({ chainId: args.chainId }).catch(() => ({ markets: [] }))
+  ]);
+  const rawMarket = (args.market ?? "").trim();
+  let activeAsset = null;
+  if (rawMarket) {
+    const resolved = arcusResolvePerpMarketDisplayName(marketsResult.markets, rawMarket) ?? (rawMarket.includes("-") ? rawMarket : `${rawMarket.toUpperCase()}-USD`);
+    const marketRow = marketsResult.markets.find((m) => m.marketDisplayName === resolved);
+    const effective = arcusResolveEffectiveLeverage({
+      marketDisplayName: resolved,
+      leverages: leveragesResult.leverages,
+      markets: marketsResult.markets
+    });
+    activeAsset = {
+      market: resolved,
+      leverage: effective.leverage,
+      leverageLabel: effective.leverageLabel,
+      maxLeverage: effective.maxLeverage,
+      markPrice: marketRow?.markPrice ?? null
+    };
+  }
+  return {
+    account,
+    positions: positions.positions ?? [],
+    orders: orders.orders ?? [],
+    apiKeys: apiKeys.apiKeys ?? [],
+    leverages: leveragesResult.leverages,
+    activeAsset,
+    executorAddress: args.executorAddress,
+    hasRegisteredApiKey: Array.isArray(apiKeys.apiKeys) && apiKeys.apiKeys.length > 0
+  };
+}
+async function arcusSpotFetchBalancesSummary(args) {
+  return arcusFetchSpotBalances(args);
+}
+function arcusCanonicalJson(payload) {
+  const keys = Object.keys(payload).sort();
+  const parts = [];
+  for (const k of keys) {
+    const v = payload[k];
+    if (v === void 0 || v === null) continue;
+    let encoded;
+    if (typeof v === "string") {
+      encoded = JSON.stringify(v.toLowerCase().startsWith("0x") ? v.toLowerCase() : v);
+    } else {
+      encoded = JSON.stringify(v);
+    }
+    parts.push(`${JSON.stringify(k)}:${encoded}`);
+  }
+  return `{${parts.join(",")}}`;
+}
+function arcusPayloadMessageHex(canonicalJson) {
+  return `0x${Buffer.from(canonicalJson, "utf8").toString("hex")}`;
+}
+function arcusPayloadMsgHashHex(canonicalJson) {
+  return createHash("sha256").update(canonicalJson, "utf8").digest("hex");
+}
+function arcusNanosecondTimestamp() {
+  return String(BigInt(Date.now()) * 1000000n);
+}
+function humanPriceToQuantums(priceHuman, tickSize) {
+  const price = Number(priceHuman);
+  const tick = Number(tickSize);
+  if (!Number.isFinite(price) || !Number.isFinite(tick) || tick <= 0) {
+    throw new Error(`Invalid price or tickSize: ${priceHuman}, ${tickSize}`);
+  }
+  return BigInt(Math.round(price / tick));
+}
+function humanSizeToQuantums(szHuman, stepSize) {
+  const sz = Number(szHuman);
+  const step = Number(stepSize);
+  if (!Number.isFinite(sz) || !Number.isFinite(step) || step <= 0) {
+    throw new Error(`Invalid size or stepSize: ${szHuman}, ${stepSize}`);
+  }
+  return BigInt(Math.round(sz / step));
+}
+function buildArcusPlaceOrderPayload(args) {
+  const timeInForce = args.timeInForce ?? args.orderType ?? 0;
+  const ct = BigInt(args.timestampNs);
+  const payload = {
+    ad: getAddress(args.address),
+    ai: args.accountIndex ?? 0,
+    ct: Number(ct),
+    g: args.grouping ?? 0,
+    m: args.marketId,
+    op: args.op ?? 1,
+    p: Number(args.priceQuantums),
+    q: Number(args.sizeQuantums),
+    r: args.reduceOnly ? 1 : 0,
+    s: args.side,
+    t: timeInForce,
+    v: args.version ?? 1
+  };
+  if (args.clientId?.trim()) payload.c = args.clientId.trim();
+  return payload;
+}
+function buildArcusCancelOrderPayload(args) {
+  const payload = {
+    ad: getAddress(args.address),
+    ai: args.accountIndex ?? 0,
+    ct: Number(BigInt(args.timestampNs)),
+    id: args.orderId,
+    m: args.marketId,
+    op: 2,
+    v: 1
+  };
+  if (args.clientId?.trim()) payload.c = args.clientId.trim();
+  return payload;
+}
+function buildArcusTpslPayload(args) {
+  const base = buildArcusPlaceOrderPayload({ ...args, op: 4, reduceOnly: true });
+  return { ...base, tpslType: args.tpslType };
+}
+
+// src/core/purpose.ts
+function mergePurposeText(purposeText, purposeSuffix) {
+  const t = (purposeText ?? "").trim();
+  const suffix = (purposeSuffix ?? "").trim();
+  if (!suffix) return t;
+  return t ? `${t}
+
+${suffix}` : suffix;
+}
+
+// src/core/envelope.ts
+function finalizeMultisign(input) {
+  const { keyGen, destinationChainID, legs } = input;
+  if (legs.length === 0) {
+    throw new Error("finalizeMultisign requires at least one leg");
+  }
+  const ph = (keyGen.pubkeyhex ?? "").trim();
+  if (!ph) throw new Error("keyGen pubKey (pubkeyhex) is required");
+  const keyList = keyGen.keylist ?? [];
+  const clientId = getClientIdFromKeyGenResult(keyGen);
+  const first = legs[0];
+  const messageHashes = legs.map((l) => l.msgHash);
+  const messageRawBatch = legs.map((l) => l.msgRaw);
+  const batchMeta = legs.map((l) => ({
+    destinationAddress: l.destinationAddress,
+    signatureText: l.signatureText,
+    ...l.audit
+  }));
+  const proposalTxParams = legs.map((l) => l.proposalTxParams).filter((p) => p != null && typeof p === "object");
+  const extraPayload = {
+    batchMeta,
+    ...input.extraJSON ?? {}
+  };
+  const extraJSON = JSON.stringify(extraPayload, (_, v) => typeof v === "bigint" ? v.toString() : v);
+  const bodyForSign = {
+    keyList,
+    pubKey: ph,
+    msgHash: messageHashes[0],
+    msgRaw: first.msgRaw,
+    destinationChainID,
+    destinationAddress: input.destinationAddress ?? first.destinationAddress,
+    extraJSON,
+    signatureText: first.signatureText,
+    purpose: mergePurposeText(input.purposeText, input.purposeSuffix),
+    ...first.feeSnapshot
+  };
+  if (legs.length > 1) {
+    bodyForSign.messageHashes = messageHashes;
+    bodyForSign.messageRawBatch = messageRawBatch;
+  }
+  if (proposalTxParams.length > 0) {
+    bodyForSign.proposalTxParams = proposalTxParams;
+  }
+  const valueWei = first.valueWei;
+  if (valueWei != null && valueWei > 0n) {
+    bodyForSign.value = valueWei.toString();
+  }
+  if (clientId) bodyForSign.clientId = clientId;
+  if (input.expiryDate != null && input.expiryDate > 0) {
+    bodyForSign.expiryDate = Math.floor(input.expiryDate);
+  }
+  return { bodyForSign, messageToSign: JSON.stringify(bodyForSign) };
+}
+var PAYLOAD_SIGN_ED25519_REQUEST_KIND = "payload_sign_ed25519";
+function msgHashNo0xFromBytes(bytes) {
+  return Buffer.from(bytes).toString("hex");
+}
+function payloadMsgRawHex(messageUtf8, delivery) {
+  const envelope = {
+    version: 1,
+    messageUtf8,
+    delivery
+  };
+  return stringToHex(JSON.stringify(envelope));
+}
+function buildPayloadSignEd25519MultisignBody(args) {
+  const messageBytes = Buffer.from(args.messageUtf8, "utf8");
+  const msgHash = msgHashNo0xFromBytes(messageBytes);
+  const extraJSON = {
+    signRequestKind: PAYLOAD_SIGN_ED25519_REQUEST_KIND,
+    payloadSignEd25519: {
+      version: 1,
+      messageHex: msgHash,
+      messageLength: messageBytes.length
+    },
+    delivery: args.delivery
+  };
+  if (args.billingKeyGenPubKey?.trim()) {
+    extraJSON.billingKeyGenPubKey = args.billingKeyGenPubKey.trim();
+  }
+  return finalizeMultisign({
+    keyGen: args.keyGen,
+    purposeText: args.purposeText,
+    purposeSuffix: args.purposeSuffix,
+    destinationChainID: args.destinationChainID,
+    destinationAddress: args.destinationAddress,
+    extraJSON,
+    expiryDate: args.expiryDate,
+    legs: [
+      {
+        msgHash,
+        msgRaw: payloadMsgRawHex(args.messageUtf8, args.delivery),
+        destinationAddress: args.destinationAddress,
+        signatureText: args.signatureText ?? "Arcus Ed25519 payload sign",
+        audit: {
+          kind: "PAYLOAD_SIGN_ED25519",
+          deliveryKind: args.delivery.kind,
+          messageLength: messageBytes.length,
+          ...args.audit ?? {}
+        },
+        feeSnapshot: {}
+      }
+    ]
+  });
+}
+
+// src/protocols/evm/arcus/multisign.ts
+init_api();
+
+// src/protocols/evm/arcus/keygenPair.ts
+function assertArcusPairedKeyGens(args) {
+  const secpType = (args.secp256k1KeyGen.keyType ?? "secp256k1").toLowerCase();
+  const edType = (args.ed25519KeyGen.keyType ?? "ed25519").toLowerCase();
+  if (!secpType.includes("secp256k1")) {
+    throw new Error(`Arcus custody KeyGen must be secp256k1, got ${secpType}`);
+  }
+  if (!edType.includes("ed25519")) {
+    throw new Error(`Arcus API KeyGen must be ed25519, got ${edType}`);
+  }
+  const secpGroup = (args.secp256k1KeyGen.groupId ?? "").trim();
+  const edGroup = (args.ed25519KeyGen.groupId ?? "").trim();
+  if (secpGroup && edGroup && secpGroup !== edGroup) {
+    throw new Error(`Arcus KeyGen GroupId mismatch: secp256k1=${secpGroup} ed25519=${edGroup}`);
+  }
+  const secpPk = (args.secp256k1KeyGen.pubkeyhex ?? "").trim();
+  const edPk = (args.ed25519KeyGen.pubkeyhex ?? "").trim();
+  if (!secpPk) throw new Error("secp256k1 KeyGen pubkeyhex is required");
+  if (!edPk) throw new Error("ed25519 KeyGen pubkeyhex is required");
+  return { secp256k1: args.secp256k1KeyGen, ed25519: args.ed25519KeyGen };
+}
+
+// src/protocols/evm/arcus/multisign.ts
+init_constants();
+var ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
+async function resolvePerpMarket(chainId, market) {
+  const { markets } = await arcusFetchPerpMarkets({ chainId });
+  const resolved = arcusResolvePerpMarketDisplayName(markets, market) ?? (market.includes("-") ? market : `${market.toUpperCase()}-USD`);
+  const row = markets.find((m) => m.marketDisplayName === resolved);
+  if (!row) throw new Error(`Arcus perp market not found: ${market}`);
+  return row;
+}
+function scheme2CanonicalJson(body) {
+  return arcusCanonicalJson(body);
+}
+async function buildArcusCreateApiKeyMultisign(args) {
+  const paired = assertArcusPairedKeyGens({
+    secp256k1KeyGen: args.secp256k1KeyGen,
+    ed25519KeyGen: args.ed25519KeyGen
+  });
+  const address = getAddress(args.executorAddress);
+  const publicKey = args.ed25519PubKeyHex.trim().replace(/^0x/i, "");
+  if (publicKey.length !== 64) {
+    throw new Error("ed25519PubKeyHex must be 64 hex chars (32-byte Ed25519 public key)");
+  }
+  const validUntil = args.validUntilMs ?? Date.now() + 365 * 864e5;
+  const body = {
+    address: address.toLowerCase(),
+    publicKey,
+    apiWalletName: (args.apiWalletName ?? "Continuum").trim(),
+    validUntil
+  };
+  const canonical = arcusCanonicalJson(body);
+  const digest = hashMessage(canonical);
+  const msgHash = digest.startsWith("0x") ? digest.slice(2) : digest;
+  return finalizeMultisign({
+    keyGen: paired.secp256k1,
+    purposeText: args.purposeText,
+    destinationChainID: String(args.chainId),
+    destinationAddress: address,
+    expiryDate: args.expiryDate,
+    extraJSON: {
+      signRequestKind: "personal_sign",
+      delivery: {
+        kind: "arcus_create_api_key",
+        chainId: args.chainId,
+        body,
+        canonical
+      }
+    },
+    legs: [
+      {
+        msgHash,
+        msgRaw: `0x${Buffer.from(canonical, "utf8").toString("hex")}`,
+        destinationAddress: address,
+        signatureText: "Arcus createApiKey personal_sign",
+        audit: {
+          kind: "PERSONAL_SIGN",
+          protocol: ARCUS_PROTOCOL_ID,
+          action: "createApiKey",
+          address,
+          publicKey
+        },
+        feeSnapshot: {}
+      }
+    ]
+  });
+}
+async function buildArcusPlaceOrderMultisign(args) {
+  const paired = assertArcusPairedKeyGens({
+    secp256k1KeyGen: args.secp256k1KeyGen,
+    ed25519KeyGen: args.ed25519KeyGen
+  });
+  const marketRow = await resolvePerpMarket(args.chainId, args.market);
+  arcusAssertPerpMarketOnline(marketRow);
+  const address = getAddress(args.executorAddress);
+  const timestampNs = arcusNanosecondTimestamp();
+  const goodTilNs = String(BigInt(timestampNs) + 90n * 86400n * 1000000000n);
+  const timeInForce = args.timeInForce ?? args.tif ?? args.orderType ?? 0;
+  const tp = args.takeProfitTriggerPxHuman?.trim();
+  const sl = args.stopLossTriggerPxHuman?.trim();
+  if (args.reduceOnly && (tp || sl)) {
+    throw new Error("reduceOnly cannot be combined with takeProfitTriggerPxHuman or stopLossTriggerPxHuman.");
+  }
+  const priceQuantums = humanPriceToQuantums(args.limitPxHuman, marketRow.tickSize);
+  const sizeQuantums = humanSizeToQuantums(args.szHuman, marketRow.stepSize);
+  const entryPayload = buildArcusPlaceOrderPayload({
+    address,
+    accountIndex: args.accountIndex,
+    clientId: args.clientId,
+    timestampNs,
+    marketId: marketRow.marketId,
+    priceQuantums,
+    sizeQuantums,
+    side: args.isBuy ? 0 : 1,
+    timeInForce,
+    reduceOnly: args.reduceOnly,
+    grouping: 0
+  });
+  entryPayload.g = Number(goodTilNs);
+  const legs = [
+    {
+      canonical: arcusCanonicalJson(entryPayload),
+      audit: { leg: "entry", market: marketRow.marketDisplayName }
+    }
+  ];
+  if (tp) {
+    const tpPayload = buildArcusTpslPayload({
+      address,
+      accountIndex: args.accountIndex,
+      clientId: args.clientId,
+      timestampNs,
+      marketId: marketRow.marketId,
+      priceQuantums: humanPriceToQuantums(tp, marketRow.tickSize),
+      sizeQuantums,
+      side: args.isBuy ? 1 : 0,
+      orderType: 0,
+      grouping: 0,
+      tpslType: "TAKE_PROFIT"
+    });
+    tpPayload.g = Number(goodTilNs);
+    legs.push({
+      canonical: arcusCanonicalJson(tpPayload),
+      audit: { leg: "takeProfit", triggerPxHuman: tp }
+    });
+  }
+  if (sl) {
+    const slPayload = buildArcusTpslPayload({
+      address,
+      accountIndex: args.accountIndex,
+      clientId: args.clientId,
+      timestampNs,
+      marketId: marketRow.marketId,
+      priceQuantums: humanPriceToQuantums(sl, marketRow.tickSize),
+      sizeQuantums,
+      side: args.isBuy ? 1 : 0,
+      orderType: 0,
+      grouping: 0,
+      tpslType: "STOP_LOSS"
+    });
+    slPayload.g = Number(goodTilNs);
+    legs.push({
+      canonical: arcusCanonicalJson(slPayload),
+      audit: { leg: "stopLoss", triggerPxHuman: sl }
+    });
+  }
+  if (legs.length === 1) {
+    const canonical = legs[0].canonical;
+    return buildPayloadSignEd25519MultisignBody({
+      keyGen: paired.ed25519,
+      purposeText: args.purposeText,
+      destinationChainID: String(args.chainId),
+      destinationAddress: ZERO_ADDRESS,
+      messageUtf8: canonical,
+      billingKeyGenPubKey: paired.secp256k1.pubkeyhex,
+      expiryDate: args.expiryDate,
+      delivery: {
+        kind: "arcus_exchange",
+        chainId: args.chainId,
+        endpoint: "placeOrder",
+        timestampNs,
+        apiKeyPubKeyHex: paired.ed25519.pubkeyhex,
+        body: JSON.parse(canonical)
+      },
+      audit: {
+        protocol: ARCUS_PROTOCOL_ID,
+        action: "placeOrder",
+        market: marketRow.marketDisplayName,
+        isBuy: args.isBuy,
+        limitPxHuman: args.limitPxHuman,
+        szHuman: args.szHuman,
+        leverageHuman: args.leverageHuman?.trim() || null,
+        timeInForce,
+        reduceOnly: Boolean(args.reduceOnly),
+        takeProfitTriggerPxHuman: tp ?? null,
+        stopLossTriggerPxHuman: sl ?? null
+      }
+    });
+  }
+  const batchLegs = legs.map((leg, i) => {
+    const messageBytes = Buffer.from(leg.canonical, "utf8");
+    return {
+      msgHash: messageBytes.toString("hex"),
+      msgRaw: `0x${messageBytes.toString("hex")}`,
+      destinationAddress: ZERO_ADDRESS,
+      signatureText: `Arcus bracket leg ${i + 1}/${legs.length}`,
+      audit: { protocol: ARCUS_PROTOCOL_ID, action: "placeOrder", ...leg.audit },
+      feeSnapshot: {}
+    };
+  });
+  return finalizeMultisign({
+    keyGen: paired.ed25519,
+    purposeText: args.purposeText,
+    destinationChainID: String(args.chainId),
+    destinationAddress: ZERO_ADDRESS,
+    expiryDate: args.expiryDate,
+    extraJSON: {
+      signRequestKind: PAYLOAD_SIGN_ED25519_REQUEST_KIND,
+      billingKeyGenPubKey: paired.secp256k1.pubkeyhex,
+      delivery: {
+        kind: "arcus_exchange",
+        chainId: args.chainId,
+        endpoint: "batchPlaceOrders",
+        timestampNs,
+        grouping: "positionTpsl",
+        legCount: legs.length,
+        apiKeyPubKeyHex: paired.ed25519.pubkeyhex
+      },
+      batchMeta: batchLegs.map((l) => l.audit)
+    },
+    legs: batchLegs
+  });
+}
+async function buildArcusCloseMultisign(args) {
+  return buildArcusPlaceOrderMultisign({
+    ...args,
+    isBuy: !args.isLong,
+    reduceOnly: true,
+    timeInForce: args.timeInForce ?? 2,
+    takeProfitTriggerPxHuman: void 0,
+    stopLossTriggerPxHuman: void 0
+  });
+}
+async function buildArcusCancelOrderMultisign(args) {
+  const paired = assertArcusPairedKeyGens({
+    secp256k1KeyGen: args.secp256k1KeyGen,
+    ed25519KeyGen: args.ed25519KeyGen
+  });
+  const marketRow = await resolvePerpMarket(args.chainId, args.market);
+  const address = getAddress(args.executorAddress);
+  const timestampNs = arcusNanosecondTimestamp();
+  const payload = buildArcusCancelOrderPayload({
+    address,
+    accountIndex: args.accountIndex,
+    clientId: args.clientId,
+    timestampNs,
+    marketId: marketRow.marketId,
+    orderId: args.orderId
+  });
+  const canonical = arcusCanonicalJson(payload);
+  return buildPayloadSignEd25519MultisignBody({
+    keyGen: paired.ed25519,
+    purposeText: args.purposeText,
+    destinationChainID: String(args.chainId),
+    destinationAddress: ZERO_ADDRESS,
+    messageUtf8: canonical,
+    billingKeyGenPubKey: paired.secp256k1.pubkeyhex,
+    expiryDate: args.expiryDate,
+    delivery: {
+      kind: "arcus_exchange",
+      chainId: args.chainId,
+      endpoint: "cancelOrder",
+      timestampNs,
+      apiKeyPubKeyHex: paired.ed25519.pubkeyhex,
+      body: payload
+    },
+    audit: {
+      protocol: ARCUS_PROTOCOL_ID,
+      action: "cancelOrder",
+      market: marketRow.marketDisplayName,
+      orderId: args.orderId
+    }
+  });
+}
+async function buildArcusSetLeverageMultisign(args) {
+  const paired = assertArcusPairedKeyGens({
+    secp256k1KeyGen: args.secp256k1KeyGen,
+    ed25519KeyGen: args.ed25519KeyGen
+  });
+  const marketRow = await resolvePerpMarket(args.chainId, args.market);
+  arcusAssertPerpMarketOnline(marketRow);
+  const address = getAddress(args.executorAddress);
+  const timestampNs = arcusNanosecondTimestamp();
+  const body = {
+    address: address.toLowerCase(),
+    accountIndex: args.accountIndex ?? 0,
+    marketId: marketRow.marketId,
+    leverage: args.leverage
+  };
+  const canonical = scheme2CanonicalJson(body);
+  const action = "setLeverage";
+  const messageUtf8 = `${timestampNs}${action}${canonical}`;
+  return buildPayloadSignEd25519MultisignBody({
+    keyGen: paired.ed25519,
+    purposeText: args.purposeText,
+    destinationChainID: String(args.chainId),
+    destinationAddress: ZERO_ADDRESS,
+    messageUtf8,
+    billingKeyGenPubKey: paired.secp256k1.pubkeyhex,
+    expiryDate: args.expiryDate,
+    signatureText: "Arcus setLeverage (Scheme 2)",
+    delivery: {
+      kind: "arcus_exchange",
+      chainId: args.chainId,
+      endpoint: action,
+      timestampNs,
+      scheme: 2,
+      apiKeyPubKeyHex: paired.ed25519.pubkeyhex,
+      body,
+      canonical
+    },
+    audit: {
+      protocol: ARCUS_PROTOCOL_ID,
+      action,
+      market: args.market,
+      leverage: args.leverage
+    }
+  });
+}
+async function buildEvmMultisignBodyArcusPlaceOrderBatch(args) {
+  return buildArcusPlaceOrderMultisign(args);
+}
+async function buildEvmMultisignBodyArcusCreateApiKeyBatch(args) {
+  return buildArcusCreateApiKeyMultisign(args);
+}
+async function buildEvmMultisignBodyArcusCancelOrderBatch(args) {
+  return buildArcusCancelOrderMultisign(args);
+}
+async function buildEvmMultisignBodyArcusSetLeverageBatch(args) {
+  return buildArcusSetLeverageMultisign(args);
+}
+async function buildEvmMultisignBodyArcusCloseBatch(args) {
+  return buildArcusCloseMultisign(args);
+}
+
+// src/protocols/evm/arcus/pendingClose.ts
+function parsePositiveSize(value) {
+  if (value == null || !String(value).trim()) return null;
+  const n = Number.parseFloat(String(value).trim());
+  if (!Number.isFinite(n) || n <= 0) return null;
+  return n;
+}
+function arcusOrderClosesPosition(position, order) {
+  return position.isLong ? !order.isBuy : order.isBuy;
+}
+function arcusOrderCountsAsPendingClose(order) {
+  return Boolean(order.reduceOnly) || Boolean(order.isTrigger);
+}
+function arcusPendingCloseForPosition(args) {
+  const positionSize = parsePositiveSize(args.position.sizeHuman);
+  if (positionSize == null) {
+    return { pendingCloseSz: 0, pendingClosePct: 0 };
+  }
+  let pendingCloseSz = 0;
+  for (const order of args.orders) {
+    if (order.marketDisplayName !== args.position.key) continue;
+    if (!arcusOrderClosesPosition(args.position, order)) continue;
+    if (!arcusOrderCountsAsPendingClose(order)) continue;
+    const sz = parsePositiveSize(order.sizeHuman);
+    if (sz != null) pendingCloseSz += sz;
+  }
+  const pendingClosePct = Math.min(100, pendingCloseSz / positionSize * 100);
+  return { pendingCloseSz, pendingClosePct };
+}
+function arcusPendingCloseByMarket(args) {
+  const out = /* @__PURE__ */ new Map();
+  for (const position of args.positions) {
+    out.set(position.key, arcusPendingCloseForPosition({ position, orders: args.orders }));
+  }
+  return out;
+}
+
+// src/protocols/evm/arcus/positionDisplay.ts
+function parsePositiveDecimal(value) {
+  const trimmed = String(value ?? "").trim().replace(/,/g, "");
+  if (!trimmed || !/^\d+(\.\d+)?$/.test(trimmed)) return null;
+  const n = Number(trimmed);
+  return Number.isFinite(n) && n > 0 ? n : null;
+}
+function floorToStep(value, step) {
+  if (!Number.isFinite(value) || value <= 0 || !Number.isFinite(step) || step <= 0) return null;
+  const steps = Math.floor(value / step + 1e-12);
+  if (steps <= 0) return null;
+  return steps * step;
+}
+function formatArcusDisplaySize(value, stepSize) {
+  const step = stepSize ? parsePositiveDecimal(stepSize) : null;
+  const floored = step != null ? floorToStep(value, step) : value;
+  if (floored == null || floored <= 0) return "0";
+  const abs = Math.abs(floored);
+  const maxFrac = abs >= 1 ? 4 : abs >= 0.01 ? 6 : 8;
+  return floored.toLocaleString(void 0, { maximumFractionDigits: maxFrac });
+}
+function marketStepSize(markets, marketDisplayName) {
+  return markets.find((m) => m.marketDisplayName === marketDisplayName)?.stepSize ?? null;
+}
+function parseArcusSideIsBuy(raw) {
+  const s = String(raw ?? "").trim().toUpperCase();
+  if (s === "BUY" || s === "LONG" || s === "0") return true;
+  if (s === "SELL" || s === "SHORT" || s === "1") return false;
+  return null;
+}
+function arcusParsePositionDisplayRow(raw, markets) {
+  if (!raw || typeof raw !== "object") return null;
+  const row = raw;
+  const marketDisplayName = String(row.marketDisplayName ?? "").trim();
+  if (!marketDisplayName) return null;
+  const side = String(row.side ?? "").toUpperCase();
+  const isLong = side === "LONG" || side === "BUY";
+  const stepSize = marketStepSize(markets, marketDisplayName);
+  const step = stepSize ? parsePositiveDecimal(stepSize) : null;
+  const markPx = parsePositiveDecimal(String(row.markPx ?? row.markPrice ?? ""));
+  const notional = Math.abs(parsePositiveDecimal(String(row.positionValueNotional ?? row.notional ?? "")) ?? 0);
+  let sizeHuman = null;
+  if (notional > 0 && markPx != null && markPx > 0) {
+    sizeHuman = formatArcusDisplaySize(notional / markPx, stepSize);
+  } else {
+    const sizeRaw = Math.abs(Number(String(row.size ?? row.sizeHuman ?? "").trim()));
+    if (Number.isFinite(sizeRaw) && sizeRaw > 0 && step != null) {
+      sizeHuman = formatArcusDisplaySize(sizeRaw * step, stepSize);
+    }
+  }
+  if (!sizeHuman || !parsePositiveDecimal(sizeHuman)) return null;
+  const levRaw = row.leverage;
+  const leverageLabel = levRaw != null && String(levRaw).trim() ? `${Math.round(Number(levRaw))}x cross` : null;
+  return {
+    key: marketDisplayName,
+    marketDisplayName,
+    isLong,
+    sizeHuman,
+    entryPxHuman: String(row.entryPx ?? row.entryPrice ?? "").trim() || null,
+    markPxHuman: markPx != null ? String(markPx) : String(row.markPx ?? "").trim() || null,
+    positionValueUsd: String(row.positionValueNotional ?? row.notional ?? "").trim() || null,
+    unrealizedPnlUsd: String(row.unrealizedPnl ?? row.unrealizedPnlUsd ?? "").trim() || null,
+    liquidationPxHuman: String(row.liquidationPx ?? row.liquidationPrice ?? "").trim() || null,
+    leverageLabel,
+    marginUsedUsd: String(row.marginUsed ?? "").trim() || null
+  };
+}
+function arcusParseOpenOrderDisplayRow(raw, markets) {
+  if (!raw || typeof raw !== "object") return null;
+  const row = raw;
+  const orderId = String(row.orderId ?? row.id ?? "").trim();
+  const marketDisplayName = String(row.marketDisplayName ?? "").trim();
+  if (!orderId || !marketDisplayName) return null;
+  const isBuy = parseArcusSideIsBuy(row.side);
+  if (isBuy == null) return null;
+  const stepSize = marketStepSize(markets, marketDisplayName);
+  const step = stepSize ? parsePositiveDecimal(stepSize) : null;
+  let sizeHuman = String(row.sizeHuman ?? row.remainingSize ?? row.size ?? "").trim() || null;
+  if (sizeHuman && step != null) {
+    const asNum = Number(sizeHuman);
+    if (Number.isFinite(asNum) && asNum > 0 && asNum < 1e6) {
+      sizeHuman = formatArcusDisplaySize(asNum * step, stepSize);
+    }
+  }
+  const priceRaw = String(row.price ?? row.limitPx ?? "").trim();
+  return {
+    orderId,
+    marketDisplayName,
+    isBuy,
+    limitPxHuman: priceRaw || null,
+    sizeHuman,
+    reduceOnly: Boolean(row.reduceOnly) || Number(row.reduceOnly) === 1,
+    isTrigger: Boolean(row.isTrigger) || String(row.orderType ?? "").toUpperCase().includes("STOP")
+  };
+}
+function arcusParseAccountSummary(account) {
+  if (!account) {
+    return { freeCollateralUsd: null, equityUsd: null, marginUsedUsd: null };
+  }
+  return {
+    freeCollateralUsd: String(account.freeCollateral ?? "").trim() || null,
+    equityUsd: String(account.equity ?? account.accountValue ?? "").trim() || null,
+    marginUsedUsd: String(account.marginUsed ?? account.totalMarginUsed ?? "").trim() || null
+  };
+}
+function arcusMapPositionDisplayRows(rawPositions, markets) {
+  return rawPositions.map((raw) => arcusParsePositionDisplayRow(raw, markets)).filter((row) => row != null);
+}
+function arcusMapOpenOrderDisplayRows(rawOrders, markets) {
+  return rawOrders.map((raw) => arcusParseOpenOrderDisplayRow(raw, markets)).filter((row) => row != null);
+}
+init_api();
+init_constants();
+var ZERO_ADDRESS2 = "0x0000000000000000000000000000000000000000";
+async function buildArcusSpotRfqMultisign(args) {
+  const paired = assertArcusPairedKeyGens({
+    secp256k1KeyGen: args.secp256k1KeyGen,
+    ed25519KeyGen: args.ed25519KeyGen
+  });
+  const address = getAddress(args.executorAddress);
+  const { tokens } = await arcusFetchSpotOverview({ chainId: args.chainId });
+  const ticker = args.ticker.trim().toUpperCase();
+  const token = tokens.find((t) => t.ticker.toUpperCase() === ticker);
+  if (!token) throw new Error(`Arcus spot token not found: ${ticker}`);
+  const timestampNs = arcusNanosecondTimestamp();
+  const body = {
+    address: address.toLowerCase(),
+    ticker: token.ticker,
+    side: args.isBuy ? "BUY" : "SELL",
+    size: args.sizeHuman.trim(),
+    tokenContractAddress: token.contractAddress.toLowerCase()
+  };
+  if (args.limitPxHuman?.trim()) {
+    body.limitPrice = args.limitPxHuman.trim();
+  }
+  const canonical = arcusCanonicalJson(body);
+  const action = args.isBuy ? "spotBuy" : "spotSell";
+  const messageUtf8 = `${timestampNs}${action}${canonical}`;
+  return buildPayloadSignEd25519MultisignBody({
+    keyGen: paired.ed25519,
+    purposeText: args.purposeText,
+    destinationChainID: String(args.chainId),
+    destinationAddress: ZERO_ADDRESS2,
+    messageUtf8,
+    billingKeyGenPubKey: paired.secp256k1.pubkeyhex,
+    expiryDate: args.expiryDate,
+    signatureText: `Arcus spot RFQ ${action}`,
+    delivery: {
+      kind: "arcus_spot_rfq",
+      chainId: args.chainId,
+      endpoint: action,
+      timestampNs,
+      scheme: 2,
+      apiKeyPubKeyHex: paired.ed25519.pubkeyhex,
+      body,
+      tokenContractAddress: token.contractAddress,
+      tokenSymbol: token.ticker,
+      tokenName: token.name
+    },
+    audit: {
+      protocol: ARCUS_PROTOCOL_ID,
+      action,
+      marketKind: "spot",
+      ticker: token.ticker,
+      isBuy: args.isBuy,
+      sizeHuman: args.sizeHuman,
+      limitPxHuman: args.limitPxHuman ?? null
+    }
+  });
+}
+async function buildEvmMultisignBodyArcusSpotRfqBatch(args) {
+  return buildArcusSpotRfqMultisign(args);
+}
+
+// src/protocols/evm/arcus/bridgeConstants.ts
+init_constants();
+var ARCUS_BRIDGE_VAULT_4663 = "0x14b107cf534239c59571b066cB6497a321Da897c";
+var ARCUS_DEPOSIT_PROXY_4663 = "0xD42c46c7BaD6A54b38395F846b09981CE75fb8e2";
+var ARCUS_USDG_DECIMALS = 6;
+var ARCUS_QUOTE_QUANTUMS_PER_USD = 1000000000n;
+var ARCUS_MIN_WITHDRAW_USD = 1;
+var ARCUS_PERP_ACCOUNT_INDEX = 0;
+var ARCUS_SPOT_ACCOUNT_INDEX = 1;
+function arcusAccountIndexForProduct(product) {
+  return product === "spot" ? ARCUS_SPOT_ACCOUNT_INDEX : ARCUS_PERP_ACCOUNT_INDEX;
+}
+function arcusBridgeConfig(chainId) {
+  if (chainId !== 4663) return null;
+  return {
+    chainId,
+    usdg: ARCUS_USDG_ADDRESS_4663,
+    depositProxy: ARCUS_DEPOSIT_PROXY_4663,
+    bridgeVault: ARCUS_BRIDGE_VAULT_4663,
+    usdgDecimals: ARCUS_USDG_DECIMALS
+  };
+}
+var ARCUS_WITHDRAW_EIP712_DOMAIN_NAME = "Arcus Withdraw";
+var ARCUS_WITHDRAW_EIP712_DOMAIN_VERSION = "1";
+var ARCUS_WITHDRAW_SIGN_TYPES = {
+  Withdraw: [
+    { name: "ethereumAddress", type: "address" },
+    { name: "accountIndex", type: "uint8" },
+    { name: "amount", type: "uint256" },
+    { name: "nonce", type: "string" }
+  ]
+};
+function parseArcusUsdHumanToQuoteQuantums(usdHuman) {
+  const trimmed = usdHuman.trim().replace(/,/g, "");
+  if (!trimmed || !/^\d+(\.\d+)?$/.test(trimmed)) {
+    throw new Error("usdHuman must be a positive decimal string");
+  }
+  const [whole, frac = ""] = trimmed.split(".");
+  const frac9 = (frac + "000000000").slice(0, 9);
+  const quantums = BigInt(whole) * 1000000000n + BigInt(frac9 || "0");
+  if (quantums <= 0n) throw new Error("usdHuman must be greater than zero");
+  return quantums;
+}
+function parseArcusUsdHumanToUsdgWei(usdHuman) {
+  const trimmed = usdHuman.trim().replace(/,/g, "");
+  if (!trimmed || !/^\d+(\.\d+)?$/.test(trimmed)) {
+    throw new Error("usdHuman must be a positive decimal string");
+  }
+  const [whole, frac = ""] = trimmed.split(".");
+  const frac6 = (frac + "000000").slice(0, 6);
+  const wei = BigInt(whole) * 1000000n + BigInt(frac6 || "0");
+  if (wei <= 0n) throw new Error("usdHuman must be greater than zero");
+  return wei;
+}
+function buildArcusWithdrawTypedData(args) {
+  const cfg = arcusBridgeConfig(args.chainId);
+  if (!cfg) throw new Error("Arcus fund flows are supported on Robinhood Chain (4663) only.");
+  const address = getAddress(args.executorAddress);
+  const amount = parseArcusUsdHumanToQuoteQuantums(args.usdHuman);
+  const nonce = args.nonceNs ?? arcusNanosecondTimestamp();
+  const accountIndex = arcusAccountIndexForProduct(args.product);
+  return {
+    domain: {
+      name: ARCUS_WITHDRAW_EIP712_DOMAIN_NAME,
+      version: ARCUS_WITHDRAW_EIP712_DOMAIN_VERSION,
+      chainId: cfg.chainId,
+      verifyingContract: getAddress(cfg.bridgeVault)
+    },
+    types: ARCUS_WITHDRAW_SIGN_TYPES,
+    primaryType: "Withdraw",
+    message: {
+      ethereumAddress: address,
+      accountIndex,
+      amount,
+      nonce
+    },
+    requestBody: {
+      ethereumAddress: address.toLowerCase(),
+      accountIndex,
+      amount: amount.toString(),
+      nonce
+    }
+  };
+}
+function routerSwapGasLimitFromEstimate(estimatedGas, chainGasLimit) {
+  if (chainGasLimit != null && Number.isFinite(chainGasLimit) && chainGasLimit > 0) {
+    return gasLimitFromEstimateAndChainConfig(estimatedGas, chainGasLimit);
+  }
+  return (estimatedGas * 12n + 9n) / 10n;
+}
+
+// src/chains/evm/buildBatch.ts
+async function buildEvmMultisignBatch(args) {
+  const { context, steps } = args;
+  const {
+    chainId,
+    rpcUrl,
+    executorAddress,
+    chainDetail,
+    useCustomGas,
+    customGasChainDetails,
+    keyGen,
+    purposeText
+  } = context;
+  if (steps.length === 0) throw new Error("buildEvmMultisignBatch requires at least one step");
+  const ch = defineChain({
+    id: chainId,
+    name: "Destination",
+    nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
+    rpcUrls: { default: { http: [rpcUrl] } }
+  });
+  const publicClient = createPublicClient({ chain: ch, transport: http(rpcUrl) });
+  const feeParams = await fetchChainFeeParams(rpcUrl, chainId);
+  const legacy = Boolean(chainDetail?.legacy) || !feeParams.isEip1559;
+  const latestBaseFeeWei = !legacy ? (await publicClient.getBlock({ blockTag: "latest" })).baseFeePerGas ?? 0n : 0n;
+  const gasLimitConfig = useCustomGas && chainDetail?.gasLimit != null ? Number(chainDetail.gasLimit) : void 0;
+  const chainGasLimitRouter = chainDetail?.gasLimit != null && Number.isFinite(Number(chainDetail.gasLimit)) && Number(chainDetail.gasLimit) > 0 ? Number(chainDetail.gasLimit) : void 0;
+  const gasFeeMultiplier = useCustomGas && chainDetail?.gasMultiplier != null ? Number(chainDetail.gasMultiplier) : void 0;
+  const executor = getAddress(executorAddress);
+  const baseNonce = await publicClient.getTransactionCount({ address: executor, blockTag: "pending" });
+  const legs = [];
+  for (let i = 0; i < steps.length; i++) {
+    const step = steps[i];
+    const currentNonce = baseNonce + i;
+    let estimatedGas;
+    if (args.estimateGasForStep) {
+      estimatedGas = await args.estimateGasForStep({ step, index: i, publicClient, executor });
+    } else {
+      try {
+        estimatedGas = await publicClient.estimateGas({
+          to: step.to,
+          data: step.data,
+          value: step.value,
+          account: executor
+        });
+      } catch {
+        estimatedGas = step.fallbackGas ?? 100000n;
+      }
+    }
+    let gasLimitI;
+    if (args.resolveGasLimit) {
+      gasLimitI = await args.resolveGasLimit({ step, index: i, estimatedGas, publicClient });
+    } else if (step.routerSwap) {
+      gasLimitI = routerSwapGasLimitFromEstimate(estimatedGas, chainGasLimitRouter);
+    } else {
+      gasLimitI = useCustomGas ? gasLimitFromEstimateAndChainConfig(estimatedGas, gasLimitConfig) : estimatedGas;
+    }
+    let proposalTxParams;
+    let feeSnapshot;
+    let serialized;
+    if (legacy) {
+      let gasPriceWei = await publicClient.getGasPrice();
+      if (useCustomGas && gasFeeMultiplier != null && gasFeeMultiplier > 0) {
+        gasPriceWei = gasPriceWei * BigInt(100 + gasFeeMultiplier) / 100n;
+      }
+      if (useCustomGas && chainDetail?.gasPrice != null && chainDetail.gasPrice > 0) {
+        const configured = parseGwei(gweiToDecimalString(Number(chainDetail.gasPrice)));
+        if (configured > gasPriceWei) gasPriceWei = configured;
+      }
+      serialized = serializeTransaction({
+        type: "legacy",
+        to: step.to,
+        data: step.data,
+        value: step.value,
+        gas: gasLimitI,
+        gasPrice: gasPriceWei,
+        nonce: currentNonce,
+        chainId
+      });
+      proposalTxParams = {
+        nonce: currentNonce,
+        gasLimit: gasLimitI.toString(),
+        txType: "legacy",
+        gasPrice: gasPriceWei.toString()
+      };
+      feeSnapshot = proposalTxParamsToFeeSnapshot(proposalTxParams);
+    } else {
+      const fetchedBase = feeParams.baseFeeGwei ?? 0;
+      const fetchedPriority = feeParams.priorityFeeGwei ?? 0;
+      const configuredBase = useCustomGas && chainDetail?.baseFee != null ? Number(chainDetail.baseFee) : 0;
+      const configuredPriority = useCustomGas && chainDetail?.priorityFee != null ? Number(chainDetail.priorityFee) : 0;
+      const effectiveBaseFeeGwei = Math.max(fetchedBase, configuredBase);
+      const effectivePriorityFeeGwei = Math.max(fetchedPriority, configuredPriority);
+      const baseFeeMultiplierPct = useCustomGas && chainDetail?.baseFeeMultiplier != null ? Math.max(100, Number(chainDetail.baseFeeMultiplier)) : 100;
+      const baseComponentGwei = effectiveBaseFeeGwei * baseFeeMultiplierPct / 100;
+      const maxFeePerGasGwei = baseComponentGwei + effectivePriorityFeeGwei;
+      let maxPriorityFeePerGas = effectivePriorityFeeGwei > 0 ? parseGwei(gweiToDecimalString(effectivePriorityFeeGwei)) : parseGwei("1");
+      let maxFeePerGas = parseGwei(gweiToDecimalString(maxFeePerGasGwei));
+      if (useCustomGas && gasFeeMultiplier != null && gasFeeMultiplier > 0) {
+        maxPriorityFeePerGas = maxPriorityFeePerGas * BigInt(100 + gasFeeMultiplier) / 100n;
+        maxFeePerGas = maxFeePerGas * BigInt(100 + gasFeeMultiplier) / 100n;
+      }
+      ({ maxFeePerGas, maxPriorityFeePerGas } = alignEip1559FeesWithLatestBase(
+        maxFeePerGas,
+        maxPriorityFeePerGas,
+        latestBaseFeeWei
+      ));
+      serialized = serializeTransaction({
+        type: "eip1559",
+        to: step.to,
+        data: step.data,
+        value: step.value,
+        gas: gasLimitI,
+        maxFeePerGas,
+        maxPriorityFeePerGas,
+        nonce: currentNonce,
+        chainId
+      });
+      proposalTxParams = {
+        nonce: currentNonce,
+        gasLimit: gasLimitI.toString(),
+        txType: "eip1559",
+        maxFeePerGas: maxFeePerGas.toString(),
+        maxPriorityFeePerGas: maxPriorityFeePerGas.toString()
+      };
+      feeSnapshot = i === 0 ? proposalTxParamsToFeeSnapshot(proposalTxParams) : {};
+    }
+    const h = keccak256(serialized);
+    const msgHash = h.startsWith("0x") ? h.slice(2) : h;
+    const batchMetaExtra = args.buildBatchMeta({ step, index: i, gasLimit: gasLimitI });
+    legs.push({
+      msgHash,
+      msgRaw: i === 0 && args.firstMsgRawNo0x != null ? args.firstMsgRawNo0x : serialized,
+      destinationAddress: step.to,
+      signatureText: typeof batchMetaExtra.signatureText === "string" ? batchMetaExtra.signatureText : JSON.stringify(batchMetaExtra.signatureText ?? {}),
+      audit: batchMetaExtra,
+      feeSnapshot: i === 0 ? feeSnapshot : {},
+      proposalTxParams,
+      valueWei: i === 0 ? step.value : void 0
+    });
+    if (i === 0 && args.firstMsgRawNo0x != null) {
+      legs[0].msgRaw = args.firstMsgRawNo0x;
+    }
+  }
+  const extraJSON = {};
+  if (useCustomGas && customGasChainDetails && Object.keys(customGasChainDetails).length > 0) {
+    extraJSON.customGasChainDetails = customGasChainDetails;
+  }
+  const result = finalizeMultisign({
+    keyGen,
+    purposeText,
+    purposeSuffix: args.purposeSuffix,
+    destinationChainID: String(chainId),
+    destinationAddress: args.destinationAddress ?? steps[0].to,
+    legs,
+    extraJSON: Object.keys(extraJSON).length > 0 ? extraJSON : void 0,
+    expiryDate: context.expiryDate
+  });
+  const pv = args.payableValueWei;
+  if (pv != null && pv > 0n) {
+    result.bodyForSign.value = pv.toString();
+  }
+  return result;
+}
+var EIP712_SIGN_REQUEST_KIND = "eip712";
+function msgHashNo0x(digest) {
+  return digest.startsWith("0x") ? digest.slice(2) : digest;
+}
+function eip712SignatureText(domain, primaryType) {
+  return JSON.stringify({
+    kind: "EIP-712",
+    ...typeof domain.name === "string" ? { name: domain.name } : {},
+    primaryType
+  });
+}
+function jsonStringifyForAudit(value) {
+  return JSON.stringify(value, (_, v) => typeof v === "bigint" ? v.toString() : v);
+}
+function eip712MsgRawHex(typedData, delivery) {
+  const envelope = {
+    version: 1,
+    ...typedData,
+    delivery
+  };
+  return stringToHex(jsonStringifyForAudit(envelope));
+}
+function buildEip712MultisignBody(args) {
+  const { typedData, delivery } = args;
+  const digest = hashTypedData({
+    domain: typedData.domain,
+    types: typedData.types,
+    primaryType: typedData.primaryType,
+    message: typedData.message
+  });
+  const extraJSON = {
+    signRequestKind: EIP712_SIGN_REQUEST_KIND,
+    eip712: {
+      version: 1,
+      digest,
+      domain: typedData.domain,
+      types: typedData.types,
+      primaryType: typedData.primaryType,
+      message: typedData.message
+    },
+    delivery
+  };
+  return finalizeMultisign({
+    keyGen: args.keyGen,
+    purposeText: args.purposeText,
+    purposeSuffix: args.purposeSuffix,
+    destinationChainID: args.destinationChainID,
+    destinationAddress: args.destinationAddress,
+    extraJSON,
+    expiryDate: args.expiryDate,
+    legs: [
+      {
+        msgHash: msgHashNo0x(digest),
+        msgRaw: eip712MsgRawHex(typedData, delivery),
+        destinationAddress: args.destinationAddress,
+        signatureText: eip712SignatureText(typedData.domain, typedData.primaryType),
+        audit: {
+          kind: "EIP712",
+          primaryType: typedData.primaryType,
+          deliveryKind: delivery.kind,
+          ...args.audit ?? {}
+        },
+        feeSnapshot: {}
+      }
+    ]
+  });
+}
+
+// src/protocols/evm/arcus/fundMultisign.ts
+init_support();
+init_constants();
+
+// src/protocols/evm/arcus/registration.ts
+init_api();
+async function assertArcusAddressRegisteredForDeposit(args) {
+  const address = getAddress(args.executorAddress).toLowerCase();
+  const { apiKeys } = await arcusFetchApiKeys({ chainId: args.chainId, address });
+  if (!Array.isArray(apiKeys) || apiKeys.length === 0) {
+    throw new Error(
+      "Arcus deposit requires a registered API key for this address. Complete Setup (createApiKey) first."
+    );
+  }
+}
+async function arcusAddressHasRegisteredApiKey(args) {
+  try {
+    await assertArcusAddressRegisteredForDeposit({
+      chainId: args.chainId,
+      executorAddress: getAddress(args.executorAddress.trim())
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/protocols/evm/arcus/fundMultisign.ts
+var erc20ApproveAbi = parseAbi(["function approve(address spender, uint256 amount) returns (bool)"]);
+var depositProxyAbi = parseAbi([
+  "function initiateDeposit(address owner, uint16 accountIndex, address token, uint256 amount) returns (uint64 inboxIndex)"
+]);
+var DEPOSIT_APPROVE_FALLBACK_GAS = 80000n;
+var DEPOSIT_INITIATE_FALLBACK_GAS = 350000n;
+async function buildArcusDepositMultisign(args) {
+  if (!isArcusChainSupported(args.chainId)) {
+    throw new Error("chainId must be 4663 (Robinhood Chain)");
+  }
+  await assertArcusAddressRegisteredForDeposit({
+    chainId: args.chainId,
+    executorAddress: getAddress(args.executorAddress)
+  });
+  const cfg = arcusBridgeConfig(args.chainId);
+  if (!cfg) throw new Error("Arcus deposit is not configured for this chain.");
+  const amountWei = parseArcusUsdHumanToUsdgWei(args.usdHuman);
+  const executor = getAddress(args.executorAddress);
+  const accountIndex = args.product === "spot" ? 1 : 0;
+  const usdg = getAddress(cfg.usdg);
+  const depositProxy = getAddress(cfg.depositProxy);
+  const approveData = encodeFunctionData({
+    abi: erc20ApproveAbi,
+    functionName: "approve",
+    args: [depositProxy, amountWei]
+  });
+  const depositData = encodeFunctionData({
+    abi: depositProxyAbi,
+    functionName: "initiateDeposit",
+    args: [executor, accountIndex, usdg, amountWei]
+  });
+  return buildEvmMultisignBatch({
+    context: {
+      keyGen: args.keyGen,
+      chainCategory: "evm",
+      chainId: args.chainId,
+      rpcUrl: args.rpcUrl,
+      chainDetail: args.chainDetail,
+      useCustomGas: args.useCustomGas,
+      customGasChainDetails: args.customGasChainDetails ?? null,
+      executorAddress: executor,
+      purposeText: args.purposeText
+    },
+    steps: [
+      { to: usdg, data: approveData, value: 0n, fallbackGas: DEPOSIT_APPROVE_FALLBACK_GAS },
+      { to: depositProxy, data: depositData, value: 0n, fallbackGas: DEPOSIT_INITIATE_FALLBACK_GAS }
+    ],
+    destinationAddress: depositProxy,
+    buildBatchMeta: ({ index }) => {
+      if (index === 0) {
+        return {
+          kind: "Arcus",
+          action: "depositApprove",
+          product: args.product,
+          accountIndex,
+          usdg,
+          depositProxy,
+          usdHuman: args.usdHuman,
+          evm: { type: "arcus_deposit_approve", version: 1, chainId: String(args.chainId) }
+        };
+      }
+      return {
+        kind: "Arcus",
+        action: "deposit",
+        product: args.product,
+        accountIndex,
+        usdg,
+        depositProxy,
+        usdHuman: args.usdHuman,
+        evm: { type: "arcus_deposit_initiate", version: 1, chainId: String(args.chainId) }
+      };
+    }
+  });
+}
+async function buildArcusWithdrawMultisign(args) {
+  if (!isArcusChainSupported(args.chainId)) {
+    throw new Error("chainId must be 4663 (Robinhood Chain)");
+  }
+  const minQuantums = ARCUS_QUOTE_QUANTUMS_PER_USD * BigInt(ARCUS_MIN_WITHDRAW_USD);
+  const typed = buildArcusWithdrawTypedData({
+    chainId: args.chainId,
+    executorAddress: args.executorAddress,
+    product: args.product,
+    usdHuman: args.usdHuman
+  });
+  if (typed.message.amount < minQuantums) {
+    throw new Error(`Arcus withdraw must be at least ${ARCUS_MIN_WITHDRAW_USD} USD`);
+  }
+  return buildEip712MultisignBody({
+    keyGen: args.keyGen,
+    purposeText: args.purposeText,
+    destinationChainID: String(args.chainId),
+    destinationAddress: getAddress(args.executorAddress),
+    typedData: typed,
+    delivery: {
+      kind: "arcus_withdraw",
+      chainId: args.chainId,
+      product: args.product,
+      accountIndex: typed.message.accountIndex,
+      body: typed.requestBody
+    },
+    audit: {
+      protocol: ARCUS_PROTOCOL_ID,
+      action: "withdraw",
+      product: args.product,
+      usdHuman: args.usdHuman,
+      accountIndex: typed.message.accountIndex,
+      nonce: typed.message.nonce
+    }
+  });
+}
+async function buildEvmMultisignBodyArcusDepositBatch(args) {
+  return buildArcusDepositMultisign(args);
+}
+async function buildArcusWithdrawMultisignBody(args) {
+  return buildArcusWithdrawMultisign(args);
+}
+
+// src/protocols/evm/arcus/index.ts
+init_constants();
+var arcusProtocolModule = {
+  id: ARCUS_PROTOCOL_ID,
+  chainCategory: "evm",
+  isChainSupported(ctx) {
+    if (ctx.chainCategory !== "evm") return false;
+    const chainId = typeof ctx.chainId === "number" ? ctx.chainId : Number(ctx.chainId);
+    return Number.isFinite(chainId) && isArcusChainSupported(chainId);
+  },
+  isTokenSupported(token) {
+    if (token.category !== "evm") return false;
+    return token.kind === "erc20" || token.kind === "native";
+  },
+  actions: [
+    {
+      id: "arcus.createApiKey",
+      protocolId: ARCUS_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Register Arcus Ed25519 API key (secp256k1 personal_sign + paired ed25519 KeyGen)",
+      commonParams: ["keyGen", "purposeText"],
+      params: {
+        secp256k1KeyGenId: { type: "string", required: true, description: "Custody secp256k1 KeyGen id" },
+        ed25519KeyGenId: { type: "string", required: true, description: "Paired ed25519 KeyGen id (same GroupId)" },
+        apiWalletName: { type: "string", required: false, description: "Label for the API key" }
+      }
+    },
+    {
+      id: "arcus.placeOrder",
+      protocolId: ARCUS_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Place Arcus perp order with optional TP/SL (Ed25519 payload sign)",
+      commonParams: ["keyGen", "purposeText"],
+      params: {
+        secp256k1KeyGenId: { type: "string", required: true, description: "Custody secp256k1 KeyGen id" },
+        ed25519KeyGenId: { type: "string", required: true, description: "Paired ed25519 KeyGen id" },
+        market: { type: "string", required: true, description: "e.g. BTC-USD" },
+        isBuy: { type: "boolean", required: true, description: "true for buy/long" },
+        limitPxHuman: { type: "string", required: true, description: "Entry limit price" },
+        szHuman: { type: "string", required: true, description: "Order size" },
+        takeProfitTriggerPxHuman: { type: "string", required: false, description: "Optional TP trigger" },
+        stopLossTriggerPxHuman: { type: "string", required: false, description: "Optional SL trigger" }
+      }
+    },
+    {
+      id: "arcus.spotRfq",
+      protocolId: ARCUS_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Arcus spot Stock Token RFQ buy/sell",
+      commonParams: ["keyGen", "purposeText"],
+      params: {
+        secp256k1KeyGenId: { type: "string", required: true, description: "Custody secp256k1 KeyGen id" },
+        ed25519KeyGenId: { type: "string", required: true, description: "Paired ed25519 KeyGen id" },
+        ticker: { type: "string", required: true, description: "Spot ticker e.g. AAPL" },
+        isBuy: { type: "boolean", required: true, description: "true for buy" },
+        sizeHuman: { type: "string", required: true, description: "Token size" },
+        limitPxHuman: { type: "string", required: false, description: "Optional limit price" }
+      }
+    },
+    {
+      id: "arcus.close",
+      protocolId: ARCUS_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Close Arcus perp position with IoC reduce-only limit order",
+      commonParams: ["keyGen", "purposeText"],
+      params: {
+        secp256k1KeyGenId: { type: "string", required: true, description: "Custody secp256k1 KeyGen id" },
+        ed25519KeyGenId: { type: "string", required: true, description: "Paired ed25519 KeyGen id" },
+        market: { type: "string", required: true, description: "Perp market" },
+        isLong: { type: "boolean", required: true, description: "true when closing a long position" },
+        limitPxHuman: { type: "string", required: true, description: "Limit price for IoC close" },
+        szHuman: { type: "string", required: true, description: "Size to close" }
+      }
+    },
+    {
+      id: "arcus.cancelOrder",
+      protocolId: ARCUS_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Cancel Arcus perp order",
+      commonParams: ["keyGen", "purposeText"],
+      params: {
+        secp256k1KeyGenId: { type: "string", required: true, description: "Custody secp256k1 KeyGen id" },
+        ed25519KeyGenId: { type: "string", required: true, description: "Paired ed25519 KeyGen id" },
+        market: { type: "string", required: true, description: "Perp market" },
+        orderId: { type: "string", required: true, description: "Server order id" }
+      }
+    },
+    {
+      id: "arcus.setLeverage",
+      protocolId: ARCUS_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Set Arcus perp leverage for a market",
+      commonParams: ["keyGen", "purposeText"],
+      params: {
+        secp256k1KeyGenId: { type: "string", required: true, description: "Custody secp256k1 KeyGen id" },
+        ed25519KeyGenId: { type: "string", required: true, description: "Paired ed25519 KeyGen id" },
+        market: { type: "string", required: true, description: "Perp market" },
+        leverage: { type: "number", required: true, description: "Target leverage" }
+      }
+    },
+    {
+      id: "arcus.deposit",
+      protocolId: ARCUS_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Deposit USDG on Robinhood Chain into Arcus perp or spot collateral (approve + initiateDeposit). Requires registered API key.",
+      commonParams: ["keyGen", "purposeText", "useCustomGas"],
+      params: {
+        usdHuman: { type: "string", required: true, description: "USD amount to deposit" },
+        product: { type: "string", required: false, description: "perp (default) or spot" }
+      }
+    },
+    {
+      id: "arcus.withdraw",
+      protocolId: ARCUS_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Withdraw USDG collateral from Arcus to wallet (EIP-712 + POST /v1/withdraw)",
+      commonParams: ["keyGen", "purposeText"],
+      params: {
+        usdHuman: { type: "string", required: true, description: "USD amount to withdraw" },
+        product: { type: "string", required: false, description: "perp (default) or spot" }
+      }
+    }
+  ]
+};
+registerProtocolModule(arcusProtocolModule);
+
+export { ARCUS_BRIDGE_VAULT_4663, ARCUS_DEFAULT_CANDLE_COUNT, ARCUS_DEFAULT_LOOKBACK_DAYS, ARCUS_DEFAULT_OHLCV_INTERVAL, ARCUS_DEPOSIT_PROXY_4663, ARCUS_MAX_CANDLE_COUNT, ARCUS_MIN_WITHDRAW_USD, ARCUS_PERP_ACCOUNT_INDEX, ARCUS_PERP_INTERVAL_MS, ARCUS_PERP_MARKET_STATUS_ONLINE, ARCUS_PERP_OHLCV_INTERVALS, ARCUS_PROTOCOL_ID, ARCUS_QUOTE_QUANTUMS_PER_USD, ARCUS_SPOT_ACCOUNT_INDEX, ARCUS_SPOT_INTERVAL_SEC, ARCUS_SPOT_OHLCV_INTERVALS, ARCUS_SUPPORTED_CHAIN_IDS, ARCUS_USDG_ADDRESS_4663, ARCUS_USDG_DECIMALS, ARCUS_WITHDRAW_EIP712_DOMAIN_NAME, ARCUS_WITHDRAW_EIP712_DOMAIN_VERSION, ARCUS_WITHDRAW_SIGN_TYPES, arcusAccountIndexForProduct, arcusAddressHasRegisteredApiKey, arcusApiMetaBaseUrl, arcusAssertPerpMarketOnline, arcusBridgeConfig, arcusCanonicalJson, arcusFetchAccount, arcusFetchAccountLeverages, arcusFetchAccountSummary, arcusFetchAllMids, arcusFetchApiKeys, arcusFetchLeveragesSummary, arcusFetchMarketSnapshotSummary, arcusFetchMarketsSummary, arcusFetchOhlcvSummary, arcusFetchOpenContextSummary, arcusFetchOpenOrders, arcusFetchOpenOrdersSummary, arcusFetchPerpCandles, arcusFetchPerpMarkets, arcusFetchPerpOhlcvRange, arcusFetchPositions, arcusFetchPositionsSummary, arcusFetchSpotBalances, arcusFetchSpotOhlcvRange, arcusFetchSpotOverview, arcusFetchSpotTokenCandles, arcusIsPerpMarketOnline, arcusLookupMidFromMids, arcusMapOpenOrderDisplayRows, arcusMapPerpCandles, arcusMapPositionDisplayRows, arcusMapSpotCandles, arcusMaxLeverageFromInitialMarginFraction, arcusNanosecondTimestamp, arcusOrderClosesPosition, arcusOrderCountsAsPendingClose, arcusParseAccountSummary, arcusParseOpenOrderDisplayRow, arcusParsePositionDisplayRow, arcusPayloadMessageHex, arcusPayloadMsgHashHex, arcusPendingCloseByMarket, arcusPendingCloseForPosition, arcusPerpApiBaseUrl, arcusProtocolModule, arcusResolveEffectiveLeverage, arcusResolvePerpMarketDisplayName, arcusResolvePerpOhlcvWindow, arcusSearchMarketsSummary, arcusSearchPerpMarkets, arcusSearchSpotMarkets, arcusSpotFetchBalancesSummary, arcusSpotFetchMarketsSummary, arcusSpotFetchOhlcvSummary, arcusSpotIndexerBaseUrl, arcusSpotSearchMarketsSummary, assertArcusAddressRegisteredForDeposit, buildArcusCancelOrderMultisign, buildArcusCancelOrderPayload, buildArcusCloseMultisign, buildArcusCreateApiKeyMultisign, buildArcusDepositMultisign, buildArcusPlaceOrderMultisign, buildArcusPlaceOrderPayload, buildArcusSetLeverageMultisign, buildArcusSpotRfqMultisign, buildArcusTpslPayload, buildArcusWithdrawMultisign, buildArcusWithdrawMultisignBody, buildArcusWithdrawTypedData, buildEvmMultisignBodyArcusCancelOrderBatch, buildEvmMultisignBodyArcusCloseBatch, buildEvmMultisignBodyArcusCreateApiKeyBatch, buildEvmMultisignBodyArcusDepositBatch, buildEvmMultisignBodyArcusPlaceOrderBatch, buildEvmMultisignBodyArcusSetLeverageBatch, buildEvmMultisignBodyArcusSpotRfqBatch, formatArcusDisplaySize, formatArcusLeverageLabel, humanPriceToQuantums, humanSizeToQuantums, isArcusChainSupported, parseArcusLeverageLabel, parseArcusUsdHumanToQuoteQuantums, parseArcusUsdHumanToUsdgWei };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map