@depthhq/maker-sdk 0.0.0-stage → 0.1.2

package/dist/node.js

@@ -0,0 +1,1195 @@
+// src/fill/cursor.ts
+import { randomBytes } from "node:crypto";
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+
+class FillCursorStore {
+  genesis;
+  maker;
+  path;
+  constructor(genesis, maker, directory) {
+    this.genesis = genesis;
+    this.maker = maker;
+    if (!/^[1-9A-HJ-NP-Za-km-z]+$/.test(genesis) || !/^[1-9A-HJ-NP-Za-km-z]+$/.test(maker))
+      throw new RangeError("Fill cursor identity is invalid");
+    this.path = join(directory ?? process.env.XDG_STATE_HOME ?? join(homedir(), ".local", "state"), "depth", "fills", `${genesis}-${maker}.json`);
+  }
+  async load() {
+    let contents;
+    try {
+      contents = await readFile(this.path, "utf8");
+    } catch (error) {
+      if (error.code === "ENOENT")
+        return;
+      throw error;
+    }
+    const saved = JSON.parse(contents);
+    if (saved.genesis !== this.genesis || saved.maker !== this.maker || typeof saved.cursor !== "string" || !saved.cursor)
+      throw new Error("Fill cursor file does not match this maker and network");
+    return saved.cursor;
+  }
+  async save(cursor) {
+    if (!/^[1-9A-HJ-NP-Za-km-z]+$/.test(cursor))
+      throw new RangeError("Fill cursor signature is invalid");
+    await mkdir(dirname(this.path), { recursive: true, mode: 448 });
+    const temporary = `${this.path}.${process.pid}.${randomBytes(8).toString("hex")}`;
+    await writeFile(temporary, JSON.stringify({
+      genesis: this.genesis,
+      maker: this.maker,
+      cursor
+    }), { mode: 384 });
+    await rename(temporary, this.path);
+  }
+}
+// src/bot/bot.ts
+import { createHash, randomBytes as randomBytes3 } from "node:crypto";
+import { PublicKey } from "@solana/web3.js";
+import { DEPTH_PROGRAM_ID } from "@depthhq/bindings";
+
+// src/bot/store.ts
+import { randomBytes as randomBytes2 } from "node:crypto";
+import { mkdir as mkdir2, open, readFile as readFile2, rename as rename2, unlink } from "node:fs/promises";
+import { hostname } from "node:os";
+import { dirname as dirname2, join as join2 } from "node:path";
+
+class BotStore {
+  genesis;
+  maker;
+  operator;
+  path;
+  lock;
+  constructor(genesis, maker, operator, directory) {
+    this.genesis = genesis;
+    this.maker = maker;
+    this.operator = operator;
+    for (const value of [genesis, maker, operator])
+      if (!/^[1-9A-HJ-NP-Za-km-z]+$/.test(value))
+        throw new Error("Maker bot identity is invalid");
+    this.path = join2(directory, `${genesis}-${maker}-${operator}.json`);
+  }
+  async acquire() {
+    if (this.lock)
+      throw new Error("Maker bot already holds its lease");
+    await mkdir2(dirname2(this.path), { recursive: true, mode: 448 });
+    const path = `${this.path}.lock`;
+    const token = randomBytes2(16).toString("hex");
+    for (let attempt = 0;attempt < 2; attempt++) {
+      try {
+        const handle = await open(path, "wx", 384);
+        try {
+          await handle.writeFile(JSON.stringify({ host: hostname(), pid: process.pid, token }));
+        } catch (error) {
+          await handle.close();
+          await unlink(path);
+          throw error;
+        }
+        this.lock = { token, close: () => handle.close() };
+        return;
+      } catch (error) {
+        if (error.code !== "EEXIST")
+          throw error;
+        const contents = await readFile2(path, "utf8");
+        const lock = JSON.parse(contents);
+        if (lock.host !== hostname() || !Number.isSafeInteger(lock.pid) || lock.pid <= 0)
+          throw new Error("Maker bot lease belongs to another host");
+        try {
+          process.kill(lock.pid, 0);
+          throw new Error("Another maker bot is running for this wallet");
+        } catch (cause) {
+          if (cause.code !== "ESRCH")
+            throw cause;
+        }
+        if (await readFile2(path, "utf8") !== contents)
+          throw new Error("Maker bot lease changed during recovery");
+        await unlink(path);
+      }
+    }
+    throw new Error("Maker bot lease could not be acquired");
+  }
+  async release() {
+    const lock = this.lock;
+    if (!lock)
+      return;
+    this.lock = undefined;
+    await lock.close();
+    let contents;
+    try {
+      contents = await readFile2(`${this.path}.lock`, "utf8");
+    } catch (error) {
+      if (error.code === "ENOENT")
+        return;
+      throw error;
+    }
+    const value = JSON.parse(contents);
+    if (value.token === lock.token)
+      await unlink(`${this.path}.lock`);
+  }
+  async load() {
+    let source;
+    try {
+      source = await readFile2(this.path, "utf8");
+    } catch (error) {
+      if (error.code === "ENOENT")
+        return {
+          genesis: this.genesis,
+          maker: this.maker,
+          operator: this.operator,
+          fills: {}
+        };
+      throw error;
+    }
+    const state = JSON.parse(source, (_key, value) => value && typeof value === "object" && Object.keys(value).length === 1 && typeof value.$bigint === "string" ? BigInt(value.$bigint) : value);
+    if (state.genesis !== this.genesis || state.maker !== this.maker || state.operator !== this.operator || !state.fills || typeof state.fills !== "object")
+      throw new Error("Maker bot checkpoint belongs to another wallet or network");
+    if (state.referencePrice !== undefined && (typeof state.referencePrice !== "bigint" || state.referencePrice <= 0n))
+      throw new Error("Maker bot checkpoint price is invalid");
+    for (const value of [state.request?.clientNonce, state.replacement?.nonce])
+      if (value !== undefined && (typeof value !== "bigint" || value < 0n || value >= 1n << 64n))
+        throw new Error("Maker bot checkpoint nonce is invalid");
+    for (const value of [state.quote, state.replacement?.prior])
+      if (value !== undefined && !/^[1-9A-HJ-NP-Za-km-z]{32,44}$/.test(value))
+        throw new Error("Maker bot checkpoint quote is invalid");
+    if (state.request && (!Number.isSafeInteger(state.request.expiresAt) || typeof state.request.maxCapacity !== "bigint" || state.request.maxCapacity <= 0n || !Array.isArray(state.request.tiers) || !state.request.tiers.length))
+      throw new Error("Maker bot checkpoint request is invalid");
+    for (const fill of Object.values(state.fills))
+      if (typeof fill.signature !== "string" || !Number.isSafeInteger(fill.slot) || fill.slot < 0)
+        throw new Error("Maker bot checkpoint fill is invalid");
+    if (state.hedge) {
+      const hedge = state.hedge;
+      if (typeof hedge.identity !== "string" || !Number.isSafeInteger(hedge.nonce) || hedge.nonce < 0 || !Array.isArray(hedge.history) || hedge.history.length > 100 || hedge.unhedgedSince !== undefined && !Number.isSafeInteger(hedge.unhedgedSince))
+        throw new Error("Hedge checkpoint is invalid");
+      for (const order of [
+        ...hedge.history,
+        ...hedge.pending ? [hedge.pending] : []
+      ])
+        if (!/^0x[0-9a-f]{32}$/.test(order.cloid) || !Number.isSafeInteger(order.nonce) || order.nonce < 0 || !Number.isSafeInteger(order.expiresAt) || order.expiresAt <= order.nonce || typeof order.buy !== "boolean" || typeof order.reduceOnly !== "boolean" || typeof order.size !== "bigint" || order.size <= 0n || typeof order.limitPriceE8 !== "bigint" || order.limitPriceE8 <= 0n)
+          throw new Error("Hedge checkpoint order is invalid");
+      for (const record of hedge.history)
+        if (!["filled", "cancelled", "rejected"].includes(record.status) || typeof record.filledSize !== "bigint" || record.filledSize < 0n || record.filledSize > record.size || !Number.isSafeInteger(record.completedAt) || record.completedAt < record.nonce || record.orderId !== undefined && (!Number.isSafeInteger(record.orderId) || record.orderId < 0))
+          throw new Error("Hedge checkpoint receipt is invalid");
+    }
+    return state;
+  }
+  async save(state) {
+    if (!this.lock)
+      throw new Error("Acquire the maker bot lease before saving");
+    const lease = JSON.parse(await readFile2(`${this.path}.lock`, "utf8"));
+    if (lease.token !== this.lock.token || lease.pid !== process.pid || lease.host !== hostname())
+      throw new Error("Maker bot lease was lost");
+    const path = `${this.path}.${process.pid}.${randomBytes2(8).toString("hex")}`;
+    const handle = await open(path, "wx", 384);
+    try {
+      await handle.writeFile(JSON.stringify(state, (_key, value) => typeof value === "bigint" ? { $bigint: value.toString() } : value));
+      await handle.sync();
+    } finally {
+      await handle.close();
+    }
+    await rename2(path, this.path);
+    const directory = await open(dirname2(this.path), "r");
+    try {
+      await directory.sync();
+    } finally {
+      await directory.close();
+    }
+  }
+}
+
+// src/bot/policy.ts
+import { positionPnl } from "@depthhq/sdk";
+
+// src/hedge/policy.ts
+function validateHedgePolicy(policy) {
+  if (!Number.isInteger(policy.maxLeverage) || policy.maxLeverage < 1 || policy.maxLeverage > 10)
+    throw new RangeError("Maximum hedge leverage must be 1 to 10");
+  if (!Number.isInteger(policy.ratioBps) || policy.ratioBps < 1 || policy.ratioBps > 1e4)
+    throw new RangeError("Hedge ratio must be 1 to 10000 bps");
+  if (policy.thresholdNotional <= 0n || policy.maxOrderNotional <= 0n || policy.maxUnhedgedNotional <= policy.thresholdNotional)
+    throw new RangeError("Hedge notional limits are invalid");
+  for (const value of [
+    policy.batchMs,
+    policy.maxUnhedgedMs,
+    policy.maxPriceAgeMs,
+    policy.orderTtlMs
+  ])
+    if (!Number.isSafeInteger(value) || value < 1 || value > 300000)
+      throw new RangeError("Hedge time limits must be 1 to 300000 ms");
+  if (policy.batchMs >= policy.maxUnhedgedMs || policy.orderTtlMs > policy.maxUnhedgedMs)
+    throw new RangeError("Hedge batching and order expiry must fit the exposure time limit");
+  if (!Number.isInteger(policy.maxSlippageBps) || policy.maxSlippageBps < 1 || policy.maxSlippageBps > 100)
+    throw new RangeError("Hedge slippage must be 1 to 100 bps");
+}
+function validateBook(book, now, maxAge) {
+  if (!Number.isSafeInteger(book.timestamp) || book.timestamp > now + 1000 || now - book.timestamp > maxAge)
+    throw new Error("External order book is stale");
+  for (const [side, levels] of [
+    ["bid", book.bids],
+    ["ask", book.asks]
+  ]) {
+    if (!levels.length)
+      throw new Error("External order book is empty");
+    for (let index = 0;index < levels.length; index++) {
+      const level = levels[index];
+      if (level.priceE8 <= 0n || level.size <= 0n || index > 0 && (side === "bid" ? level.priceE8 > levels[index - 1].priceE8 : level.priceE8 < levels[index - 1].priceE8))
+        throw new Error("External order book is invalid");
+    }
+  }
+  if (book.bids[0].priceE8 >= book.asks[0].priceE8)
+    throw new Error("External order book is crossed");
+}
+function executionPrice(levels, size) {
+  if (size <= 0n)
+    throw new RangeError("Hedge execution size must be positive");
+  let remaining = size;
+  let cost = 0n;
+  for (const level of levels) {
+    const fill = remaining < level.size ? remaining : level.size;
+    cost += fill * level.priceE8;
+    remaining -= fill;
+    if (remaining === 0n)
+      return (cost + size - 1n) / size;
+  }
+  throw new Error("External order book cannot cover the quote tier");
+}
+
+// src/hedge/types.ts
+var abs = (value) => value < 0n ? -value : value;
+var notional = (size, priceE8) => (abs(size) * priceE8 + 99999999999n) / 100000000000n;
+
+// src/bot/policy.ts
+function validateBotPolicy(policy) {
+  if (policy.maxCapacity <= 0n || policy.maxInventoryNotional <= 0n || policy.maxCapacity > policy.maxInventoryNotional)
+    throw new RangeError("Maker capacity must fit a positive inventory limit");
+  for (const [name, value] of Object.entries(policy))
+    if (typeof value === "number" && (!Number.isSafeInteger(value) || value <= 0) && !(["inventorySkewBps", "executionCostBps"].includes(name) && value === 0))
+      throw new RangeError(`${name} must be a positive integer`);
+  if (policy.refreshSeconds >= policy.lifetimeSeconds)
+    throw new RangeError("Refresh must precede quote expiry");
+  if (policy.spreadBps >= 20000 || policy.repriceBps > 1e4)
+    throw new RangeError("Maker price bounds are invalid");
+  if ((policy.inventorySkewBps ?? 0) > 100 || (policy.executionCostBps ?? 0) > 100)
+    throw new RangeError("Maker pricing adjustments must be 0 to 100 bps");
+  if ((policy.fundingHours ?? 1) > 168)
+    throw new RangeError("Maker funding horizon must be at most 168 hours");
+  const reserve = policy.gasReserveLamports ?? 50000000n;
+  if (reserve < 10000000n || reserve > BigInt(Number.MAX_SAFE_INTEGER))
+    throw new RangeError("Maker SOL reserve must be at least 10000000 lamports");
+}
+function quoteHealth(market, now) {
+  if (!("active" in market.status) || !("none" in market.incident))
+    return "market paused";
+  const age = now - market.oracleTimestamp.toNumber();
+  if (age < 0 || age > market.config.maxOracleAgeSeconds)
+    return "oracle stale";
+  if (now > market.lastFundingTimestamp.toNumber() + market.config.fundingIntervalSeconds)
+    return "funding overdue";
+  if (BigInt(market.oraclePriceE8.toString()) < 100000000n)
+    return "oracle price invalid";
+}
+function botQuote(policy, market, position, nonce, now, pricing) {
+  validateBotPolicy(policy);
+  const reason = quoteHealth(market, now);
+  if (reason)
+    throw new Error(reason);
+  if (position.status !== "ready" || position.position === undefined || position.collateral === undefined || position.reserved === undefined)
+    throw new Error("Maker private position is not ready");
+  const price = BigInt(market.oraclePriceE8.toString());
+  const exposure = (position.position < 0n ? -position.position : position.position) * price / 100000000000n;
+  const marginBps = BigInt(market.config.initialMarginBps);
+  if (marginBps <= 0n)
+    throw new Error("Maker margin policy is invalid");
+  const pnl = position.position === 0n ? 0n : positionPnl(position, price, BigInt(market.fundingIndex.toString())).net;
+  const free = position.collateral + pnl - position.reserved - (exposure * marginBps + 9999n) / 10000n;
+  const limits = [
+    policy.maxCapacity,
+    policy.maxInventoryNotional - exposure,
+    free > 0n ? free * 10000n / marginBps : 0n,
+    BigInt(market.config.maxAccountNotional.toString()) - exposure,
+    BigInt(market.config.maxMarketNotional.toString())
+  ];
+  const capacity = limits.reduce((minimum, value) => value < minimum ? value : minimum);
+  const tiers = market.config.quoteTiers.map((value) => BigInt(value.toString())).filter((size) => size > 0n && size <= capacity);
+  if (!tiers.length)
+    return;
+  const half = Math.ceil(policy.spreadBps / 2);
+  if (half > market.config.maxQuoteDeviationBps)
+    throw new Error("Maker spread exceeds oracle deviation policy");
+  if (pricing)
+    validateBook(pricing.book, now * 1000, pricing.maxPriceAgeMs);
+  if (pricing && (!Number.isFinite(pricing.takerFeeBps) || pricing.takerFeeBps < 0 || !Number.isFinite(pricing.hourlyFundingBps)))
+    throw new Error("External execution costs are invalid");
+  const netPosition = position.position + (pricing?.externalPosition ?? 0n);
+  const netExposure = notional(netPosition, price);
+  const skewBps = netExposure * BigInt(policy.inventorySkewBps ?? 0) / policy.maxInventoryNotional;
+  const boundedSkew = skewBps < BigInt(policy.inventorySkewBps ?? 0) ? skewBps : BigInt(policy.inventorySkewBps ?? 0);
+  const skew = price * boundedSkew * (netPosition > 0n ? -1n : 1n) / 10000n;
+  const costs = BigInt(half + (policy.executionCostBps ?? 0));
+  const horizon = policy.fundingHours ?? 1;
+  const bidCosts = costs + BigInt(Math.ceil((pricing?.takerFeeBps ?? 0) + Math.max(0, -(pricing?.hourlyFundingBps ?? 0)) * horizon));
+  const askCosts = costs + BigInt(Math.ceil((pricing?.takerFeeBps ?? 0) + Math.max(0, pricing?.hourlyFundingBps ?? 0) * horizon));
+  const quotes = tiers.map((size) => {
+    const units = (size * 100000000000n + price - 1n) / price;
+    const sell = pricing ? executionPrice(pricing.book.bids, units) : price;
+    const buy = pricing ? executionPrice(pricing.book.asks, units) : price;
+    const bidE8 = sell * (10000n - bidCosts) / 10000n + skew;
+    const askE8 = (buy * (10000n + askCosts) + 9999n) / 10000n + skew;
+    const bound = price * BigInt(market.config.maxQuoteDeviationBps);
+    if (bidE8 < 100000000n || bidE8 >= askE8 || abs(bidE8 - price) * 10000n > bound || abs(askE8 - price) * 10000n > bound)
+      throw new Error("Executable maker prices exceed oracle deviation bounds");
+    return { size, bidE8, askE8 };
+  });
+  const duration = Math.min(policy.lifetimeSeconds, market.config.maxQuoteLifetimeSeconds);
+  return {
+    tiers: quotes,
+    maxCapacity: capacity,
+    expiresAt: now + duration,
+    clientNonce: nonce
+  };
+}
+
+// src/bot/bot.ts
+var terminal = new Set(["filled", "cancelled", "rejected"]);
+var nonce = () => BigInt(`0x${randomBytes3(8).toString("hex")}`);
+
+class MakerBot {
+  maker;
+  policy;
+  store;
+  hedge;
+  state;
+  position;
+  dirty = true;
+  busy = false;
+  stopping = false;
+  pricing;
+  hedgeLease;
+  pricingDirty = false;
+  constructor(maker, policy, store, hedge) {
+    this.maker = maker;
+    this.policy = policy;
+    this.store = store;
+    this.hedge = hedge;
+  }
+  static async create(options) {
+    validateBotPolicy(options.policy);
+    const client = options.maker;
+    const store = new BotStore(await client.options.connection.getGenesisHash(), client.options.maker.toBase58(), client.options.wallet.publicKey.toBase58(), options.stateDirectory);
+    await store.acquire();
+    const bot = new MakerBot(client, options.policy, store, options.hedge);
+    try {
+      bot.state = await store.load();
+      if (!options.hedge && bot.state.hedge)
+        throw new Error("Restore the configured hedge adapter before restarting a previously hedged maker");
+      if (options.hedge) {
+        if (bot.state.hedge && bot.state.hedge.identity !== options.hedge.adapter.identity)
+          throw new Error("Hedge checkpoint belongs to another account or network");
+        bot.hedgeLease = new BotStore(PublicKey.default.toBase58(), new PublicKey(createHash("sha256").update(options.hedge.adapter.identity).digest()).toBase58(), PublicKey.default.toBase58(), options.stateDirectory);
+        await bot.hedgeLease.acquire();
+        const shared = await bot.hedgeLease.load();
+        if (shared.hedge)
+          bot.state.hedge = shared.hedge;
+        bot.state.hedge ??= {
+          identity: options.hedge.adapter.identity,
+          nonce: 0,
+          history: []
+        };
+        if (bot.state.hedge.identity !== options.hedge.adapter.identity)
+          throw new Error("Shared hedge checkpoint belongs to another account");
+        const depthAccount = `${store.genesis}:${client.marketAccount().toBase58()}`;
+        if (bot.state.hedge.depthAccount && bot.state.hedge.depthAccount !== depthAccount)
+          throw new Error("Hedge account is already assigned to another Depth maker or network");
+        bot.state.hedge.depthAccount = depthAccount;
+        await bot.saveHedge();
+        await store.save(bot.state);
+      }
+      await bot.reconcile();
+      return bot;
+    } catch (error) {
+      await bot.hedgeLease?.release();
+      await store.release();
+      throw error;
+    }
+  }
+  async saveHedge() {
+    const store = this.hedgeLease;
+    await store.save({
+      genesis: store.genesis,
+      maker: store.maker,
+      operator: store.operator,
+      fills: {},
+      hedge: this.state.hedge
+    });
+    await this.store.save(this.state);
+  }
+  async hedgeTick() {
+    if (!this.hedge)
+      return;
+    const account = await this.maker.read("MarketAccount", this.maker.marketAccount(), "finalized");
+    const confirmed = await this.maker.read("MarketAccount", this.maker.marketAccount());
+    let ready = "ready" in account.status && "ready" in confirmed.status && account.version.toString() === confirmed.version.toString();
+    if (ready && (!this.position || this.position.version !== BigInt(account.version.toString()) || this.dirty)) {
+      const prior = this.position?.version;
+      this.position = await this.maker.position.summary({ timeoutMs: 180000 });
+      const fresh = await this.maker.read("MarketAccount", this.maker.marketAccount(), "finalized");
+      const latest = await this.maker.read("MarketAccount", this.maker.marketAccount());
+      ready = "ready" in fresh.status && "ready" in latest.status && fresh.version.toString() === latest.version.toString() && this.position.status === "ready" && this.position.version === BigInt(fresh.version.toString());
+      if (ready) {
+        this.pricingDirty ||= prior !== this.position.version || this.dirty;
+        this.dirty = false;
+      }
+    }
+    const snapshot = await this.hedge.tick(this.state.hedge, () => this.saveHedge(), ready ? this.position?.position : undefined);
+    if (snapshot.phase === "pending" || snapshot.phase === "blocked") {
+      await this.cancel(true);
+      return snapshot.reason ?? "hedge reconciliation pending";
+    }
+    const [book, costs] = await Promise.all([
+      this.hedge.adapter.book(),
+      this.hedge.adapter.costs()
+    ]);
+    if (this.pricing) {
+      const before = this.pricing.book.bids[0].priceE8 + this.pricing.book.asks[0].priceE8;
+      const after = book.bids[0].priceE8 + book.asks[0].priceE8;
+      const change = after > before ? after - before : before - after;
+      this.pricingDirty ||= change * 10000n >= before * BigInt(this.policy.repriceBps) || costs.takerFeeBps !== this.pricing.takerFeeBps || costs.hourlyFundingBps !== this.pricing.hourlyFundingBps;
+    }
+    this.pricing = {
+      book,
+      ...costs,
+      externalPosition: snapshot.externalPosition,
+      maxPriceAgeMs: this.hedge.policy.maxPriceAgeMs
+    };
+  }
+  snapshot(phase, reason) {
+    return {
+      phase,
+      reason,
+      quoteId: this.state?.quote,
+      fillCount: Object.keys(this.state?.fills ?? {}).length
+    };
+  }
+  requestId() {
+    const value = this.state?.request?.clientNonce;
+    if (value === undefined)
+      return;
+    const bytes = Buffer.alloc(8);
+    bytes.writeBigUInt64LE(value);
+    return PublicKey.findProgramAddressSync([
+      Buffer.from("quote"),
+      this.maker.marketAddress.toBuffer(),
+      this.maker.options.maker.toBuffer(),
+      bytes
+    ], DEPTH_PROGRAM_ID)[0];
+  }
+  async reconcile() {
+    const state = this.state;
+    let cursor;
+    const managed = [];
+    do {
+      const page = await this.maker.quote.list({ cursor, limit: 100 });
+      for (const item of page.items) {
+        const quote = await this.maker.quoteState(item.id);
+        if (quote.operator.equals(this.maker.options.wallet.publicKey) && !terminal.has(Object.keys(quote.status)[0]))
+          managed.push(item.id.toBase58());
+      }
+      cursor = page.nextCursor ?? undefined;
+    } while (cursor);
+    const allowed = new Set([
+      state.quote,
+      state.replacement?.prior,
+      this.requestId()?.toBase58()
+    ].filter(Boolean));
+    for (const id of managed)
+      if (!allowed.has(id)) {
+        const quote = await this.maker.quote.get(new PublicKey(id)).status();
+        if (["active", "waiting", "validated", "validating", "closing"].includes(quote.status))
+          await this.maker.quote.get(new PublicKey(id)).cancel();
+      }
+  }
+  async fills() {
+    const state = this.state;
+    let before;
+    let head;
+    const records = new Map;
+    do {
+      const page = await this.maker.fills.list({
+        before,
+        until: state.cursor,
+        limit: 100
+      });
+      head ??= page.head;
+      for (const fill of page.fills)
+        if (!state.fills[fill.id])
+          records.set(fill.id, { signature: fill.signature, slot: fill.slot });
+      before = page.cursor;
+    } while (before);
+    if (records.size) {
+      for (const [id, value] of records)
+        state.fills[id] = value;
+      this.dirty = true;
+    }
+    if (head) {
+      state.cursor = head;
+      await this.store.save(state);
+    }
+  }
+  async cancel(preserve = false) {
+    const state = this.state;
+    if (!state.quote) {
+      const request = this.requestId();
+      if (request && await this.maker.options.connection.getAccountInfo(request, "confirmed"))
+        state.quote = request.toBase58();
+      else {
+        if (state.request && (preserve || state.request.expiresAt + 180 > Math.floor(Date.now() / 1000)))
+          return false;
+        state.request = undefined;
+        if (!preserve)
+          state.replacement = undefined;
+        await this.store.save(state);
+        return true;
+      }
+    }
+    const handle = this.maker.quote.get(new PublicKey(state.quote));
+    const quote = await handle.status();
+    if (terminal.has(quote.status)) {
+      state.quote = undefined;
+      state.request = undefined;
+      state.referencePrice = undefined;
+      if (!preserve)
+        state.replacement = undefined;
+      this.dirty = true;
+      await this.store.save(state);
+      return true;
+    }
+    if (["active", "waiting", "validated", "validating", "closing"].includes(quote.status))
+      await handle.cancel();
+    return false;
+  }
+  async tick() {
+    if (this.busy)
+      throw new Error("Maker bot tick is already running");
+    if (!this.state)
+      throw new Error("Maker bot has been closed");
+    this.busy = true;
+    try {
+      const state = this.state;
+      let [market, lamports] = await Promise.all([
+        this.maker.read("Market", this.maker.marketAddress),
+        this.maker.options.connection.getBalance(this.maker.options.wallet.publicKey, "confirmed")
+      ]);
+      let now = Math.floor(Date.now() / 1000);
+      const reason = this.stopping ? "shutdown" : quoteHealth(market, now) ?? (BigInt(lamports) < (this.policy.gasReserveLamports ?? 50000000n) ? "operator SOL reserve" : undefined);
+      if (reason) {
+        const stopped = await this.cancel();
+        if (this.stopping && this.hedge && state.hedge)
+          await this.hedge.tick(state.hedge, () => this.saveHedge(), undefined, undefined, true);
+        if (!this.stopping && this.hedge && state.hedge?.pending)
+          await this.hedge.tick(state.hedge, () => this.saveHedge(), undefined);
+        return this.snapshot(stopped && !state.hedge?.pending ? "stopped" : "pending", reason);
+      }
+      await this.fills();
+      const hedgeReason = await this.hedgeTick();
+      if (hedgeReason)
+        return this.snapshot("pending", hedgeReason);
+      if (this.hedge) {
+        market = await this.maker.read("Market", this.maker.marketAddress);
+        now = Math.floor(Date.now() / 1000);
+        const changed = quoteHealth(market, now);
+        if (changed) {
+          const stopped = await this.cancel();
+          return this.snapshot(stopped ? "stopped" : "pending", changed);
+        }
+      }
+      if (!state.quote && this.requestId() && await this.maker.options.connection.getAccountInfo(this.requestId(), "confirmed")) {
+        state.quote = this.requestId().toBase58();
+        await this.store.save(state);
+      }
+      if (state.quote) {
+        const handle2 = this.maker.quote.get(new PublicKey(state.quote));
+        const quote = await handle2.status();
+        if (terminal.has(quote.status)) {
+          state.quote = undefined;
+          state.request = undefined;
+          this.dirty = true;
+          await this.store.save(state);
+        } else if (state.replacement) {
+          if (!["cancelled", "filled"].includes(quote.status)) {
+            await this.maker.quote.replacement(new PublicKey(state.replacement.prior), state.replacement.nonce).begin();
+            await this.cancel(true);
+            return this.snapshot("pending", "releasing prior quote");
+          }
+        } else if (["validating", "validated", "waiting", "reserving"].includes(quote.status)) {
+          const current = await this.maker.quoteState(handle2.id);
+          if (current.expiry.toNumber() <= now && ["validating", "validated", "waiting"].includes(quote.status))
+            await this.cancel();
+          else
+            await handle2.activate({ timeoutMs: 0 });
+          return this.snapshot("pending", "activating quote");
+        } else if (["closing", "releasing"].includes(quote.status)) {
+          await this.cancel();
+          return this.snapshot("pending", "releasing quote");
+        } else if (quote.status === "active") {
+          const price = BigInt(market.oraclePriceE8.toString());
+          const difference = state.referencePrice === undefined ? undefined : (price > state.referencePrice ? price - state.referencePrice : state.referencePrice - price) * 10000n;
+          const current = await this.maker.quoteState(handle2.id);
+          const duration = Math.min(this.policy.lifetimeSeconds, market.config.maxQuoteLifetimeSeconds);
+          const refresh = current.expiry.toNumber() - now <= duration - Math.min(this.policy.refreshSeconds, duration - 1);
+          if (!this.dirty && !this.pricingDirty && !refresh && difference !== undefined && difference < BigInt(this.policy.repriceBps) * state.referencePrice)
+            return this.snapshot("active");
+          state.replacement = { prior: state.quote, nonce: nonce() };
+          this.pricingDirty = false;
+          await this.store.save(state);
+          await this.maker.quote.replacement(handle2.id, state.replacement.nonce).begin();
+          await this.cancel(true);
+          return this.snapshot("pending", "repricing quote");
+        }
+      }
+      if (market.pendingOrders > 0)
+        return this.snapshot("idle", "settlement in progress");
+      const account = await this.maker.read("MarketAccount", this.maker.marketAccount());
+      if (!("ready" in account.status))
+        return this.snapshot("idle", "maker account busy");
+      if (this.dirty || !this.position || this.position.version !== BigInt(account.version.toString())) {
+        this.position = await this.maker.position.summary({
+          timeoutMs: 180000
+        });
+        if (this.position.status !== "ready" || this.position.version !== BigInt(account.version.toString()))
+          return this.snapshot("idle", "maker view changed");
+        this.dirty = false;
+        return this.snapshot("idle", "maker view refreshed");
+      }
+      if (!state.request) {
+        const request2 = botQuote(this.policy, market, this.position, state.replacement?.nonce ?? nonce(), now, this.pricing);
+        if (!request2)
+          return this.snapshot("idle", "inventory or collateral limit");
+        state.request = request2;
+        this.pricingDirty = false;
+        state.referencePrice = BigInt(market.oraclePriceE8.toString());
+        await this.store.save(state);
+      }
+      const request = state.request;
+      if (request.expiresAt <= now) {
+        state.request = undefined;
+        await this.store.save(state);
+        return this.snapshot("idle", "prepared quote expired");
+      }
+      const handle = state.replacement ? await this.maker.quote.replacement(new PublicKey(state.replacement.prior), state.replacement.nonce).resume(request, { timeoutMs: 0 }) : await this.maker.quote.publish(request);
+      state.quote = handle.id.toBase58();
+      state.replacement = undefined;
+      await this.store.save(state);
+      await handle.activate({ timeoutMs: 0 });
+      return this.snapshot("pending", "quote submitted");
+    } catch (error) {
+      this.dirty = true;
+      try {
+        await this.cancel(true);
+      } catch (cause) {
+        throw new AggregateError([error, cause], "Maker bot failed and quote cancellation could not be confirmed");
+      }
+      throw error;
+    } finally {
+      this.busy = false;
+    }
+  }
+  stop() {
+    this.stopping = true;
+  }
+  async close() {
+    if (this.busy)
+      throw new Error("Wait for the active maker tick before closing");
+    await this.store.release();
+    await this.hedgeLease?.release();
+    this.state = undefined;
+  }
+}
+var create_maker_bot = MakerBot.create;
+// src/hedge/engine.ts
+import { randomBytes as randomBytes4 } from "node:crypto";
+class HedgeEngine {
+  adapter;
+  policy;
+  snapshot;
+  busy = false;
+  constructor(adapter, policy) {
+    this.adapter = adapter;
+    this.policy = policy;
+    validateHedgePolicy(policy);
+    if (adapter.sizeStep <= 0n || adapter.minNotional <= 0n)
+      throw new Error("External order limits are invalid");
+  }
+  async tick(state, save, depthPosition, timestamp, reconcileOnly = false) {
+    if (this.busy)
+      throw new Error("Hedge engine tick is already running");
+    if (state.identity !== this.adapter.identity)
+      throw new Error("Hedge checkpoint belongs to another account or network");
+    this.busy = true;
+    const clock = () => timestamp ?? Date.now();
+    let now = clock();
+    const result = (phase, reason, externalPosition) => {
+      this.snapshot = {
+        venue: "hyperliquid",
+        network: this.adapter.network,
+        account: this.adapter.address,
+        updatedAt: now,
+        phase,
+        reason,
+        depthPosition,
+        externalPosition,
+        unhedgedPosition: externalPosition === undefined || depthPosition === undefined ? undefined : depthPosition + externalPosition,
+        pending: state.pending,
+        history: state.history.slice(-50)
+      };
+      return this.snapshot;
+    };
+    try {
+      if (state.pending) {
+        const order2 = state.pending;
+        const receipt2 = await this.adapter.receipt(order2);
+        now = clock();
+        if (receipt2.status === "unknown") {
+          if (reconcileOnly)
+            return result("blocked", "Paused with an unresolved hedge receipt; no order will be resubmitted");
+          if (now >= order2.expiresAt)
+            return result("blocked", "Hedge submission is unresolved; reconcile the persisted order before trading");
+          const retry = await this.adapter.submit(order2);
+          now = clock();
+          if (retry.status === "unknown" || retry.status === "open")
+            return result("pending", "Hedge confirmation pending");
+          state.history.push({
+            ...order2,
+            ...retry,
+            completedAt: Math.max(now, order2.nonce)
+          });
+        } else if (receipt2.status === "open") {
+          state.nonce = Math.max(now, state.nonce + 1);
+          await save();
+          await this.adapter.cancel(order2, state.nonce);
+          return result("pending", "Cancelling an outstanding hedge order");
+        } else {
+          state.history.push({
+            ...order2,
+            ...receipt2,
+            completedAt: Math.max(now, order2.nonce)
+          });
+        }
+        state.history = state.history.slice(-100);
+        state.pending = undefined;
+        await save();
+      }
+      if (reconcileOnly) {
+        const account2 = await this.adapter.account();
+        return result("waiting", "Automation paused; existing positions remain open", account2.position);
+      }
+      if (depthPosition === undefined)
+        return result("pending", "Waiting for finalized Depth inventory");
+      const [account, book] = await Promise.all([
+        this.adapter.account(),
+        this.adapter.book()
+      ]);
+      now = clock();
+      validateBook(book, now, this.policy.maxPriceAgeMs);
+      if (!Number.isSafeInteger(account.timestamp) || account.timestamp > now + 1000 || now - account.timestamp > this.policy.maxPriceAgeMs)
+        throw new Error("External account snapshot is stale");
+      if (!Number.isInteger(account.leverage) || account.leverage < 1 || account.leverage > this.policy.maxLeverage)
+        throw new Error("External leverage exceeds hedge policy");
+      const latest = state.history[state.history.length - 1];
+      if (latest && account.timestamp < latest.completedAt)
+        return result("pending", "Waiting for the external account to include the confirmed hedge", account.position);
+      if (account.openOrders.length)
+        return result("blocked", "Hedge account has unmanaged open orders", account.position);
+      const price = (book.bids[0].priceE8 + book.asks[0].priceE8) / 2n;
+      const target = -(depthPosition * BigInt(this.policy.ratioBps) / 10000n / this.adapter.sizeStep) * this.adapter.sizeStep;
+      const delta = target - account.position;
+      const risk = notional(depthPosition + account.position, price);
+      const difference = notional(delta, price);
+      const hard = risk >= this.policy.maxUnhedgedNotional;
+      if (difference === 0n) {
+        state.unhedgedSince = undefined;
+        await save();
+        return result(hard ? "blocked" : "balanced", hard ? "Unhedged exposure exceeds policy" : undefined, account.position);
+      }
+      state.unhedgedSince ??= now;
+      await save();
+      const age = now - state.unhedgedSince;
+      if (!hard && age < this.policy.maxUnhedgedMs && (difference < this.policy.thresholdNotional || age < this.policy.batchMs))
+        return result("waiting", "Net exposure is within the batching window", account.position);
+      const buy = delta > 0n;
+      const levels = buy ? book.asks : book.bids;
+      const rawLimit = levels[0].priceE8 * BigInt(1e4 + (buy ? 1 : -1) * this.policy.maxSlippageBps) / 10000n;
+      const limit = this.adapter.price(rawLimit, buy);
+      let capacity = this.policy.maxOrderNotional * 100000000000n / limit;
+      const available = levels.filter((level) => buy ? level.priceE8 <= limit : level.priceE8 >= limit).reduce((sum, level) => sum + level.size, 0n);
+      capacity = capacity < available ? capacity : available;
+      const reducing = account.position !== 0n && account.position > 0n !== buy;
+      if (reducing)
+        capacity = capacity < abs(account.position) ? capacity : abs(account.position);
+      else {
+        if (!Number.isInteger(account.leverage) || account.leverage < 1 || account.availableMargin < 0n)
+          throw new Error("External margin state is invalid");
+        const marginCapacity = account.availableMargin * BigInt(account.leverage) * 99n * 100000000000n / (100n * limit);
+        capacity = capacity < marginCapacity ? capacity : marginCapacity;
+      }
+      let size = abs(delta) < capacity ? abs(delta) : capacity;
+      size = size / this.adapter.sizeStep * this.adapter.sizeStep;
+      if (size === 0n || !reducing && notional(size, limit) < this.adapter.minNotional)
+        return result(hard || age >= this.policy.maxUnhedgedMs ? "blocked" : "waiting", "Hedge size is below venue limits or available margin", account.position);
+      const order = {
+        cloid: `0x${randomBytes4(16).toString("hex")}`,
+        nonce: Math.max(now, state.nonce + 1),
+        expiresAt: now + this.policy.orderTtlMs,
+        buy,
+        size,
+        limitPriceE8: limit,
+        reduceOnly: reducing
+      };
+      state.nonce = order.nonce;
+      state.pending = order;
+      await save();
+      const receipt = await this.adapter.submit(order);
+      now = clock();
+      if (receipt.status !== "unknown" && receipt.status !== "open") {
+        state.history.push({
+          ...order,
+          ...receipt,
+          completedAt: Math.max(now, order.nonce)
+        });
+        state.history = state.history.slice(-100);
+        state.pending = undefined;
+        await save();
+      }
+      return result(receipt.status === "rejected" ? "blocked" : "pending", receipt.reason ?? "Hedge submitted; reconciling confirmed exposure", account.position);
+    } catch (error) {
+      result("blocked", error instanceof Error ? error.message : "External hedge service unavailable");
+      throw error;
+    } finally {
+      this.busy = false;
+    }
+  }
+}
+// src/hedge/hyperliquid.ts
+import { HttpTransport, InfoClient } from "@nktkas/hyperliquid";
+import {
+  canonicalize,
+  getWalletAddress,
+  signL1Action
+} from "@nktkas/hyperliquid/signing";
+import {
+  OrderRequest,
+  CancelByCloidRequest
+} from "@nktkas/hyperliquid/api/exchange";
+import { privateKeyToAccount } from "viem/accounts";
+
+// src/hedge/amount.ts
+function units(value, decimals, exact = true) {
+  if (!/^-?\d+(?:\.\d+)?$/.test(value))
+    throw new Error("External decimal is invalid");
+  const negative = value.startsWith("-");
+  const [whole, fraction = ""] = value.replace(/^-/, "").split(".");
+  const extra = fraction.slice(decimals);
+  if (exact && /[1-9]/.test(extra))
+    throw new Error("External decimal exceeds precision");
+  const amount = BigInt(whole) * 10n ** BigInt(decimals) + BigInt(fraction.slice(0, decimals).padEnd(decimals, "0") || "0");
+  return negative ? -amount - (!exact && /[1-9]/.test(extra) ? 1n : 0n) : amount;
+}
+function decimal(value, decimals) {
+  const magnitude = value < 0n ? -value : value;
+  const base = 10n ** BigInt(decimals);
+  const fraction = (magnitude % base).toString().padStart(decimals, "0").replace(/0+$/, "");
+  return `${value < 0n ? "-" : ""}${magnitude / base}${fraction ? `.${fraction}` : ""}`;
+}
+
+// src/hedge/hyperliquid.ts
+class HyperliquidAdapter {
+  network;
+  address;
+  wallet;
+  transport;
+  info;
+  asset;
+  sizeDecimals;
+  minNotional = 10000000n;
+  identity;
+  sizeStep;
+  cache = new Map;
+  cached(key, ttl, load) {
+    const prior = this.cache.get(key);
+    if (prior && prior.expiresAt > Date.now())
+      return prior.value;
+    const value = load().catch((error) => {
+      this.cache.delete(key);
+      throw error;
+    });
+    this.cache.set(key, { expiresAt: Date.now() + ttl, value });
+    return value;
+  }
+  constructor(network, address, wallet, transport, info, asset, sizeDecimals) {
+    this.network = network;
+    this.address = address;
+    this.wallet = wallet;
+    this.transport = transport;
+    this.info = info;
+    this.asset = asset;
+    this.sizeDecimals = sizeDecimals;
+    this.identity = `hyperliquid:${network}:${address.toLowerCase()}:SOL`;
+    this.sizeStep = 10n ** BigInt(9 - sizeDecimals);
+  }
+  static async create(options) {
+    if (Boolean(options.wallet) === Boolean(options.agentKey))
+      throw new Error("Provide one Hyperliquid agent signer source");
+    const wallet = options.wallet ?? privateKeyToAccount(options.agentKey);
+    if (!/^0x[0-9a-fA-F]{40}$/.test(options.account))
+      throw new Error("Hyperliquid account address is invalid");
+    const network = options.network ?? "testnet";
+    const transport = new HttpTransport({
+      isTestnet: network === "testnet",
+      timeout: 1e4
+    });
+    const info = new InfoClient({ transport });
+    const signer = await getWalletAddress(wallet);
+    if (signer.toLowerCase() === options.account.toLowerCase())
+      throw new Error("Use a dedicated approved Hyperliquid agent wallet");
+    const [meta, agents] = await Promise.all([
+      info.meta(),
+      info.extraAgents({ user: options.account })
+    ]);
+    if (!agents.some((agent) => agent.address.toLowerCase() === signer.toLowerCase() && (agent.validUntil === null || agent.validUntil > Date.now())))
+      throw new Error("Hyperliquid agent is not approved or has expired");
+    const asset = meta.universe.findIndex((item) => item.name === "SOL" && !item.isDelisted);
+    if (asset < 0)
+      throw new Error("Hyperliquid SOL perpetual is unavailable");
+    const sizeDecimals = meta.universe[asset].szDecimals;
+    if (!Number.isInteger(sizeDecimals) || sizeDecimals < 0 || sizeDecimals > 6)
+      throw new Error("Unsupported Hyperliquid SOL precision");
+    return new HyperliquidAdapter(network, options.account, wallet, transport, info, asset, sizeDecimals);
+  }
+  async book() {
+    const book = await this.cached("book", 500, () => this.info.l2Book({ coin: "SOL" }));
+    if (!book)
+      throw new Error("Hyperliquid SOL order book is unavailable");
+    const levels = (side) => side.map((level) => ({
+      priceE8: units(level.px, 8),
+      size: units(level.sz, 9)
+    }));
+    return {
+      timestamp: book.time,
+      bids: levels(book.levels[0]),
+      asks: levels(book.levels[1])
+    };
+  }
+  async account() {
+    const [state, orders, data] = await Promise.all([
+      this.info.clearinghouseState({ user: this.address }),
+      this.cached("orders", 5000, () => this.info.openOrders({ user: this.address })),
+      this.cached("asset", 30000, () => this.info.activeAssetData({ user: this.address, coin: "SOL" }))
+    ]);
+    if (state.assetPositions.some((entry) => entry.position.coin !== "SOL" && units(entry.position.szi, 9) !== 0n))
+      throw new Error("Use a dedicated SOL hedge account without unrelated positions");
+    const position = state.assetPositions.find((entry) => entry.position.coin === "SOL")?.position;
+    if (data.leverage.type !== "cross")
+      throw new Error("The hedge adapter requires cross margin on its dedicated account");
+    const value = units(state.marginSummary.accountValue, 6, false);
+    const used = units(state.marginSummary.totalMarginUsed, 6, false) + 1n;
+    return {
+      timestamp: state.time,
+      position: position ? units(position.szi, 9) : 0n,
+      availableMargin: value > used ? value - used : 0n,
+      leverage: data.leverage.value,
+      openOrders: orders.map((order) => String(order.oid))
+    };
+  }
+  async costs() {
+    const [fees, data] = await Promise.all([
+      this.cached("fees", 60000, () => this.info.userFees({ user: this.address })),
+      this.cached("funding", 1e4, () => this.info.metaAndAssetCtxs())
+    ]);
+    const index = data[0].universe.findIndex((item) => item.name === "SOL");
+    if (index < 0)
+      throw new Error("Hyperliquid SOL funding is unavailable");
+    const bps = (value) => Number(units(value, 12)) / 1e8;
+    return {
+      takerFeeBps: bps(fees.userCrossRate),
+      hourlyFundingBps: bps(data[1][index].funding)
+    };
+  }
+  price(value, buy) {
+    if (value <= 0n)
+      throw new Error("Hedge price is invalid");
+    const digits = (value / 100000000n).toString().length;
+    const decimals = Math.min(6 - this.sizeDecimals, Math.max(0, 5 - digits));
+    const tick = 10n ** BigInt(8 - decimals);
+    return (buy ? value / tick : (value + tick - 1n) / tick) * tick;
+  }
+  async submit(order) {
+    const outstanding = await this.info.openOrders({ user: this.address });
+    if (outstanding.some((entry) => entry.cloid !== order.cloid))
+      throw new Error("Hedge account has unmanaged open orders");
+    const action = canonicalize(OrderRequest.entries.action, {
+      type: "order",
+      orders: [
+        {
+          a: this.asset,
+          b: order.buy,
+          p: decimal(order.limitPriceE8, 8),
+          s: decimal(order.size, 9),
+          r: order.reduceOnly,
+          t: { limit: { tif: "Ioc" } },
+          c: order.cloid
+        }
+      ],
+      grouping: "na"
+    });
+    const payload = {
+      action,
+      nonce: order.nonce,
+      expiresAfter: order.expiresAt
+    };
+    const signature = await signL1Action({
+      ...payload,
+      wallet: this.wallet,
+      isTestnet: this.network === "testnet"
+    });
+    const response = await this.transport.request("exchange", { ...payload, signature });
+    if (response.status !== "ok") {
+      const message = typeof response.response === "string" ? response.response : "Hyperliquid order rejected";
+      if (/nonce|duplicate/i.test(message))
+        return {
+          status: "unknown",
+          filledSize: 0n,
+          reason: "Persisted hedge nonce already submitted; reconciling"
+        };
+      return { status: "rejected", filledSize: 0n, reason: message };
+    }
+    const result = response.response;
+    const status = result.data?.statuses?.[0];
+    if (status?.error)
+      return { status: "rejected", filledSize: 0n, reason: status.error };
+    return this.receipt(order);
+  }
+  async receipt(order) {
+    const status = await this.info.orderStatus({
+      user: this.address,
+      oid: order.cloid
+    });
+    if (status.status !== "order")
+      return { status: "unknown", filledSize: 0n };
+    const detail = status.order;
+    if (detail.order.coin !== "SOL" || detail.order.cloid !== order.cloid || detail.order.side === "B" !== order.buy || units(detail.order.origSz, 9) !== order.size || units(detail.order.limitPx, 8) !== order.limitPriceE8 || detail.order.reduceOnly !== order.reduceOnly)
+      throw new Error("Hyperliquid order does not match the hedge checkpoint");
+    if (detail.status === "open" || detail.status === "triggered")
+      return { status: "open", orderId: detail.order.oid, filledSize: 0n };
+    const fills = await this.info.userFillsByTime({
+      user: this.address,
+      startTime: order.nonce - 1000,
+      endTime: Date.now()
+    });
+    if (fills.length >= 2000)
+      throw new Error("Hyperliquid fill window exceeds the reconciliation limit");
+    const seen = new Set;
+    const matching = fills.filter((fill) => {
+      if (fill.oid !== detail.order.oid || fill.coin !== "SOL" || seen.has(fill.tid))
+        return false;
+      seen.add(fill.tid);
+      return true;
+    });
+    const filledSize = matching.reduce((sum, fill) => sum + units(fill.sz, 9), 0n);
+    if (matching.some((fill) => fill.side === "B" !== order.buy || units(fill.sz, 9) <= 0n || units(fill.px, 8) <= 0n || fill.feeToken !== "USDC" || !/^0x[0-9a-fA-F]{64}$/.test(fill.hash)))
+      throw new Error("Hyperliquid fill does not match the hedge order");
+    if (filledSize > order.size)
+      throw new Error("Hyperliquid filled size exceeds the hedge order");
+    if (detail.status === "filled" && filledSize !== order.size)
+      return {
+        status: "unknown",
+        orderId: detail.order.oid,
+        filledSize,
+        reason: "Hedge fill indexing is incomplete"
+      };
+    const cost = matching.reduce((sum, fill) => sum + units(fill.sz, 9) * units(fill.px, 8), 0n);
+    return {
+      status: detail.status === "filled" ? "filled" : /rejected/i.test(detail.status) ? "rejected" : "cancelled",
+      orderId: detail.order.oid,
+      filledSize,
+      averagePriceE8: filledSize ? cost / filledSize : undefined,
+      fee: matching.reduce((sum, fill) => sum + units(fill.fee, 6), 0n),
+      hashes: [...new Set(matching.map((fill) => fill.hash))],
+      reason: detail.status
+    };
+  }
+  async cancel(order, nonce2 = order.nonce + 1) {
+    const action = canonicalize(CancelByCloidRequest.entries.action, {
+      type: "cancelByCloid",
+      cancels: [{ asset: this.asset, cloid: order.cloid }]
+    });
+    const signature = await signL1Action({
+      wallet: this.wallet,
+      action,
+      nonce: nonce2,
+      isTestnet: this.network === "testnet"
+    });
+    await this.transport.request("exchange", { action, nonce: nonce2, signature });
+  }
+}
+var create_hyperliquid = HyperliquidAdapter.create;
+// src/hedge/setup.ts
+import { ExchangeClient, HttpTransport as HttpTransport2, InfoClient as InfoClient2 } from "@nktkas/hyperliquid";
+import {
+  getWalletAddress as getWalletAddress2
+} from "@nktkas/hyperliquid/signing";
+import { privateKeyToAccount as privateKeyToAccount2 } from "viem/accounts";
+async function setup_hyperliquid(options) {
+  if (Boolean(options.wallet) === Boolean(options.accountKey))
+    throw new Error("Provide one Hyperliquid account signer source");
+  if (!Number.isInteger(options.leverage) || options.leverage < 1 || options.leverage > 10)
+    throw new Error("Setup leverage must be 1 to 10");
+  if (Boolean(options.agent) === Boolean(options.agentKey))
+    throw new Error("Provide one Hyperliquid agent identity source");
+  const agent = options.agent ?? privateKeyToAccount2(options.agentKey).address;
+  if (!/^0x[0-9a-fA-F]{40}$/.test(agent))
+    throw new Error("Hyperliquid agent address is invalid");
+  const wallet = options.wallet ?? privateKeyToAccount2(options.accountKey);
+  const account = await getWalletAddress2(wallet);
+  if (options.account && account.toLowerCase() !== options.account.toLowerCase())
+    throw new Error("The setup signer does not own the configured Hyperliquid account");
+  if (account.toLowerCase() === agent.toLowerCase())
+    throw new Error("The account and agent must be separate wallets");
+  const transport = new HttpTransport2({
+    isTestnet: (options.network ?? "testnet") === "testnet"
+  });
+  const info = new InfoClient2({ transport });
+  const state = await info.clearinghouseState({ user: account });
+  if (units(state.marginSummary.accountValue, 6, false) < 10000000n)
+    throw new Error(`Fund Hyperliquid ${options.network ?? "testnet"} account ${account} with at least 10 USDC before setup`);
+  const client = new ExchangeClient({ wallet, transport });
+  const agents = await info.extraAgents({ user: account });
+  if (!agents.some((entry) => entry.address.toLowerCase() === agent.toLowerCase() && (entry.validUntil === null || entry.validUntil > Date.now())))
+    await client.approveAgent({
+      agentAddress: agent,
+      agentName: options.agentName ?? "Depth maker"
+    });
+  const meta = await info.meta();
+  const asset = meta.universe.findIndex((entry) => entry.name === "SOL" && !entry.isDelisted);
+  if (asset < 0)
+    throw new Error("Hyperliquid SOL perpetual is unavailable");
+  await client.updateLeverage({
+    asset,
+    isCross: true,
+    leverage: options.leverage
+  });
+  return {
+    account,
+    agent,
+    network: options.network ?? "testnet",
+    leverage: options.leverage
+  };
+}
+export {
+  validateHedgePolicy,
+  validateBotPolicy,
+  setup_hyperliquid,
+  create_maker_bot,
+  create_hyperliquid,
+  MakerBot,
+  HyperliquidAdapter,
+  HedgeEngine,
+  FillCursorStore,
+  BotStore
+};