@splitmarkets/sdk 0.2.0

package/dist/chunk-MZEPXYHI.js

@@ -0,0 +1,758 @@
+import { parseAbi, parseAbiItem, toHex, createPublicClient, http, keccak256, toBytes, encodeFunctionData, encodeAbiParameters, parseSignature, decodeEventLog, decodeAbiParameters } from 'viem';
+import { base, arbitrum } from 'viem/chains';
+import { privateKeyToAccount } from 'viem/accounts';
+
+// split.ts
+var BASE_CHAIN_ID = 8453;
+var ARB_CHAIN_ID = 42161;
+function chainIdOf(chain) {
+  return chain === "arbitrum" ? ARB_CHAIN_ID : BASE_CHAIN_ID;
+}
+var FACILITATOR_URL_BASE = "https://bundlerfix---b402-facilitator-base-posmj54s5q-uc.a.run.app";
+var FACILITATOR_URL_ARB = "https://b402-facilitator-arb-62092339396.us-central1.run.app";
+function facilitatorUrlForChain(chain) {
+  return chain === "arbitrum" ? FACILITATOR_URL_ARB : FACILITATOR_URL_BASE;
+}
+var NEXUS_FACTORY = "0x0000006648ED9B2B842552BE63Af870bC74af837";
+var NEXUS_BOOTSTRAP = "0x0000003eDf18913c01cBc482C978bBD3D6E8ffA3";
+function encodeNexusInitData(owner) {
+  const validatorInitData = owner.toLowerCase();
+  const bootstrapCall = encodeFunctionData({
+    abi: parseAbi(["function initNexusWithDefaultValidator(bytes data)"]),
+    functionName: "initNexusWithDefaultValidator",
+    args: [validatorInitData]
+  });
+  return encodeAbiParameters(
+    [{ type: "address" }, { type: "bytes" }],
+    [NEXUS_BOOTSTRAP, bootstrapCall]
+  );
+}
+function getMasterWalletSalt(owner) {
+  const normalized = owner.toLowerCase().slice(2);
+  const reversed = normalized.split("").reverse().join("");
+  return BigInt(keccak256(toBytes(`b402-${reversed}`)));
+}
+var nexusFactoryAbi = parseAbi([
+  "function computeAccountAddress(bytes initData, bytes32 salt) view returns (address)"
+]);
+async function deriveSmartWallet(owner, chain, rpcUrl) {
+  const salt = getMasterWalletSalt(owner);
+  const smartWallet = await getPublic(chain, rpcUrl).readContract({
+    address: NEXUS_FACTORY,
+    abi: nexusFactoryAbi,
+    functionName: "computeAccountAddress",
+    args: [encodeNexusInitData(owner), toHex(salt, { size: 32 })]
+  });
+  return { smartWallet, salt: salt.toString() };
+}
+var INCOGNITO_RESERVED_MESSAGE = "b402 Incognito EOA Derivation";
+var INCOGNITO_CACHE_KEY_PREFIX = "incognito_signature_v1_";
+var INCOGNITO_CACHE_DURATION = 24 * 60 * 60 * 1e3;
+var _sigMem = /* @__PURE__ */ new Map();
+var _inFlightSig = /* @__PURE__ */ new Map();
+function readCachedSig(cacheKey) {
+  const mem = _sigMem.get(cacheKey);
+  if (mem && Date.now() - mem.timestamp < INCOGNITO_CACHE_DURATION) return mem.signature;
+  if (typeof globalThis !== "undefined" && globalThis.sessionStorage) {
+    try {
+      const raw = globalThis.sessionStorage.getItem(cacheKey);
+      if (raw) {
+        const { signature, timestamp } = JSON.parse(raw);
+        if (signature && Date.now() - timestamp < INCOGNITO_CACHE_DURATION) return signature;
+      }
+    } catch {
+    }
+  }
+  return void 0;
+}
+function writeCachedSig(cacheKey, signature) {
+  _sigMem.set(cacheKey, { signature, timestamp: Date.now() });
+  if (typeof globalThis !== "undefined" && globalThis.sessionStorage) {
+    try {
+      globalThis.sessionStorage.setItem(
+        cacheKey,
+        JSON.stringify({ signature, timestamp: Date.now() })
+      );
+    } catch {
+    }
+  }
+}
+async function getCachedSignature(walletClient, account) {
+  const cacheKey = `${INCOGNITO_CACHE_KEY_PREFIX}${account.toLowerCase()}`;
+  const cached = readCachedSig(cacheKey);
+  if (cached) return cached;
+  const existing = _inFlightSig.get(cacheKey);
+  if (existing) return existing;
+  const p = (async () => {
+    const signing = walletClient.account ?? account;
+    const signature = await walletClient.signMessage({
+      account: signing,
+      message: INCOGNITO_RESERVED_MESSAGE
+    });
+    writeCachedSig(cacheKey, signature);
+    return signature;
+  })();
+  _inFlightSig.set(cacheKey, p);
+  try {
+    return await p;
+  } finally {
+    _inFlightSig.delete(cacheKey);
+  }
+}
+async function getIncognitoSigner(walletClient, account) {
+  const sig = await getCachedSignature(walletClient, account);
+  return privateKeyToAccount(keccak256(sig));
+}
+async function deriveTradingAccount(walletClient, account, chain = "base", rpcUrl) {
+  const signer = await getIncognitoSigner(walletClient, account);
+  const { smartWallet, salt } = await deriveSmartWallet(signer.address, chain, rpcUrl);
+  return {
+    eoa: account,
+    incognitoEOA: signer.address,
+    smartWallet,
+    salt,
+    // The 7579 validator authenticates the UserOp against the owner (incognito) key;
+    // signing the raw userOpHash with the in-memory account is SILENT.
+    signUserOpHash: (userOpHash) => signer.signMessage({ message: { raw: userOpHash } })
+  };
+}
+var approveAbi = parseAbi(["function approve(address spender, uint256 amount) returns (bool)"]);
+var transferAuthAbi = parseAbi([
+  "function transferWithAuthorization(address from, address to, uint256 value, uint256 validAfter, uint256 validBefore, bytes32 nonce, uint8 v, bytes32 r, bytes32 s)"
+]);
+var tokenMetaAbi = parseAbi([
+  "function name() view returns (string)",
+  "function version() view returns (string)"
+]);
+var TRANSFER_WITH_AUTH_TYPES = {
+  TransferWithAuthorization: [
+    { name: "from", type: "address" },
+    { name: "to", type: "address" },
+    { name: "value", type: "uint256" },
+    { name: "validAfter", type: "uint256" },
+    { name: "validBefore", type: "uint256" },
+    { name: "nonce", type: "bytes32" }
+  ]
+};
+async function buildEIP3009PullCall(args) {
+  const client = getPublic(args.chain, args.rpcUrl);
+  const [tokenName, tokenVersion] = await Promise.all([
+    client.readContract({ address: args.usdc, abi: tokenMetaAbi, functionName: "name" }),
+    client.readContract({ address: args.usdc, abi: tokenMetaAbi, functionName: "version" }).catch(
+      () => "2"
+    )
+  ]);
+  const domain = {
+    name: tokenName,
+    version: tokenVersion,
+    chainId: chainIdOf(args.chain),
+    verifyingContract: args.usdc
+  };
+  const validAfter = 0n;
+  const validBefore = BigInt(Math.floor(Date.now() / 1e3) + 3600);
+  const nonce = toHex(crypto.getRandomValues(new Uint8Array(32)));
+  const message = {
+    from: args.owner,
+    to: args.to,
+    value: args.value.toString(),
+    validAfter: validAfter.toString(),
+    validBefore: validBefore.toString(),
+    nonce
+  };
+  const sig = await args.walletClient.signTypedData({
+    // ACCOUNT OBJECT not address string — local wallets sign typed data in-memory;
+    // a string forces a json-rpc account → eth_signTypedData_v4 routed to the HTTP
+    // transport (no such method), which breaks embedded wallets.
+    account: args.walletClient.account ?? args.owner,
+    domain,
+    types: TRANSFER_WITH_AUTH_TYPES,
+    primaryType: "TransferWithAuthorization",
+    // uint256 fields are decimal strings (JSON-safe); viem's generic widens here.
+    message
+  });
+  const { r, s, v, yParity } = parseSignature(sig);
+  const vByte = Number(v ?? BigInt(yParity + 27));
+  return {
+    to: args.usdc,
+    value: "0",
+    data: encodeFunctionData({
+      abi: transferAuthAbi,
+      functionName: "transferWithAuthorization",
+      args: [args.owner, args.to, args.value, validAfter, validBefore, nonce, vByte, r, s]
+    })
+  };
+}
+var splitBuyAbi = parseAbi([
+  "function buyN(uint256 seriesId, uint256 qN, uint256 maxCost, (address,uint256,uint256,uint256,uint256) q, bytes sig) returns (uint256)"
+]);
+var splitSellAbi = parseAbi([
+  "function sellN(uint256 seriesId, uint256 qN, uint256 minProceeds, (address,uint256,uint256,uint256,uint256) q, bytes sig) returns (uint256)"
+]);
+function buildSplitPoolBuyCalls(pool, usdc, seriesId, qN, total, quote) {
+  return [
+    {
+      to: usdc,
+      value: "0",
+      data: encodeFunctionData({ abi: approveAbi, functionName: "approve", args: [pool, total] })
+    },
+    {
+      to: pool,
+      value: "0",
+      data: encodeFunctionData({
+        abi: splitBuyAbi,
+        functionName: "buyN",
+        args: [BigInt(seriesId), qN, total, quoteTuple(quote), quote.signature]
+      })
+    }
+  ];
+}
+function buildSplitPoolCloseCalls(pool, nToken, seriesId, qN, minProceeds, quote) {
+  return [
+    {
+      to: nToken,
+      value: "0",
+      data: encodeFunctionData({ abi: approveAbi, functionName: "approve", args: [pool, qN] })
+    },
+    {
+      to: pool,
+      value: "0",
+      data: encodeFunctionData({
+        abi: splitSellAbi,
+        functionName: "sellN",
+        args: [BigInt(seriesId), qN, minProceeds, quoteTuple(quote), quote.signature]
+      })
+    }
+  ];
+}
+async function gaslessExecute(args) {
+  const apiBase = args.facilitatorUrl.replace(/\/+$/, "").replace(/\/api\/v1$/, "") + "/api/v1";
+  const verifyRes = await fetch(`${apiBase}/wallet/incognito/verify`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      ownerEOA: args.owner,
+      walletAddress: args.walletAddress,
+      salt: args.salt,
+      calls: args.calls,
+      chainId: chainIdOf(args.chain)
+    })
+  });
+  if (!verifyRes.ok) {
+    throw new Error(`incognito/verify failed: ${verifyRes.status} ${await verifyRes.text()}`);
+  }
+  const verify = await verifyRes.json();
+  if (!verify.isValid || !verify.userOp || !verify.userOpHash) {
+    throw new Error(verify.invalidReason || "incognito/verify rejected the calls");
+  }
+  const signature = await args.signUserOpHash(verify.userOpHash);
+  const settleRes = await fetch(`${apiBase}/wallet/incognito/settle`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ userOp: { ...verify.userOp, signature } })
+  });
+  if (!settleRes.ok) {
+    throw new Error(`incognito/settle failed: ${settleRes.status} ${await settleRes.text()}`);
+  }
+  const settle = await settleRes.json();
+  if (!settle.txHash) throw new Error(settle.errorReason || "incognito/settle did not confirm");
+  const txHash = settle.txHash;
+  const userOpHash = settle.userOpHash ?? verify.userOpHash;
+  await assertUserOpSucceeded(args.client, txHash, userOpHash);
+  return { txHash, userOpHash };
+}
+var ENTRY_POINT_07 = "0x0000000071727De22E5E9d8BAf0edAc6f37da032";
+var ERROR_STRING_SELECTOR = "0x08c379a0";
+var userOpEventAbi = parseAbiItem(
+  "event UserOperationEvent(bytes32 indexed userOpHash, address indexed sender, address indexed paymaster, uint256 nonce, bool success, uint256 actualGasCost, uint256 actualGasUsed)"
+);
+var userOpRevertReasonAbi = parseAbiItem(
+  "event UserOperationRevertReason(bytes32 indexed userOpHash, address indexed sender, uint256 nonce, bytes revertReason)"
+);
+function decodeRevertReason(revertReason) {
+  try {
+    if (revertReason && revertReason.toLowerCase().startsWith(ERROR_STRING_SELECTOR)) {
+      const [reason] = decodeAbiParameters([{ type: "string" }], `0x${revertReason.slice(10)}`);
+      if (reason) return reason;
+    }
+  } catch {
+  }
+  return "trade reverted on-chain";
+}
+async function assertUserOpSucceeded(client, txHash, userOpHash) {
+  const receipt = await client.waitForTransactionReceipt({ hash: txHash });
+  const wantHash = userOpHash.toLowerCase();
+  let ourEvent;
+  for (const log of receipt.logs) {
+    if (log.address.toLowerCase() !== ENTRY_POINT_07.toLowerCase()) continue;
+    try {
+      const decoded = decodeEventLog({ abi: [userOpEventAbi], data: log.data, topics: log.topics });
+      if (decoded.eventName === "UserOperationEvent" && decoded.args.userOpHash.toLowerCase() === wantHash) {
+        ourEvent = { success: decoded.args.success };
+        break;
+      }
+    } catch {
+    }
+  }
+  if (!ourEvent || ourEvent.success) return;
+  let reason = "trade reverted on-chain";
+  for (const log of receipt.logs) {
+    if (log.address.toLowerCase() !== ENTRY_POINT_07.toLowerCase()) continue;
+    try {
+      const decoded = decodeEventLog({ abi: [userOpRevertReasonAbi], data: log.data, topics: log.topics });
+      if (decoded.eventName === "UserOperationRevertReason" && decoded.args.userOpHash.toLowerCase() === wantHash) {
+        reason = decodeRevertReason(decoded.args.revertReason);
+        break;
+      }
+    } catch {
+    }
+  }
+  throw new Error(`Trade reverted: ${reason}`);
+}
+var ONE = 10n ** 18n;
+var toNWei = (qN) => BigInt(Math.round(qN * 1e18));
+var quoteCost = (qNWei, perN) => (qNWei * perN + ONE - 1n) / ONE;
+var sellProceeds = (qNWei, perN) => qNWei * perN / ONE;
+function defaultFeeHeadroom(amount) {
+  const fivePct = amount * 5n / 100n;
+  const floor = 50000n;
+  return fivePct > floor ? fivePct : floor;
+}
+async function buyGasless(args) {
+  const { chain, side, seriesId } = args;
+  const pool = poolAddress(chain, side);
+  const usdc = CHAINS[chain].usdc;
+  const client = getPublic(chain, args.rpcUrl);
+  const trading = args.trading ?? await deriveTradingAccount(args.walletClient, args.account, chain, args.rpcUrl);
+  const quote = args.quote ?? await getQuote(chain, side, seriesId, args.apiUrl);
+  const qNWei = toNWei(args.qN);
+  const feeBps = await client.readContract({
+    address: pool,
+    abi: SPLIT_POOL_ABI,
+    functionName: "feeBps"
+  });
+  const cost = quoteCost(qNWei, BigInt(quote.askPerN));
+  const fee = cost * BigInt(feeBps) / 10000n;
+  const baseCost = cost + fee;
+  const slipBps = BigInt(args.slippageBps ?? 100);
+  const maxCost = baseCost + baseCost * slipBps / 10000n;
+  const grossNeed = maxCost + defaultFeeHeadroom(maxCost);
+  const smartBal = await client.readContract({
+    address: usdc,
+    abi: ERC20_ABI,
+    functionName: "balanceOf",
+    args: [trading.smartWallet]
+  });
+  const pullValue = grossNeed > smartBal ? grossNeed - smartBal : 0n;
+  if (pullValue > 0n) {
+    const eoaBal = await client.readContract({
+      address: usdc,
+      abi: ERC20_ABI,
+      functionName: "balanceOf",
+      args: [args.account]
+    });
+    if (eoaBal < pullValue) {
+      const need = (Number(pullValue) / 1e6).toFixed(2);
+      const have = (Number(eoaBal) / 1e6).toFixed(2);
+      throw new Error(`Insufficient USDC: need $${need} more, have $${have}.`);
+    }
+  }
+  const calls = [];
+  if (pullValue > 0n) {
+    calls.push(
+      await buildEIP3009PullCall({
+        walletClient: args.walletClient,
+        owner: args.account,
+        to: trading.smartWallet,
+        value: pullValue,
+        usdc,
+        chain,
+        rpcUrl: args.rpcUrl
+      })
+    );
+  }
+  calls.push(...buildSplitPoolBuyCalls(pool, usdc, seriesId, qNWei, maxCost, quote));
+  return gaslessExecute({
+    facilitatorUrl: args.facilitatorUrl ?? facilitatorUrlForChain(chain),
+    walletAddress: trading.smartWallet,
+    owner: trading.incognitoEOA,
+    salt: trading.salt,
+    calls,
+    signUserOpHash: trading.signUserOpHash,
+    chain,
+    client
+  });
+}
+async function closeGasless(args) {
+  const { chain, side, seriesId } = args;
+  const pool = poolAddress(chain, side);
+  const client = getPublic(chain, args.rpcUrl);
+  const trading = args.trading ?? await deriveTradingAccount(args.walletClient, args.account, chain, args.rpcUrl);
+  const quote = args.quote ?? await getQuote(chain, side, seriesId, args.apiUrl);
+  const nToken = await client.readContract({
+    address: quote.vault,
+    abi: SPLIT_VAULT_ABI,
+    functionName: "N"
+  });
+  const bal = await client.readContract({
+    address: nToken,
+    abi: ERC20_ABI,
+    functionName: "balanceOf",
+    args: [trading.smartWallet]
+  });
+  const qNWei = args.qN !== void 0 ? toNWei(args.qN) : bal;
+  if (qNWei <= 0n) throw new Error("close: nothing to close in the trading account");
+  if (qNWei > bal) throw new Error("close: qN exceeds the trading account's balance");
+  const feeBps = await client.readContract({
+    address: pool,
+    abi: SPLIT_POOL_ABI,
+    functionName: "feeBps"
+  });
+  const proceeds = sellProceeds(qNWei, BigInt(quote.bidPerN));
+  const fee = proceeds * BigInt(feeBps) / 10000n;
+  const net = proceeds - fee;
+  const slipBps = BigInt(args.slippageBps ?? 100);
+  const minProceeds = net - net * slipBps / 10000n;
+  const calls = buildSplitPoolCloseCalls(pool, nToken, seriesId, qNWei, minProceeds, quote);
+  return gaslessExecute({
+    facilitatorUrl: args.facilitatorUrl ?? facilitatorUrlForChain(chain),
+    walletAddress: trading.smartWallet,
+    owner: trading.incognitoEOA,
+    salt: trading.salt,
+    calls,
+    signUserOpHash: trading.signUserOpHash,
+    chain,
+    client
+  });
+}
+async function getPositionGasless(args) {
+  const { chain, side, seriesId } = args;
+  const pool = poolAddress(chain, side);
+  const client = getPublic(chain, args.rpcUrl);
+  const trading = args.trading ?? await deriveTradingAccount(args.walletClient, args.account, chain, args.rpcUrl);
+  const [epoch, spot6] = await Promise.all([
+    client.readContract({ address: pool, abi: SPLIT_POOL_ABI, functionName: "epoch" }),
+    client.readContract({ address: pool, abi: SPLIT_POOL_ABI, functionName: "spot6" }).catch(() => 0n)
+  ]);
+  const spot = Number(spot6) / 1e6;
+  const [vault, strikeRaw] = await client.readContract({
+    address: pool,
+    abi: SPLIT_POOL_ABI,
+    functionName: "seriesAt",
+    args: [epoch, BigInt(seriesId)]
+  });
+  const strike = Number(strikeRaw) / 1e6;
+  const nToken = await client.readContract({
+    address: vault,
+    abi: SPLIT_VAULT_ABI,
+    functionName: "N"
+  });
+  const bal = await client.readContract({
+    address: nToken,
+    abi: ERC20_ABI,
+    functionName: "balanceOf",
+    args: [trading.smartWallet]
+  });
+  const qN = Number(bal) / 1e18;
+  if (qN === 0) return { smartWallet: trading.smartWallet, qN: 0, markUsd: 0, intrinsicUsd: 0 };
+  const intrinsicPerN = side === "short" ? Math.max(0, strike - spot) : Math.max(0, spot - strike);
+  const intrinsicUsd = intrinsicPerN * qN;
+  let markUsd = intrinsicUsd;
+  try {
+    const q = await getQuote(chain, side, seriesId, args.apiUrl);
+    const ask = Number(q.askPerN) / 1e6;
+    const bid = Number(q.bidPerN) / 1e6;
+    const mid = ask > 0 && bid > 0 ? (ask + bid) / 2 : bid;
+    if (mid > 0) markUsd = mid * qN;
+  } catch {
+  }
+  return { smartWallet: trading.smartWallet, qN, markUsd, intrinsicUsd };
+}
+
+// split.ts
+var QUOTE_API = "https://quote-api-production-b5b9.up.railway.app";
+var CHAINS = {
+  base: {
+    id: 8453,
+    name: "base",
+    splitPool: "0xe310f78e2721a2a10faabf8df830140756fcb579",
+    splitPoolPut: "0x8a176e1a7103cccbd6551eef65bc00da641a1ecb",
+    weth: "0x4200000000000000000000000000000000000006",
+    usdc: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+    rpc: "https://base-rpc.publicnode.com"
+  },
+  arbitrum: {
+    id: 42161,
+    name: "arbitrum",
+    splitPool: "0xa1b161ff5ddd2437ba9e359397e868ef4cb6df2f",
+    splitPoolPut: "",
+    // calls only on Arbitrum for now
+    weth: "0x82aF49447D8a07e3bd95BD0d56f35241523fBab1",
+    usdc: "0xaf88d065e77c8cC2239327C5EDb3A432268e5831",
+    rpc: "https://arbitrum-one-rpc.publicnode.com"
+  }
+};
+function cfg(chain) {
+  const c = CHAINS[chain];
+  if (!c) throw new Error(`split: unknown chain "${chain}" (use "base" | "arbitrum")`);
+  return c;
+}
+function poolAddress(chain, side) {
+  const c = cfg(chain);
+  if (side === "short") {
+    if (!c.splitPoolPut) throw new Error(`split: shorts (puts) not deployed on ${chain}`);
+    return c.splitPoolPut;
+  }
+  return c.splitPool;
+}
+var SPLIT_POOL_ABI = parseAbi([
+  "function epoch() view returns (uint256)",
+  "function phase() view returns (uint8)",
+  // 0 = Idle, 1 = Trading
+  "function seriesCount(uint256 epoch) view returns (uint256)",
+  "function seriesAt(uint256 epoch, uint256 id) view returns (address vault, uint256 strike)",
+  "function freeWeth() view returns (uint256)",
+  "function freeUsdc() view returns (uint256)",
+  "function spot6() view returns (uint256)",
+  "function feeBps() view returns (uint16)",
+  "function costWithFee(uint256 qN, uint256 askPerN) view returns (uint256)",
+  "function buyN(uint256 seriesId, uint256 qN, uint256 maxCost, (address,uint256,uint256,uint256,uint256) q, bytes sig) returns (uint256)",
+  "function sellN(uint256 seriesId, uint256 qN, uint256 minProceeds, (address,uint256,uint256,uint256,uint256) q, bytes sig) returns (uint256)"
+]);
+var SPLIT_VAULT_ABI = parseAbi([
+  "function strike() view returns (uint256)",
+  "function maturity() view returns (uint256)",
+  "function exerciseEnd() view returns (uint256)",
+  "function settled() view returns (bool)",
+  "function N() view returns (address)"
+]);
+var ERC20_ABI = parseAbi([
+  "function balanceOf(address) view returns (uint256)",
+  "function approve(address spender, uint256 amount) returns (bool)",
+  "function allowance(address owner, address spender) view returns (uint256)"
+]);
+var ONE2 = 10n ** 18n;
+var _publics = /* @__PURE__ */ new Map();
+function getPublic(chain, rpcUrl) {
+  const c = cfg(chain);
+  const url = rpcUrl ?? c.rpc;
+  const key = `${chain}:${url}`;
+  let p = _publics.get(key);
+  if (!p) {
+    p = createPublicClient({
+      chain: chain === "base" ? base : arbitrum,
+      transport: http(url),
+      batch: { multicall: { wait: 40 } }
+    });
+    _publics.set(key, p);
+  }
+  return p;
+}
+var chainObj = (chain) => chain === "base" ? base : arbitrum;
+var toNWei2 = (qN) => BigInt(Math.round(qN * 1e18));
+var quoteCost2 = (qNWei, perN) => (qNWei * perN + ONE2 - 1n) / ONE2;
+var sellProceeds2 = (qNWei, perN) => qNWei * perN / ONE2;
+function fmtUsd(n) {
+  return n >= 1e3 ? n.toLocaleString("en-US", { maximumFractionDigits: 0 }) : n.toFixed(0);
+}
+async function getMarkets(chain, side, rpcUrl) {
+  const pool = poolAddress(chain, side);
+  const pub = getPublic(chain, rpcUrl);
+  const [epoch, phaseRaw, spot6] = await Promise.all([
+    pub.readContract({ address: pool, abi: SPLIT_POOL_ABI, functionName: "epoch" }),
+    pub.readContract({ address: pool, abi: SPLIT_POOL_ABI, functionName: "phase" }),
+    pub.readContract({ address: pool, abi: SPLIT_POOL_ABI, functionName: "spot6" }).catch(() => 0n)
+  ]);
+  if (Number(phaseRaw) !== 1) return [];
+  const spot = Number(spot6) / 1e6;
+  const count = await pub.readContract({
+    address: pool,
+    abi: SPLIT_POOL_ABI,
+    functionName: "seriesCount",
+    args: [epoch]
+  });
+  const n = Number(count);
+  if (n === 0) return [];
+  const rows = await Promise.all(
+    Array.from({ length: n }, async (_, id) => {
+      try {
+        const [vault, strikeRaw] = await pub.readContract({
+          address: pool,
+          abi: SPLIT_POOL_ABI,
+          functionName: "seriesAt",
+          args: [epoch, BigInt(id)]
+        });
+        const strike = Number(strikeRaw) / 1e6;
+        const q = await getQuote(chain, side, id);
+        const premium = Number(q.askPerN) / 1e6;
+        const leverage = premium > 0 ? spot / premium : 0;
+        const kind = side === "short" ? "put" : "call";
+        const label = leverage > 0 ? `${leverage.toFixed(0)}x \xB7 $${fmtUsd(strike)} ${kind}` : `$${fmtUsd(strike)} ${kind}`;
+        return { seriesId: id, vault, strike, leverage, spot, premium, label, side };
+      } catch {
+        return null;
+      }
+    })
+  );
+  return rows.filter((r) => r !== null);
+}
+async function getQuote(chain, side, seriesId, apiUrl = QUOTE_API) {
+  const pool = poolAddress(chain, side);
+  const put = side === "short" ? "&put=1" : "";
+  const url = `${apiUrl.replace(/\/+$/, "")}/pool-quote?pool=${pool}&series=${seriesId}${put}`;
+  const res = await fetch(url);
+  if (!res.ok) throw new Error(`split quote ${res.status}: ${await res.text()}`);
+  const j = await res.json();
+  if (j.error) throw new Error(`split quote: ${j.error}`);
+  if (!j.signature || !j.askPerN || !j.vault) throw new Error("split quote: malformed response");
+  return j;
+}
+function quoteTuple(q) {
+  return [q.vault, BigInt(q.askPerN), BigInt(q.bidPerN), BigInt(q.validUntil), BigInt(q.nonce)];
+}
+async function buy(args) {
+  const { chain, side, seriesId, account, walletClient } = args;
+  const pool = poolAddress(chain, side);
+  const c = cfg(chain);
+  const pub = getPublic(chain, args.rpcUrl);
+  const quote = args.quote ?? await getQuote(chain, side, seriesId);
+  const qNWei = toNWei2(args.qN);
+  const askPerN = BigInt(quote.askPerN);
+  const feeBps = await pub.readContract({
+    address: pool,
+    abi: SPLIT_POOL_ABI,
+    functionName: "feeBps"
+  });
+  const cost = quoteCost2(qNWei, askPerN);
+  const fee = cost * BigInt(feeBps) / 10000n;
+  const base2 = cost + fee;
+  const slipBps = BigInt(args.slippageBps ?? 100);
+  const maxCost = base2 + base2 * slipBps / 10000n;
+  const balance = await pub.readContract({
+    address: c.usdc,
+    abi: ERC20_ABI,
+    functionName: "balanceOf",
+    args: [account]
+  });
+  if (balance < maxCost) {
+    const need = (Number(maxCost) / 1e6).toFixed(2);
+    const have = (Number(balance) / 1e6).toFixed(2);
+    throw new Error(`Insufficient USDC: need $${need}, have $${have}.`);
+  }
+  await ensureAllowance(pub, walletClient, chain, c.usdc, account, pool, maxCost);
+  const txHash = await walletClient.writeContract({
+    address: pool,
+    abi: SPLIT_POOL_ABI,
+    functionName: "buyN",
+    args: [BigInt(seriesId), qNWei, maxCost, quoteTuple(quote), quote.signature],
+    account,
+    chain: chainObj(chain),
+    gas: 600000n
+  });
+  await pub.waitForTransactionReceipt({ hash: txHash });
+  return { txHash, qN: args.qN };
+}
+async function close(args) {
+  const { chain, side, seriesId, account, walletClient } = args;
+  const pool = poolAddress(chain, side);
+  const pub = getPublic(chain, args.rpcUrl);
+  const quote = args.quote ?? await getQuote(chain, side, seriesId);
+  const nToken = await pub.readContract({
+    address: quote.vault,
+    abi: SPLIT_VAULT_ABI,
+    functionName: "N"
+  });
+  const bal = await pub.readContract({
+    address: nToken,
+    abi: ERC20_ABI,
+    functionName: "balanceOf",
+    args: [account]
+  });
+  const qNWei = args.qN !== void 0 ? toNWei2(args.qN) : bal;
+  if (qNWei <= 0n) throw new Error("split close: nothing to close");
+  if (qNWei > bal) throw new Error("split close: qN exceeds your balance");
+  const feeBps = await pub.readContract({
+    address: pool,
+    abi: SPLIT_POOL_ABI,
+    functionName: "feeBps"
+  });
+  const proceeds = sellProceeds2(qNWei, BigInt(quote.bidPerN));
+  const fee = proceeds * BigInt(feeBps) / 10000n;
+  const net = proceeds - fee;
+  const slipBps = BigInt(args.slippageBps ?? 100);
+  const minProceeds = net - net * slipBps / 10000n;
+  await ensureAllowance(pub, walletClient, chain, nToken, account, pool, qNWei);
+  const txHash = await walletClient.writeContract({
+    address: pool,
+    abi: SPLIT_POOL_ABI,
+    functionName: "sellN",
+    args: [BigInt(seriesId), qNWei, minProceeds, quoteTuple(quote), quote.signature],
+    account,
+    chain: chainObj(chain),
+    gas: 600000n
+  });
+  await pub.waitForTransactionReceipt({ hash: txHash });
+  return { txHash, qN: Number(qNWei) / 1e18 };
+}
+async function getPosition(args) {
+  const { chain, side, seriesId, account } = args;
+  const pool = poolAddress(chain, side);
+  const pub = getPublic(chain, args.rpcUrl);
+  const [epoch, spot6] = await Promise.all([
+    pub.readContract({ address: pool, abi: SPLIT_POOL_ABI, functionName: "epoch" }),
+    pub.readContract({ address: pool, abi: SPLIT_POOL_ABI, functionName: "spot6" }).catch(() => 0n)
+  ]);
+  const spot = Number(spot6) / 1e6;
+  const [vault, strikeRaw] = await pub.readContract({
+    address: pool,
+    abi: SPLIT_POOL_ABI,
+    functionName: "seriesAt",
+    args: [epoch, BigInt(seriesId)]
+  });
+  const strike = Number(strikeRaw) / 1e6;
+  const nToken = await pub.readContract({
+    address: vault,
+    abi: SPLIT_VAULT_ABI,
+    functionName: "N"
+  });
+  const bal = await pub.readContract({
+    address: nToken,
+    abi: ERC20_ABI,
+    functionName: "balanceOf",
+    args: [account]
+  });
+  const qN = Number(bal) / 1e18;
+  if (qN === 0) return { qN: 0, markUsd: 0, intrinsicUsd: 0 };
+  const intrinsicPerN = side === "short" ? Math.max(0, strike - spot) : Math.max(0, spot - strike);
+  const intrinsicUsd = intrinsicPerN * qN;
+  let markUsd = intrinsicUsd;
+  try {
+    const q = await getQuote(chain, side, seriesId);
+    const ask = Number(q.askPerN) / 1e6;
+    const bid = Number(q.bidPerN) / 1e6;
+    const mid = ask > 0 && bid > 0 ? (ask + bid) / 2 : bid;
+    if (mid > 0) markUsd = mid * qN;
+  } catch {
+  }
+  return { qN, markUsd, intrinsicUsd };
+}
+async function ensureAllowance(pub, walletClient, chain, token, owner, spender, amount) {
+  const allowance = await pub.readContract({
+    address: token,
+    abi: ERC20_ABI,
+    functionName: "allowance",
+    args: [owner, spender]
+  });
+  if (allowance >= amount) return;
+  const hash = await walletClient.writeContract({
+    address: token,
+    abi: ERC20_ABI,
+    functionName: "approve",
+    args: [spender, amount],
+    account: owner,
+    chain: chainObj(chain),
+    gas: 80000n
+  });
+  await pub.waitForTransactionReceipt({ hash });
+}
+
+export { ARB_CHAIN_ID, BASE_CHAIN_ID, CHAINS, ERC20_ABI, FACILITATOR_URL_ARB, FACILITATOR_URL_BASE, NEXUS_BOOTSTRAP, NEXUS_FACTORY, QUOTE_API, SPLIT_POOL_ABI, SPLIT_VAULT_ABI, buy, buyGasless, close, closeGasless, deriveSmartWallet, deriveTradingAccount, facilitatorUrlForChain, getMarkets, getPosition, getPositionGasless, getPublic, getQuote, poolAddress, quoteTuple };