@depthhq/maker-sdk 0.1.0 → 0.1.3

package/dist/index.js

@@ -26399,13 +26399,517 @@ import {
 } from "@depthhq/bindings";
 import { DepthView } from "@depthhq/sdk/views";
 import { DepthRecovery } from "@depthhq/sdk/recovery";
-import { PublicKey as PublicKey5 } from "@solana/web3.js";
+import { PublicKey as PublicKey7 } from "@solana/web3.js";
 
 // src/chain/random.ts
 function randomBytes3(length) {
   return crypto.getRandomValues(new Uint8Array(length));
 }
 
+// src/hedge/schema.ts
+var object = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
+var integer = (value) => Number.isSafeInteger(value) && value >= 0;
+var amount = (value) => typeof value === "string" && /^-?\d{1,40}$/.test(value);
+var optional = (value, check) => value === undefined || check(value);
+var text = (value) => typeof value === "string" && value.length <= 1024;
+function order(value, receipt = false) {
+  if (!object(value) || typeof value.cloid !== "string" || !/^0x[0-9a-f]{32}$/.test(value.cloid) || !integer(value.nonce) || !integer(value.expiresAt) || value.expiresAt <= value.nonce || typeof value.buy !== "boolean" || typeof value.reduceOnly !== "boolean" || !amount(value.size) || BigInt(value.size) <= 0n || !amount(value.limitPriceE8) || BigInt(value.limitPriceE8) <= 0n)
+    return false;
+  if (!receipt)
+    return true;
+  return ["filled", "cancelled", "rejected"].includes(String(value.status)) && integer(value.completedAt) && value.completedAt >= value.nonce && amount(value.filledSize) && BigInt(value.filledSize) >= 0n && BigInt(value.filledSize) <= BigInt(value.size) && optional(value.orderId, integer) && optional(value.averagePriceE8, amount) && optional(value.fee, amount) && optional(value.reason, text) && optional(value.hashes, (hashes) => Array.isArray(hashes) && hashes.length <= 2000 && hashes.every((hash) => typeof hash === "string" && /^0x[0-9a-fA-F]{64}$/.test(hash)));
+}
+function hedgeView(value, owner) {
+  if (!object(value) || value.maker !== owner || typeof value.enabled !== "boolean")
+    throw new Error("Maker hedge response belongs to another wallet or is invalid");
+  const snapshot = value.snapshot;
+  if (snapshot !== null && (!value.enabled || !object(snapshot) || snapshot.venue !== "hyperliquid" || !["testnet", "mainnet"].includes(String(snapshot.network)) || typeof snapshot.account !== "string" || !/^0x[0-9a-fA-F]{40}$/.test(snapshot.account) || !integer(snapshot.updatedAt) || !["balanced", "waiting", "pending", "blocked"].includes(String(snapshot.phase)) || !optional(snapshot.reason, text) || !optional(snapshot.depthPosition, amount) || !optional(snapshot.externalPosition, amount) || !optional(snapshot.unhedgedPosition, amount) || !optional(snapshot.pending, order) || !Array.isArray(snapshot.history) || snapshot.history.length > 50 || !snapshot.history.every((record) => order(record, true))))
+    throw new Error("Maker hedge response is invalid");
+  return value;
+}
+
+// src/hedge/access.ts
+var accessMessage = (wallet, nonce, expiresAt, scope = "Read hedge history") => `Depth maker access
+Wallet: ${wallet}
+Scope: ${scope}
+Nonce: ${nonce}
+Expires: ${expiresAt}`;
+
+class WalletSession {
+  options;
+  scope;
+  prefix;
+  token;
+  constructor(options, scope = "Read hedge history", prefix = "") {
+    this.options = options;
+    this.scope = scope;
+    this.prefix = prefix;
+  }
+  async request(path, init) {
+    if (!this.options.serviceUrl)
+      throw new Error("A maker service URL is required");
+    const response = await fetch(`${this.options.serviceUrl.replace(/\/$/, "")}/v1/maker/${`${this.prefix}${path}`.replace(/\/$/, "")}`, {
+      ...init,
+      cache: "no-store",
+      signal: AbortSignal.timeout(15000)
+    });
+    if (response.status === 401) {
+      this.token = undefined;
+      throw new Error("Authorize access with your maker wallet");
+    }
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({}));
+      throw new Error(typeof error.message === "string" ? error.message : response.status === 403 ? "This worker belongs to another maker" : "Maker worker is unavailable");
+    }
+    return response.json();
+  }
+  async authorize() {
+    const wallet = this.options.wallet;
+    if (!wallet.signMessage)
+      throw new Error("This wallet cannot sign access messages");
+    const challenge = await this.request(`challenge?wallet=${wallet.publicKey.toBase58()}`);
+    if (challenge.wallet !== wallet.publicKey.toBase58() || !/^[0-9a-f]{64}$/.test(challenge.nonce) || !Number.isSafeInteger(challenge.expiresAt) || challenge.expiresAt <= Date.now() || challenge.expiresAt > Date.now() + 120000 || challenge.message !== accessMessage(challenge.wallet, challenge.nonce, challenge.expiresAt, this.scope))
+      throw new Error("Maker access challenge is invalid");
+    const signature = await wallet.signMessage(new TextEncoder().encode(challenge.message));
+    const session = await this.request("session", {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({
+        nonce: challenge.nonce,
+        signature: Buffer.from(signature).toString("base64")
+      })
+    });
+    if (!/^[0-9a-f]{64}$/.test(session.token) || !Number.isSafeInteger(session.expiresAt) || session.expiresAt <= Date.now() || session.expiresAt > Date.now() + 16 * 60000)
+      throw new Error("Maker access session is invalid");
+    this.token = { value: session.token, expiresAt: session.expiresAt };
+  }
+  async authorizedRequest(path, body) {
+    if (!this.token || this.token.expiresAt <= Date.now())
+      await this.authorize();
+    return this.request(path, {
+      method: body === undefined ? "GET" : "POST",
+      headers: {
+        authorization: `Bearer ${this.token.value}`,
+        "content-type": "application/json"
+      },
+      body: body === undefined ? undefined : JSON.stringify(body)
+    });
+  }
+  disconnect() {
+    this.token = undefined;
+  }
+}
+
+class MakerAccess extends WalletSession {
+  async summary() {
+    if (!this.token || this.token.expiresAt <= Date.now()) {
+      this.token = undefined;
+      throw new Error("Authorize access with your maker wallet");
+    }
+    return hedgeView(await this.authorizedRequest("hedges"), this.options.wallet.publicKey.toBase58());
+  }
+}
+
+// src/automation/automation.ts
+import { PublicKey as PublicKey3, SystemProgram, Transaction } from "@solana/web3.js";
+
+// src/hedge/setup.ts
+import { ExchangeClient, HttpTransport, InfoClient } from "@nktkas/hyperliquid";
+import {
+  getWalletAddress
+} from "@nktkas/hyperliquid/signing";
+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 amount2 = BigInt(whole) * 10n ** BigInt(decimals) + BigInt(fraction.slice(0, decimals).padEnd(decimals, "0") || "0");
+  return negative ? -amount2 - (!exact && /[1-9]/.test(extra) ? 1n : 0n) : amount2;
+}
+
+// src/hedge/setup.ts
+async function verify_hyperliquid(options) {
+  const info = new InfoClient({
+    transport: new HttpTransport({ isTestnet: options.network === "testnet" })
+  });
+  const [state, agents] = await Promise.all([
+    info.clearinghouseState({ user: options.account }),
+    info.extraAgents({ user: options.account })
+  ]);
+  if (units(state.withdrawable, 6, false) < 10000000n)
+    throw new Error(`Fund Hyperliquid ${options.network} account ${options.account} with at least 10 available USDC`);
+  if (!agents.some((entry) => entry.address.toLowerCase() === options.agent.toLowerCase() && (entry.validUntil === null || entry.validUntil > Date.now())))
+    throw new Error("Approve the displayed agent in Hyperliquid API wallets, or connect its account wallet");
+  const position = state.assetPositions.find((entry) => entry.position.coin === "SOL")?.position;
+  if (position && position.leverage.value > options.maxLeverage)
+    throw new Error("SOL leverage exceeds the configured hedge limit");
+}
+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 ?? privateKeyToAccount(options.agentKey).address;
+  if (!/^0x[0-9a-fA-F]{40}$/.test(agent))
+    throw new Error("Hyperliquid agent address is invalid");
+  const wallet = options.wallet ?? privateKeyToAccount(options.accountKey);
+  const account = await getWalletAddress(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 HttpTransport({
+    isTestnet: (options.network ?? "testnet") === "testnet"
+  });
+  const info = new InfoClient({ 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
+  };
+}
+
+// src/automation/types.ts
+import { PublicKey as PublicKey2 } from "@solana/web3.js";
+
+// 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");
+}
+
+// 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");
+}
+
+// src/automation/types.ts
+var amount2 = (value, name) => {
+  if (typeof value !== "string" || !/^\d{1,20}$/.test(value) || BigInt(value) > (1n << 64n) - 1n)
+    throw new Error(`${name} must be an unsigned integer amount`);
+  return BigInt(value);
+};
+var object2 = (value, names) => {
+  if (!value || typeof value !== "object" || Array.isArray(value) || Object.keys(value).some((key) => !names.includes(key)))
+    throw new Error("Automation configuration is invalid");
+  return value;
+};
+var integer2 = (value, fallback) => {
+  const result = value ?? fallback;
+  if (typeof result !== "number" || !Number.isSafeInteger(result))
+    throw new Error("Automation limits must be integers");
+  return result;
+};
+function automationConfig(value) {
+  const input = object2(value, ["quote", "hedge"]);
+  const quote = object2(input.quote, [
+    "maxCapacity",
+    "maxInventoryNotional",
+    "spreadBps",
+    "repriceBps",
+    "lifetimeSeconds",
+    "refreshSeconds",
+    "gasReserveLamports",
+    "inventorySkewBps",
+    "executionCostBps",
+    "fundingHours"
+  ]);
+  const policy = {
+    maxCapacity: amount2(quote.maxCapacity, "Capacity"),
+    maxInventoryNotional: amount2(quote.maxInventoryNotional, "Inventory limit"),
+    spreadBps: integer2(quote.spreadBps),
+    repriceBps: integer2(quote.repriceBps),
+    lifetimeSeconds: integer2(quote.lifetimeSeconds),
+    refreshSeconds: integer2(quote.refreshSeconds),
+    gasReserveLamports: amount2(quote.gasReserveLamports ?? "50000000", "SOL reserve"),
+    inventorySkewBps: integer2(quote.inventorySkewBps, 15),
+    executionCostBps: integer2(quote.executionCostBps, 5),
+    fundingHours: integer2(quote.fundingHours, 1)
+  };
+  validateBotPolicy(policy);
+  if (policy.lifetimeSeconds > 86400 || policy.refreshSeconds > 86400)
+    throw new Error("Quote lifetime must be at most one day");
+  if (input.hedge === undefined)
+    return { quote: policy };
+  const hedge = object2(input.hedge, ["account", "policy"]);
+  if (typeof hedge.account !== "string" || !/^0x[0-9a-fA-F]{40}$/.test(hedge.account))
+    throw new Error("Hyperliquid account address is invalid");
+  const risk = object2(hedge.policy, [
+    "ratioBps",
+    "thresholdNotional",
+    "maxUnhedgedNotional",
+    "maxOrderNotional",
+    "batchMs",
+    "maxUnhedgedMs",
+    "maxSlippageBps",
+    "maxPriceAgeMs",
+    "orderTtlMs",
+    "maxLeverage"
+  ]);
+  const hedgePolicy = {
+    ratioBps: integer2(risk.ratioBps),
+    thresholdNotional: amount2(risk.thresholdNotional, "Hedge threshold"),
+    maxUnhedgedNotional: amount2(risk.maxUnhedgedNotional, "Exposure limit"),
+    maxOrderNotional: amount2(risk.maxOrderNotional, "Order limit"),
+    batchMs: integer2(risk.batchMs),
+    maxUnhedgedMs: integer2(risk.maxUnhedgedMs),
+    maxSlippageBps: integer2(risk.maxSlippageBps),
+    maxPriceAgeMs: integer2(risk.maxPriceAgeMs),
+    orderTtlMs: integer2(risk.orderTtlMs),
+    maxLeverage: integer2(risk.maxLeverage)
+  };
+  validateHedgePolicy(hedgePolicy);
+  return {
+    quote: policy,
+    hedge: {
+      account: hedge.account.toLowerCase(),
+      policy: hedgePolicy
+    }
+  };
+}
+var automationWire = (config) => JSON.parse(JSON.stringify(config, (_key, value) => typeof value === "bigint" ? value.toString() : value));
+function automationView(value, owner, environment) {
+  if (value === null)
+    return null;
+  const view = object2(value, [
+    "owner",
+    "environment",
+    "revision",
+    "operator",
+    "agent",
+    "config",
+    "desired",
+    "phase",
+    "updatedAt",
+    "reason",
+    "bot",
+    "hedge",
+    "funding"
+  ]);
+  if (view.owner !== owner || view.environment !== environment)
+    throw new Error("Automation belongs to another wallet or network");
+  if (typeof view.operator !== "string" || new PublicKey2(view.operator).toBase58() !== view.operator || typeof view.agent !== "string" || !/^0x[0-9a-fA-F]{40}$/.test(view.agent) || integer2(view.revision) < 1 || integer2(view.updatedAt) < 1 || !["running", "paused"].includes(String(view.desired)) || ![
+    "configured",
+    "starting",
+    "running",
+    "pausing",
+    "paused",
+    "blocked"
+  ].includes(String(view.phase)) || view.reason !== undefined && typeof view.reason !== "string")
+    throw new Error("Automation response is invalid");
+  automationConfig(view.config);
+  if (view.bot !== undefined) {
+    const bot = object2(view.bot, ["phase", "reason", "quoteId", "fillCount"]);
+    if (!["active", "pending", "idle", "stopped"].includes(String(bot.phase)) || integer2(bot.fillCount) < 0 || bot.reason !== undefined && typeof bot.reason !== "string" || bot.quoteId !== undefined && (typeof bot.quoteId !== "string" || new PublicKey2(bot.quoteId).toBase58() !== bot.quoteId))
+      throw new Error("Automation status is invalid");
+  }
+  hedgeView(view.hedge, owner);
+  if (view.funding !== undefined) {
+    const funding = object2(view.funding, ["signature", "lamports", "status"]);
+    if (typeof funding.signature !== "string" || !/^[1-9A-HJ-NP-Za-km-z]{64,90}$/.test(funding.signature) || !["pending", "confirmed", "expired", "failed"].includes(String(funding.status)))
+      throw new Error("Operator funding receipt is invalid");
+    amount2(funding.lamports, "Operator funding");
+  }
+  return view;
+}
+
+// src/automation/automation.ts
+class MakerAutomation extends WalletSession {
+  maker;
+  constructor(maker) {
+    super(maker.options, "Manage maker automation", "automation/");
+    this.maker = maker;
+  }
+  view(value) {
+    return automationView(value, this.maker.options.wallet.publicKey.toBase58(), this.maker.options.environment ?? "");
+  }
+  async summary() {
+    if (!this.token || this.token.expiresAt <= Date.now())
+      throw new Error("Authorize automation with your maker wallet");
+    return this.view(await this.authorizedRequest(""));
+  }
+  async configure(config, revision) {
+    const wire = automationWire(config);
+    automationConfig(wire);
+    if (revision === undefined) {
+      if (!this.token || this.token.expiresAt <= Date.now())
+        await this.authorize();
+      revision = (await this.summary())?.revision ?? 0;
+    }
+    if (!Number.isSafeInteger(revision) || revision < 0)
+      throw new Error("Automation revision is invalid");
+    return this.view(await this.authorizedRequest("configure", { revision, config: wire }));
+  }
+  async approve(profile, options = {}) {
+    this.view(profile);
+    const current = await this.summary();
+    if (!current || current.revision !== profile.revision || current.operator !== profile.operator || current.agent !== profile.agent)
+      throw new Error("Automation configuration changed; review it again");
+    if (!this.maker.options.maker.equals(this.maker.options.wallet.publicKey))
+      throw new Error("The maker owner must approve automation");
+    if (current.desired !== "paused" || !["configured", "paused"].includes(current.phase))
+      throw new Error("Pause automation before approving its operator");
+    const config = automationConfig(current.config);
+    const grantSeconds = options.grantSeconds ?? 86400;
+    if (!Number.isSafeInteger(grantSeconds) || grantSeconds < 60 || grantSeconds > 604800)
+      throw new Error("Operator approval must last 1 minute to 7 days");
+    const target = options.operatorFundingLamports ?? config.quote.gasReserveLamports + 200000000n;
+    if (target < config.quote.gasReserveLamports || target > 10000000000n)
+      throw new Error("Operator funding must cover the reserve and stay within 10 SOL");
+    if (config.hedge) {
+      const network = profile.environment === "devnet" ? "testnet" : "mainnet";
+      if (options.hedgeWallet)
+        await setup_hyperliquid({
+          wallet: options.hedgeWallet,
+          account: config.hedge.account,
+          agent: profile.agent,
+          network,
+          leverage: config.hedge.policy.maxLeverage,
+          agentName: `Depth ${profile.agent.slice(2, 10)}`
+        });
+      else
+        await verify_hyperliquid({
+          account: config.hedge.account,
+          agent: profile.agent,
+          network,
+          maxLeverage: config.hedge.policy.maxLeverage
+        });
+    }
+    const operator = new PublicKey3(profile.operator);
+    const balance = BigInt(await this.maker.options.connection.getBalance(operator, "confirmed"));
+    const signatures = [];
+    const recovered = this.view(await this.authorizedRequest("fund", { revision: current.revision }));
+    if (recovered.funding?.status === "pending")
+      signatures.push((await this.waitFunding(current.revision)).signature);
+    else if (balance < target) {
+      const blockhash = await this.maker.options.connection.getLatestBlockhash("confirmed");
+      const transaction = new Transaction({
+        ...blockhash,
+        feePayer: this.maker.options.wallet.publicKey
+      }).add(SystemProgram.transfer({
+        fromPubkey: this.maker.options.wallet.publicKey,
+        toPubkey: operator,
+        lamports: target - balance
+      }));
+      const signed = await this.maker.options.wallet.signTransaction(transaction);
+      this.view(await this.authorizedRequest("fund", {
+        revision: current.revision,
+        transaction: Buffer.from(signed.serialize()).toString("base64"),
+        lastValidBlockHeight: blockhash.lastValidBlockHeight,
+        targetLamports: target.toString()
+      }));
+      signatures.push((await this.waitFunding(current.revision)).signature);
+    }
+    signatures.push(await this.maker.operator.authorize({
+      operator,
+      maxCapacity: config.quote.maxCapacity,
+      expiresAt: Math.floor(Date.now() / 1000) + grantSeconds,
+      canView: true
+    }));
+    return { profile: current, signatures };
+  }
+  async waitFunding(revision) {
+    const deadline = Date.now() + 120000;
+    for (;; ) {
+      const profile = this.view(await this.authorizedRequest("fund", { revision }));
+      const receipt = profile.funding;
+      if (!receipt)
+        throw new Error("Operator funding receipt is unavailable");
+      if (receipt.status === "confirmed")
+        return receipt;
+      if (receipt.status !== "pending")
+        throw new Error(`Operator funding ${receipt.status}; retry approval after reviewing its receipt`);
+      if (Date.now() >= deadline)
+        throw new Error("Operator funding is pending; its signed transaction is saved and approval can resume");
+      await new Promise((resolve) => setTimeout(resolve, 1000));
+    }
+  }
+  async command(action, revision) {
+    if (revision === undefined) {
+      if (!this.token || this.token.expiresAt <= Date.now())
+        await this.authorize();
+      const profile = await this.summary();
+      if (!profile)
+        throw new Error("Configure maker automation first");
+      revision = profile.revision;
+    }
+    if (!Number.isSafeInteger(revision) || revision < 1)
+      throw new Error("Automation revision is invalid");
+    return this.view(await this.authorizedRequest(action, { revision }));
+  }
+  start(revision) {
+    return this.command("start", revision);
+  }
+  pause(revision) {
+    return this.command("pause", revision);
+  }
+  resume(revision) {
+    return this.start(revision);
+  }
+}
+
 // src/client/client.ts
 import {
   DepthClient,
@@ -26445,7 +26949,7 @@ async function queueAccounts(provider, connection, name, offset) {
 import * as anchor2 from "@anchor-lang/core";
 import { DEPTH_PROGRAM_ID as DEPTH_PROGRAM_ID2, SOL_USD_MARKET_ID } from "@depthhq/bindings";
 import { DepthError } from "@depthhq/sdk";
-import { PublicKey as PublicKey2 } from "@solana/web3.js";
+import { PublicKey as PublicKey4 } from "@solana/web3.js";
 function u64(value, name) {
   if (typeof value !== "bigint" || value < 0n || value > (1n << 64n) - 1n)
     throw new RangeError(`${name} must be an unsigned 64-bit bigint`);
@@ -26462,7 +26966,7 @@ function timing(options) {
 }
 function address2(market, maker, nonce) {
   const bytes = u64(nonce, "clientNonce").toArrayLike(Buffer, "le", 8);
-  return PublicKey2.findProgramAddressSync([Buffer.from("backstop"), market.toBuffer(), maker.toBuffer(), bytes], DEPTH_PROGRAM_ID2)[0];
+  return PublicKey4.findProgramAddressSync([Buffer.from("backstop"), market.toBuffer(), maker.toBuffer(), bytes], DEPTH_PROGRAM_ID2)[0];
 }
 async function poll(read2, terminal, options) {
   const { timeoutMs, pollMs } = timing(options);
@@ -26504,7 +27008,7 @@ class BackstopHandle {
     ]);
     const now = Math.floor(Date.now() / 1000);
     const margin = (input.maxCapacity * BigInt(market.config.initialMarginBps) + 9999n) / 10000n;
-    if (!market.backstopOffer.equals(PublicKey2.default) || market.pendingOrders !== 0 || Object.keys(market.status)[0] === "settling" || input.maxCapacity > BigInt(market.config.maxAccountNotional.toString()) || margin < BigInt(market.config.backstopMinCollateral.toString()))
+    if (!market.backstopOffer.equals(PublicKey4.default) || market.pendingOrders !== 0 || Object.keys(market.status)[0] === "settling" || input.maxCapacity > BigInt(market.config.maxAccountNotional.toString()) || margin < BigInt(market.config.backstopMinCollateral.toString()))
       throw new Error("Backstop offer is outside the current market policy");
     if (!account.owner.equals(client.options.maker) || !account.market.equals(client.marketAddress) || !("ready" in account.status))
       throw new Error("Maker market account is unavailable");
@@ -26591,7 +27095,7 @@ class BackstopRelease {
 
 // src/fill/history.ts
 import * as anchor3 from "@anchor-lang/core";
-import { PublicKey as PublicKey3 } from "@solana/web3.js";
+import { PublicKey as PublicKey5 } from "@solana/web3.js";
 
 class FillHistory {
   client;
@@ -26641,9 +27145,9 @@ class FillHistory {
         for (const ix of instructions2) {
           if (!keys.get(ix.programIdIndex)?.equals(this.client.program.programId) || !ix.data.subarray(0, 8).equals(Buffer.from(definition.discriminator)))
             continue;
-          const order = keys.get(ix.accounts[orderIndex]);
-          if (order)
-            orders.set(order.toBase58(), {
+          const order2 = keys.get(ix.accounts[orderIndex]);
+          if (order2)
+            orders.set(order2.toBase58(), {
               signature: signature.signature,
               slot: signature.slot
             });
@@ -26654,12 +27158,12 @@ class FillHistory {
     const fills = [];
     for (let i2 = 0;i2 < addresses.length; i2 += 100) {
       const batch = addresses.slice(i2, i2 + 100);
-      const accounts2 = await connection.getMultipleAccountsInfo(batch.map((id) => new PublicKey3(id)), "finalized");
+      const accounts2 = await connection.getMultipleAccountsInfo(batch.map((id) => new PublicKey5(id)), "finalized");
       accounts2.forEach((info, index) => {
         if (!info || !info.owner.equals(this.client.program.programId))
           throw new Error("Finalized fill receipt is unavailable");
-        const order = this.client.program.coder.accounts.decode("orderRecord", info.data);
-        if (order.maker.equals(this.client.options.maker) && order.market.equals(this.client.marketAddress) && "trade" in order.kind && "filled" in order.status) {
+        const order2 = this.client.program.coder.accounts.decode("orderRecord", info.data);
+        if (order2.maker.equals(this.client.options.maker) && order2.market.equals(this.client.marketAddress) && "trade" in order2.kind && "filled" in order2.status) {
           fills.push({ id: batch[index], ...orders.get(batch[index]) });
         }
       });
@@ -26915,51 +27419,78 @@ class QuoteHandle {
   }
   async cancel() {
     const snapshot = await this.status();
+    if (["cancelled", "filled", "rejected", "releasing"].includes(snapshot.status))
+      return snapshot;
     const actor = this.client.options.wallet.publicKey;
     const grant = actor.equals(this.client.options.maker) ? undefined : this.client.grantAddress();
     if (snapshot.status === "validating" || snapshot.status === "validated") {
-      await this.client.program.methods.cancelPreparedQuote().accountsPartial({
+      return this.cancelStep(() => this.client.program.methods.cancelPreparedQuote().accountsPartial({
         actor,
         grant: grant ?? this.client.program.programId,
         quote: this.id
-      }).rpc({ commitment: "confirmed" });
-      return this.status();
+      }).rpc({ commitment: "confirmed" }), ["cancelled", "rejected"]);
     }
     if (snapshot.status === "active" || snapshot.status === "waiting") {
-      await this.client.program.methods.stopQuote().accountsPartial({
+      await this.cancelStep(() => this.client.program.methods.stopQuote().accountsPartial({
         actor,
         market: this.client.marketAddress,
         quoteQueue: this.client.quoteQueueAddress,
         grant: grant ?? this.client.program.programId,
         quote: this.id
-      }).rpc({ commitment: "confirmed" });
+      }).rpc({ commitment: "confirmed" }), ["closing", "releasing", "cancelled", "filled"]);
     } else if (snapshot.status !== "closing") {
       throw new Error("Quote cannot be cancelled in its current state");
     }
     const current = await this.status();
-    if (snapshot.status === "waiting")
+    if (current.status !== "closing")
       return current;
     if (current.attachedOrders > 0)
       return current;
+    const [market, makerAccount] = await Promise.all([
+      this.client.read("Market", this.client.marketAddress),
+      this.client.read("MarketAccount", this.client.marketAccount())
+    ]);
+    if (market.pendingOrders > 0 || name(makerAccount.status) !== "ready")
+      return current;
     const offset = new anchor4.BN(randomBytes3(8), "le");
     const queue = await this.client.queue("release_quote", offset);
-    this.releaseSignature = await this.client.program.methods.releaseQuote(offset).accountsPartial({
-      ...queue,
-      payer: actor,
-      protocol: this.client.protocolAddress,
-      market: this.client.marketAddress,
-      marketAccount: this.client.marketAccount(),
-      grant: grant ?? this.client.program.programId,
-      quote: this.id
-    }).rpc({ commitment: "confirmed" });
+    return this.cancelStep(async () => {
+      this.releaseSignature = await this.client.program.methods.releaseQuote(offset).accountsPartial({
+        ...queue,
+        payer: actor,
+        protocol: this.client.protocolAddress,
+        market: this.client.marketAddress,
+        marketAccount: this.client.marketAccount(),
+        grant: grant ?? this.client.program.programId,
+        quote: this.id
+      }).rpc({ commitment: "confirmed" });
+    }, ["releasing", "cancelled", "filled"]);
+  }
+  async cancelStep(submit, completed) {
+    try {
+      await submit();
+    } catch (error) {
+      const snapshot = await this.status();
+      if (completed.includes(snapshot.status))
+        return snapshot;
+      throw error;
+    }
     return this.status();
   }
+  async close() {
+    if (!this.client.options.wallet.publicKey.equals(this.client.options.maker))
+      throw new Error("Only the maker owner can reclaim quote rent");
+    const snapshot = await this.status();
+    if (!["cancelled", "filled", "rejected"].includes(snapshot.status) || snapshot.attachedOrders > 0)
+      throw new Error("Release the quote and settle its orders before closing");
+    return this.client.program.methods.closeQuote().accountsPartial({ maker: this.client.options.maker, quote: this.id }).rpc({ commitment: "confirmed" });
+  }
 }
 
 // src/quote/replacement.ts
 import * as anchor5 from "@anchor-lang/core";
 import { DEPTH_PROGRAM_ID as DEPTH_PROGRAM_ID3 } from "@depthhq/bindings";
-import { PublicKey as PublicKey4 } from "@solana/web3.js";
+import { PublicKey as PublicKey6 } from "@solana/web3.js";
 class QuoteReplacement {
   client;
   priorId;
@@ -26973,7 +27504,7 @@ class QuoteReplacement {
       throw new RangeError("clientNonce must be an unsigned 64-bit bigint");
     }
     const bytes = new anchor5.BN(nonce.toString()).toArrayLike(Buffer, "le", 8);
-    this.nextId = PublicKey4.findProgramAddressSync([
+    this.nextId = PublicKey6.findProgramAddressSync([
       Buffer.from("quote"),
       client.marketAddress.toBuffer(),
       client.options.maker.toBuffer(),
@@ -26998,17 +27529,7 @@ class QuoteReplacement {
       phase: next?.status === "active" || next?.status === "filled" ? "active" : next?.status === "rejected" ? "failed" : next ? "publishing" : stopped ? "ready" : "stopping"
     };
   }
-  async resume(input, options = {}) {
-    if (input.clientNonce !== undefined && input.clientNonce !== this.nonce) {
-      throw new Error("Replacement terms use a different client nonce");
-    }
-    const timeoutMs = options.timeoutMs ?? 60000;
-    const pollMs = options.pollMs ?? 1000;
-    if (!Number.isSafeInteger(timeoutMs) || timeoutMs < 0 || !Number.isSafeInteger(pollMs) || pollMs < 100) {
-      throw new RangeError("Replacement timeout or polling interval is invalid");
-    }
-    const deadline = Date.now() + timeoutMs;
-    const previous = this.client.quote.get(this.priorId);
+  async begin() {
     const prior = await this.client.quoteState(this.priorId);
     const recorded = prior.replacementNonce == null ? undefined : BigInt(prior.replacementNonce.toString());
     if (recorded !== undefined && recorded !== this.nonce) {
@@ -27022,6 +27543,17 @@ class QuoteReplacement {
         quote: this.priorId
       }).rpc({ commitment: "confirmed" });
     }
+  }
+  async resume(input, options = {}) {
+    if (input.clientNonce !== undefined && input.clientNonce !== this.nonce)
+      throw new Error("Replacement terms use a different client nonce");
+    const timeoutMs = options.timeoutMs ?? 60000;
+    const pollMs = options.pollMs ?? 1000;
+    if (!Number.isSafeInteger(timeoutMs) || timeoutMs < 0 || !Number.isSafeInteger(pollMs) || pollMs < 100)
+      throw new RangeError("Replacement timeout or polling interval is invalid");
+    const deadline = Date.now() + timeoutMs;
+    const previous = this.client.quote.get(this.priorId);
+    await this.begin();
     for (;; ) {
       const snapshot = await previous.status();
       if (["cancelled", "filled"].includes(snapshot.status))
@@ -27047,7 +27579,7 @@ class QuoteReplacement {
 
 // src/client/client.ts
 function pda(seeds) {
-  return PublicKey5.findProgramAddressSync(seeds, DEPTH_PROGRAM_ID4)[0];
+  return PublicKey7.findProgramAddressSync(seeds, DEPTH_PROGRAM_ID4)[0];
 }
 function u642(value, name2) {
   if (typeof value !== "bigint" || value < 0n || value > (1n << 64n) - 1n) {
@@ -27058,12 +27590,25 @@ function u642(value, name2) {
 function offset() {
   return new anchor6.BN(randomBytes3(8), "le");
 }
+async function retryQuote(action, deadline) {
+  for (;; ) {
+    try {
+      return await action();
+    } catch (error) {
+      if (!(error instanceof anchor6.AnchorError) || error.error.errorCode.code !== "WrongMarketAccountStatus" || Date.now() >= deadline)
+        throw error;
+      await new Promise((resolve) => setTimeout(resolve, 1000));
+    }
+  }
+}
 function stateName(value) {
   return Object.keys(value)[0] ?? "unknown";
 }
 
 class MakerClient {
   options;
+  hedges;
+  automation;
   provider;
   program;
   position;
@@ -27091,6 +27636,8 @@ class MakerClient {
   }
   constructor(options) {
     this.options = options;
+    this.hedges = new MakerAccess(options);
+    this.automation = new MakerAutomation(this);
     this.provider = new DepthProvider(options.connection, options.wallet, {
       commitment: "confirmed",
       preflightCommitment: "confirmed"
@@ -27100,7 +27647,7 @@ class MakerClient {
     this.backstop = Object.assign((id) => new BackstopHandle(id, this), { offer: (input) => BackstopHandle.offer(this, input) });
   }
   static async create(options) {
-    const appId = typeof options.appId === "string" ? new PublicKey5(options.appId) : options.appId;
+    const appId = typeof options.appId === "string" ? new PublicKey7(options.appId) : options.appId;
     if (options.maker && options.makerOwner && !options.maker.equals(options.makerOwner)) {
       throw new Error("maker and makerOwner identify different accounts");
     }
@@ -27144,21 +27691,21 @@ class MakerClient {
       openMarket: async () => this.funding.openMarket(),
       summary: async () => (await this.owned()).account.summary(),
       pending: async () => (await this.owned()).account.pending(),
-      deposit: async (sourceOrAmount, amount, clientNonce) => {
-        if (sourceOrAmount instanceof PublicKey5) {
-          if (amount === undefined || clientNonce === undefined)
+      deposit: async (sourceOrAmount, amount3, clientNonce) => {
+        if (sourceOrAmount instanceof PublicKey7) {
+          if (amount3 === undefined || clientNonce === undefined)
             throw new RangeError("Source deposits require amount and nonce");
-          return this.funding.deposit(sourceOrAmount, amount, clientNonce);
+          return this.funding.deposit(sourceOrAmount, amount3, clientNonce);
         }
         return (await this.owned()).account.deposit(sourceOrAmount);
       },
       withdrawalHandle: (clientNonce) => this.funding.withdrawalHandle(clientNonce),
       depositHandle: (nonce) => this.funding.depositHandle(nonce),
-      withdraw: async (destinationOrAmount, amount, clientNonce) => {
-        if (destinationOrAmount instanceof PublicKey5) {
-          if (amount === undefined || clientNonce === undefined)
+      withdraw: async (destinationOrAmount, amount3, clientNonce) => {
+        if (destinationOrAmount instanceof PublicKey7) {
+          if (amount3 === undefined || clientNonce === undefined)
             throw new RangeError("Destination withdrawals require amount and nonce");
-          return this.funding.withdraw(destinationOrAmount, amount, clientNonce);
+          return this.funding.withdraw(destinationOrAmount, amount3, clientNonce);
         }
         return (await this.owned()).account.withdraw(destinationOrAmount);
       },
@@ -27193,8 +27740,8 @@ class MakerClient {
       operator.toBuffer()
     ]);
   }
-  async read(name2, address3) {
-    const info = await this.options.connection.getAccountInfo(address3, "confirmed");
+  async read(name2, address3, commitment = "confirmed") {
+    const info = await this.options.connection.getAccountInfo(address3, commitment);
     if (!info || !info.owner.equals(DEPTH_PROGRAM_ID4)) {
       throw new Error(`${name2} account is unavailable`);
     }
@@ -27278,74 +27825,76 @@ class MakerClient {
     replacement: (prior, clientNonce) => new QuoteReplacement(this, prior, clientNonce),
     publish: async (request) => {
       const clientNonce = request.clientNonce ?? BigInt(new anchor6.BN(randomBytes3(8), "le").toString());
-      const quoteNonce = u642(clientNonce, "clientNonce");
-      const id = pda([
-        Buffer.from("quote"),
-        this.marketAddress.toBuffer(),
-        this.options.maker.toBuffer(),
-        quoteNonce.toArrayLike(Buffer, "le", 8)
-      ]);
-      if (await this.options.connection.getAccountInfo(id, "confirmed")) {
-        const existing = await this.quoteState(id);
-        if (BigInt(existing.capacity.toString()) !== request.maxCapacity || "expiresAt" in request && existing.expiry.toNumber() !== request.expiresAt) {
-          throw new Error("Quote nonce is already bound to different public terms");
-        }
-        return this.quote.get(id);
-      }
       const readyDeadline = Date.now() + 60000;
-      for (;; ) {
-        const account = await this.read("MarketAccount", this.marketAccount());
-        if (stateName(account.status) === "ready")
-          break;
-        if (Date.now() >= readyDeadline) {
-          throw new Error("Maker account is processing another operation");
-        }
-        await new Promise((resolve) => setTimeout(resolve, 1000));
-      }
-      const market = await this.read("Market", this.marketAddress);
-      const input = "tiers" in request ? request : this.flatQuote(request, market, clientNonce);
-      this.validateQuote(input, market);
-      const grant = await this.grantFor(input.maxCapacity, input.expiresAt);
-      const mxePublicKey = await getMXEPublicKey(this.provider, DEPTH_PROGRAM_ID4);
-      if (!mxePublicKey)
-        throw new Error("MXE public key is unavailable");
-      const secret = x25519.utils.randomSecretKey();
-      const inputKey = x25519.getPublicKey(secret);
-      const inputNonce = randomBytes3(16);
-      const cipher = new RescueCipher(x25519.getSharedSecret(secret, mxePublicKey));
-      const bid = Array.from({ length: 4 }, (_, i2) => input.tiers[i2]?.bidE8 ?? 0n);
-      const ask = Array.from({ length: 4 }, (_, i2) => input.tiers[i2]?.askE8 ?? 0n);
-      const reciprocal = (price) => {
-        if (price === 0n)
-          return 0n;
-        if (price < 100000000n)
-          throw new RangeError("SOL quote prices must be at least $1");
-        return (1n << 76n) / price;
-      };
-      const ciphertexts = cipher.encrypt(packQuoteCurve({
-        bid,
-        ask,
-        bidReciprocal: bid.map(reciprocal),
-        askReciprocal: ask.map(reciprocal)
-      }), inputNonce);
-      const computationOffset = offset();
-      const queue = await this.queue("prepare_quote", computationOffset);
-      const signature = await this.program.methods.submitQuote(computationOffset, quoteNonce, u642(input.maxCapacity, "maxCapacity"), input.tiers.length, new anchor6.BN(input.expiresAt), market.revision, market.oracleTimestamp, ciphertexts, Array.from(inputKey), new anchor6.BN(inputNonce, "le")).accountsPartial({
-        ...queue,
-        payer: this.options.wallet.publicKey,
-        market: this.marketAddress,
-        marketAccount: this.marketAccount(),
-        grant: grant ?? this.program.programId,
-        quote: id
-      }).rpc({ commitment: "confirmed" });
-      return new QuoteHandle(id, signature, this);
+      return retryQuote(async () => {
+        const quoteNonce = u642(clientNonce, "clientNonce");
+        const id = pda([
+          Buffer.from("quote"),
+          this.marketAddress.toBuffer(),
+          this.options.maker.toBuffer(),
+          quoteNonce.toArrayLike(Buffer, "le", 8)
+        ]);
+        if (await this.options.connection.getAccountInfo(id, "confirmed")) {
+          const existing = await this.quoteState(id);
+          if (BigInt(existing.capacity.toString()) !== request.maxCapacity || "expiresAt" in request && existing.expiry.toNumber() !== request.expiresAt) {
+            throw new Error("Quote nonce is already bound to different public terms");
+          }
+          return this.quote.get(id);
+        }
+        for (;; ) {
+          const account = await this.read("MarketAccount", this.marketAccount());
+          if (stateName(account.status) === "ready")
+            break;
+          if (Date.now() >= readyDeadline) {
+            throw new Error("Maker account is processing another operation");
+          }
+          await new Promise((resolve) => setTimeout(resolve, 1000));
+        }
+        const market = await this.read("Market", this.marketAddress);
+        const input = "tiers" in request ? request : this.flatQuote(request, market, clientNonce);
+        this.validateQuote(input, market);
+        const grant = await this.grantFor(input.maxCapacity, input.expiresAt);
+        const mxePublicKey = await getMXEPublicKey(this.provider, DEPTH_PROGRAM_ID4);
+        if (!mxePublicKey)
+          throw new Error("MXE public key is unavailable");
+        const secret = x25519.utils.randomSecretKey();
+        const inputKey = x25519.getPublicKey(secret);
+        const inputNonce = randomBytes3(16);
+        const cipher = new RescueCipher(x25519.getSharedSecret(secret, mxePublicKey));
+        const bid = Array.from({ length: 4 }, (_, i2) => input.tiers[i2]?.bidE8 ?? 0n);
+        const ask = Array.from({ length: 4 }, (_, i2) => input.tiers[i2]?.askE8 ?? 0n);
+        const reciprocal = (price) => {
+          if (price === 0n)
+            return 0n;
+          if (price < 100000000n)
+            throw new RangeError("SOL quote prices must be at least $1");
+          return (1n << 76n) / price;
+        };
+        const ciphertexts = cipher.encrypt(packQuoteCurve({
+          bid,
+          ask,
+          bidReciprocal: bid.map(reciprocal),
+          askReciprocal: ask.map(reciprocal)
+        }), inputNonce);
+        const computationOffset = offset();
+        const queue = await this.queue("prepare_quote", computationOffset);
+        const signature = await this.program.methods.submitQuote(computationOffset, quoteNonce, u642(input.maxCapacity, "maxCapacity"), input.tiers.length, new anchor6.BN(input.expiresAt), market.revision, market.oracleTimestamp, ciphertexts, Array.from(inputKey), new anchor6.BN(inputNonce, "le")).accountsPartial({
+          ...queue,
+          payer: this.options.wallet.publicKey,
+          market: this.marketAddress,
+          marketAccount: this.marketAccount(),
+          grant: grant ?? this.program.programId,
+          quote: id
+        }).rpc({ commitment: "confirmed" });
+        return new QuoteHandle(id, signature, this);
+      }, readyDeadline);
     },
     get: (id) => new QuoteHandle(id, undefined, this),
     list: async (options = {}) => {
       const limit = options.limit ?? 20;
       if (!Number.isSafeInteger(limit) || limit < 1 || limit > 100)
         throw new RangeError("limit must be an integer from 1 to 100");
-      const cursor = options.cursor ? new PublicKey5(options.cursor).toBase58() : undefined;
+      const cursor = options.cursor ? new PublicKey7(options.cursor).toBase58() : undefined;
       const accounts2 = await this.options.connection.getProgramAccounts(DEPTH_PROGRAM_ID4, {
         commitment: "confirmed",
         dataSlice: { offset: 0, length: 0 },
@@ -27459,8 +28008,8 @@ class MakerClient {
       grant: grant ?? null
     });
   }
-  async requestFillView(order) {
-    const state = await this.read("OrderRecord", order);
+  async requestFillView(order2) {
+    const state = await this.read("OrderRecord", order2);
     if (!state.maker.equals(this.options.maker) || !state.market.equals(this.marketAddress) || stateName(state.status) !== "filled" || stateName(state.kind) !== "trade") {
       throw new Error("Fill is not a finalized trade by this maker");
     }
@@ -27468,12 +28017,12 @@ class MakerClient {
     const viewNonce = offset();
     const view = pda([
       Buffer.from("fill-view"),
-      order.toBuffer(),
+      order2.toBuffer(),
       this.options.wallet.publicKey.toBuffer(),
       viewNonce.toArrayLike(Buffer, "le", 8)
     ]);
     return this.requestView("fill", view, viewNonce, {
-      order,
+      order: order2,
       grant: grant ?? null
     });
   }
@@ -27519,8 +28068,8 @@ class MakerClient {
     const actions = {
       id: address3,
       cancelOpen: () => this.funding.cancelOpenMarket(),
-      addMargin: async (amount, clientNonce) => (await this.owned()).position.addMargin(amount, clientNonce),
-      removeMargin: async (amount, clientNonce) => (await this.owned()).position.removeMargin(amount, clientNonce),
+      addMargin: async (amount3, clientNonce) => (await this.owned()).position.addMargin(amount3, clientNonce),
+      removeMargin: async (amount3, clientNonce) => (await this.owned()).position.removeMargin(amount3, clientNonce),
       summary: async (options = { timeoutMs: 30000 }) => {
         const view = await this.requestMarketView();
         const result = await view.wait(options);
@@ -27540,7 +28089,7 @@ class MakerClient {
       const store = createCursorStore(genesis, this.options.maker.toBase58(), this.options.cursorDirectory);
       const cursor = await store.load();
       return new FillHistory(this).subscribe(async (fill) => {
-        const execution = await this.fills.get(new PublicKey5(fill.id));
+        const execution = await this.fills.get(new PublicKey7(fill.id));
         if (execution.status !== "ready")
           throw new Error(`Private maker fill ${fill.id} is ${execution.status}`);
         await options.onFill({ ...fill, execution });
@@ -27551,8 +28100,8 @@ class MakerClient {
         onError: options.onError
       });
     },
-    get: async (order, options = { timeoutMs: 30000 }) => {
-      const view = await this.requestFillView(order);
+    get: async (order2, options = { timeoutMs: 30000 }) => {
+      const view = await this.requestFillView(order2);
       const result = await view.wait(options);
       if (result.status !== "pending")
         await view.close();
@@ -27593,12 +28142,67 @@ class MakerClient {
 async function createDepthMaker(options) {
   return MakerClient.create(options);
 }
+// src/hedge/wallet.ts
+async function connect_hyperliquid(provider) {
+  const accounts2 = await provider.request({ method: "eth_requestAccounts" });
+  if (!Array.isArray(accounts2) || typeof accounts2[0] !== "string" || !/^0x[0-9a-fA-F]{40}$/.test(accounts2[0]))
+    throw new Error("The Ethereum wallet did not provide an account");
+  const address3 = accounts2[0];
+  const check = async () => {
+    const current = await provider.request({ method: "eth_accounts" });
+    if (!Array.isArray(current) || typeof current[0] !== "string" || current[0].toLowerCase() !== address3.toLowerCase())
+      throw new Error("The Ethereum wallet account changed; connect it again");
+  };
+  return {
+    async getAddresses() {
+      await check();
+      return [address3];
+    },
+    async getChainId() {
+      const chain = await provider.request({ method: "eth_chainId" });
+      if (typeof chain !== "string" || !/^0x[0-9a-fA-F]+$/.test(chain) || !Number.isSafeInteger(Number(chain)))
+        throw new Error("Ethereum wallet chain is invalid");
+      return Number(chain);
+    },
+    async signTypedData(params) {
+      await check();
+      const signature = await provider.request({
+        method: "eth_signTypedData_v4",
+        params: [
+          address3,
+          JSON.stringify({
+            ...params,
+            types: {
+              EIP712Domain: [
+                { name: "name", type: "string" },
+                { name: "version", type: "string" },
+                { name: "chainId", type: "uint256" },
+                { name: "verifyingContract", type: "address" }
+              ],
+              ...params.types
+            }
+          })
+        ]
+      });
+      if (typeof signature !== "string" || !/^0x[0-9a-fA-F]{130}$/.test(signature))
+        throw new Error("Ethereum wallet returned an invalid signature");
+      return signature;
+    }
+  };
+}
 export {
+  setup_hyperliquid,
   createDepthMaker as create_depth_maker,
   createDepthMaker,
+  connect_hyperliquid,
+  automationWire,
+  automationView,
+  automationConfig,
   QuoteReplacement,
   QuoteHandle,
   MakerClient,
+  MakerAutomation,
+  MakerAccess,
   BackstopRelease,
   BackstopHandle
 };