@derivexyz/derive-ts 3.0.4

package/dist/index.js

@@ -0,0 +1,2405 @@
+import {
+  DEFAULT_SIGNATURE_EXPIRY_SEC,
+  encodeCreateSessionKeyActionData,
+  encodeExternalTransfer,
+  encodeRfqExecute,
+  encodeRfqQuote,
+  encodeTradeData,
+  encodeTransfer,
+  encodeUpdateWhitelistedRecipients,
+  encodeVaultBurnShares,
+  encodeVaultCancel,
+  encodeVaultCreate,
+  encodeVaultDeposit,
+  encodeVaultMintShares,
+  encodeVaultWithdraw,
+  encodeWithdrawal,
+  expiresIn,
+  randomNonce,
+  sortRfqLegs,
+  toE18,
+  toScaled
+} from "./chunk-WR2IIVUC.js";
+
+// src/version.ts
+var SDK_VERSION = "3.0.0";
+
+// src/client.ts
+import { Wallet } from "ethers";
+
+// src/api/deposits.ts
+import { Contract, getAddress } from "ethers";
+
+// src/abis/actionManager.ts
+var ACTION_MANAGER_ABI = [
+  "function deposit(address asset, uint256 amount, uint64 subaccountId, address fallbackRecipient) returns (uint256 actionId)",
+  "function depositToNewSubaccount(address asset, uint256 amount, uint32 managerId, address owner) returns (uint256 actionId)"
+];
+
+// src/abis/erc20.ts
+var ERC20_ABI = [
+  "function approve(address spender, uint256 amount) returns (bool)",
+  "function allowance(address owner, address spender) view returns (uint256)",
+  "function balanceOf(address owner) view returns (uint256)",
+  "function decimals() view returns (uint8)"
+];
+
+// src/errors.ts
+var DeriveRpcError = class extends Error {
+  code;
+  data;
+  method;
+  constructor(method, error) {
+    super(
+      `${method}: [${error.code}] ${error.message}${error.data !== void 0 ? ` \u2014 ${JSON.stringify(error.data)}` : ""}`
+    );
+    this.name = "DeriveRpcError";
+    this.method = method;
+    this.code = error.code;
+    this.data = error.data;
+  }
+};
+var DeriveTimeoutError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "DeriveTimeoutError";
+  }
+};
+var DeriveConnectionError = class extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "DeriveConnectionError";
+  }
+};
+
+// src/api/deposits.ts
+var DepositsApi = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+    this.contractCall = new ContractCallDeposits(ctx);
+    this.depositAddress = new DepositAddressDeposits(ctx);
+  }
+  ctx;
+  contractCall;
+  depositAddress;
+  /**
+   * Deposit history rows (up to 1000), regardless of which flow funded
+   * them. Scoped to one subaccount when `subaccountId` is given,
+   * otherwise to the whole owner wallet. Timestamps are unix milliseconds.
+   */
+  async getHistory(options = {}) {
+    return this.ctx.send("private/get_deposit_history", {
+      subaccount_id: options.subaccountId,
+      wallet: options.subaccountId === void 0 ? this.ctx.credentials().ownerAddress : void 0,
+      start_timestamp: options.startTimestampMs,
+      end_timestamp: options.endTimestampMs
+    });
+  }
+  /**
+   * Polls `private/get_subaccounts` until a subaccount id outside
+   * `knownSubaccountIds` appears — the signal that a deposit creating a
+   * new subaccount (either flow) was credited — and returns the new id.
+   * Snapshot the ids BEFORE initiating the deposit.
+   */
+  async awaitCredited(params) {
+    const { knownSubaccountIds, timeoutMs = 12e4, pollIntervalMs = 2e3 } = params;
+    const known = new Set(knownSubaccountIds);
+    const wallet = this.ctx.credentials().ownerAddress;
+    const deadline = Date.now() + timeoutMs;
+    for (; ; ) {
+      const { subaccount_ids } = await this.ctx.send("private/get_subaccounts", { wallet });
+      const credited = subaccount_ids.find((id) => !known.has(id));
+      if (credited !== void 0) return credited;
+      if (Date.now() >= deadline) {
+        throw new DeriveTimeoutError(`deposit not credited within ${timeoutMs}ms \u2014 no new subaccount for ${wallet}`);
+      }
+      await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
+    }
+  }
+};
+var ContractCallDeposits = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  ctx;
+  /**
+   * Approves (if needed) and deposits into an existing subaccount.
+   * `fallbackRecipient` (default: the signer) receives the funds into
+   * its fallback subaccount if the deposit cannot be applied.
+   * Resolves once the transaction is mined — crediting happens
+   * asynchronously once the deposit is observed on-chain.
+   */
+  async deposit(params) {
+    const { actionManager, amountRaw } = await this.approveForDeposit(params);
+    const fallback = getAddress(params.fallbackRecipient ?? await params.signer.getAddress());
+    const tx = await actionManager.getFunction("deposit")(
+      getAddress(params.asset),
+      amountRaw,
+      params.subaccountId,
+      fallback
+    );
+    await tx.wait();
+    return { txHash: tx.hash };
+  }
+  /**
+   * Approves (if needed) and deposits into a NEW subaccount under
+   * `managerId`, owned by `owner` (default: the signer). The exchange
+   * assigns the subaccount id asynchronously — discover it with
+   * `deposits.awaitCredited` against a pre-deposit snapshot of the
+   * owner's ids.
+   */
+  async depositToNewSubaccount(params) {
+    const { actionManager, amountRaw } = await this.approveForDeposit(params);
+    const owner = getAddress(params.owner ?? await params.signer.getAddress());
+    const tx = await actionManager.getFunction("depositToNewSubaccount")(
+      getAddress(params.asset),
+      amountRaw,
+      params.managerId,
+      owner
+    );
+    await tx.wait();
+    return { txHash: tx.hash };
+  }
+  /** Scales the amount, then ensures the ActionManager may pull it from the ERC-20. */
+  async approveForDeposit(params) {
+    const managerAddress = this.ctx.network.contracts.actionManager;
+    if (!managerAddress) {
+      throw new Error(
+        `network '${this.ctx.network.name}' has no actionManager contract configured \u2014 contract-call deposits need a NetworkConfig with contracts.actionManager set`
+      );
+    }
+    const erc20Address = params.erc20 ?? this.ctx.network.contracts.usdc;
+    if (!erc20Address) {
+      throw new Error(`network '${this.ctx.network.name}' has no usdc contract configured \u2014 pass erc20 explicitly`);
+    }
+    const token = new Contract(getAddress(erc20Address), ERC20_ABI, params.signer);
+    const amountRaw = typeof params.amount === "bigint" ? params.amount : toScaled(params.amount, Number(await token.getFunction("decimals")()));
+    if (amountRaw <= 0n) throw new Error("deposit amount must be positive");
+    const holder = await params.signer.getAddress();
+    const allowance = await token.getFunction("allowance")(holder, managerAddress);
+    if (allowance < amountRaw) {
+      this.ctx.logger("debug", `approving ${amountRaw} of ${erc20Address} to ActionManager`);
+      const approval = await token.getFunction("approve")(managerAddress, amountRaw);
+      await approval.wait();
+    }
+    return { actionManager: new Contract(managerAddress, ACTION_MANAGER_ABI, params.signer), amountRaw };
+  }
+};
+var DepositAddressDeposits = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  ctx;
+  /**
+   * Registers (or re-fetches — the address is deterministic per wallet/
+   * subaccount/manager) the deposit address the exchange watches and
+   * sweeps, routing funds to an existing subaccount or, with
+   * `managerId`, a new one. `wallet` defaults to the client's owner.
+   */
+  async register(options = {}) {
+    if (!options.subaccountId && !options.managerId) {
+      throw new Error("provide subaccountId (existing) or managerId (to route deposits into a new subaccount)");
+    }
+    return this.ctx.send("public/register_deposit_address", {
+      wallet: getAddress(options.wallet ?? this.ctx.credentials().ownerAddress),
+      subaccount_id: options.subaccountId,
+      manager_id: options.managerId
+    });
+  }
+};
+
+// src/api/marketData.ts
+var toWireCollateral = (c) => ({ asset_name: c.assetName, amount: c.amount });
+var toWirePosition = (p) => ({
+  instrument_name: p.instrumentName,
+  amount: p.amount,
+  entry_price: p.entryPrice ?? null
+});
+var MarketDataApi = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  ctx;
+  getInstrument(instrumentName) {
+    return this.ctx.send("public/get_instrument", { instrument_name: instrumentName });
+  }
+  /** One page of instruments; the response carries pagination info. */
+  getInstruments(query) {
+    return this.ctx.send("public/get_all_instruments", {
+      instrument_type: query.instrumentType,
+      expired: query.expired ?? false,
+      currency: query.currency ?? null,
+      page: query.page ?? null,
+      page_size: query.pageSize ?? null
+    });
+  }
+  /** Every currently tradeable instrument name across all currencies. */
+  getAllLiveInstruments() {
+    return this.ctx.send("public/get_all_live_instruments", null);
+  }
+  /**
+   * Latest ticker snapshot: top of book (`b`/`a` prices, `B`/`A`
+   * amounts), mark (`M`) and index (`I`) prices, and match bounds.
+   */
+  getTicker(instrumentName) {
+    return this.ctx.send("public/get_ticker", { instrument_name: instrumentName });
+  }
+  /** Ticker snapshots for every instrument of a type, keyed by instrument name. */
+  getTickers(params) {
+    return this.ctx.send("public/get_tickers", {
+      instrument_type: params.instrumentType,
+      currency: params.currency ?? null,
+      expiry_date: params.expiryDate
+    });
+  }
+  getAllCurrencies() {
+    return this.ctx.send("public/get_all_currencies", null);
+  }
+  getCurrency(currency) {
+    return this.ctx.send("public/get_currency", { currency });
+  }
+  /** Latest signed oracle feeds (spot/perp/option/forward), optionally filtered by currency/expiry. */
+  getLatestSignedFeeds(params = {}) {
+    return this.ctx.send("public/get_latest_signed_feeds", {
+      currency: params.currency ?? null,
+      expiry: params.expiry ?? null
+    });
+  }
+  /** Settlement prices per expiry for the currency's options. */
+  getOptionSettlementPrices(currency) {
+    return this.ctx.send("public/get_option_settlement_prices", { currency });
+  }
+  /** On-chain settlement status and hash for a single op by its uuid. */
+  getTransaction(opUuid) {
+    return this.ctx.send("public/get_transaction", { op_uuid: opUuid });
+  }
+  /** Referral fee-share and reward breakdown over a millisecond window. */
+  getReferralPerformance(params) {
+    return this.ctx.send("public/get_referral_performance", {
+      start_ms: params.startMs,
+      end_ms: params.endMs,
+      referral_code: params.referralCode ?? null,
+      wallet: params.wallet ?? null
+    });
+  }
+  /** Spot index OHLC candles for a currency over a UTC-seconds window; `period` is the bucket size in seconds. */
+  getIndexChartData(params) {
+    return this.ctx.send("public/get_index_chart_data", {
+      currency: params.currency,
+      start_timestamp: params.startTimestamp,
+      end_timestamp: params.endTimestamp,
+      period: params.period
+    });
+  }
+  /** Interest-rate candles for a currency's lending pools, optionally scoped to one risk universe. */
+  getInterestRateHistory(params) {
+    return this.ctx.send("public/get_interest_rate_history", {
+      currency: params.currency,
+      start_timestamp: params.startTimestamp ?? null,
+      end_timestamp: params.endTimestamp ?? null,
+      period: params.period ?? null,
+      risk_universe_id: params.riskUniverseId ?? null
+    });
+  }
+  // The methods below pre-date the generated EndpointMap, so their method string and params
+  // are cast through `never`; results are untyped (`unknown`) unless a generated type exists.
+  /** 24h and lifetime volume/fee/trade statistics for an instrument name or type (`ALL`/`OPTION`/`PERP`/`SPOT`). */
+  getStatistics(params) {
+    return this.ctx.send(
+      "public/statistics",
+      {
+        instrument_name: params.instrumentName,
+        currency: params.currency ?? null,
+        end_time: params.endTime ?? null
+      }
+    );
+  }
+  /** All maker programs, including past/historical epochs. */
+  getMakerPrograms() {
+    return this.ctx.send("public/get_maker_programs", {});
+  }
+  /** Per-maker score breakdown for one program epoch. */
+  getMakerProgramScores(params) {
+    return this.ctx.send(
+      "public/get_maker_program_scores",
+      {
+        program_name: params.programName,
+        epoch_start_timestamp: params.epochStartTimestamp
+      }
+    );
+  }
+  /** Paginated liquidation-auction history across all subaccounts (or one, if `subaccountId` is given). */
+  getLiquidationHistory(params = {}) {
+    return this.ctx.send(
+      "public/get_liquidation_history",
+      {
+        subaccount_id: params.subaccountId ?? null,
+        start_timestamp: params.fromTimestamp,
+        end_timestamp: params.toTimestamp,
+        page: params.page,
+        page_size: params.pageSize
+      }
+    );
+  }
+  /** Mark-to-market value and maintenance margin for a subaccount. */
+  marginWatch(params) {
+    return this.ctx.send(
+      "public/margin_watch",
+      {
+        subaccount_id: params.subaccountId,
+        force_onchain: params.forceOnchain,
+        is_delayed_liquidation: params.isDelayedLiquidation
+      }
+    );
+  }
+  /** Margin requirement for a simulated portfolio and optional trade deltas; ignores open-order margin. */
+  simulateMargin(params) {
+    return this.ctx.send(
+      "public/get_margin",
+      {
+        margin_type: params.marginType,
+        market: params.market ?? null,
+        simulated_collaterals: params.simulatedCollaterals.map(toWireCollateral),
+        simulated_positions: params.simulatedPositions.map(toWirePosition),
+        simulated_collateral_changes: params.simulatedCollateralChanges?.map(toWireCollateral) ?? null,
+        simulated_position_changes: params.simulatedPositionChanges?.map(toWirePosition) ?? null
+      }
+    );
+  }
+};
+
+// src/api/orders.ts
+import { formatUnits } from "ethers";
+
+// src/signing/action.ts
+import { AbiCoder as AbiCoder2, concat, getAddress as getAddress3, isHexString, keccak256 as keccak2562 } from "ethers";
+
+// src/signing/eip712.ts
+import { AbiCoder, getAddress as getAddress2, keccak256, toUtf8Bytes } from "ethers";
+var ACTION_TYPEHASH = "0x4d7a9f27c403ff9c0f19bce61d76d82f9aa29f8d6d4b0c5474607d9770d1af17";
+var DOMAIN_TYPEHASH = keccak256(
+  toUtf8Bytes("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)")
+);
+var NAME_HASH = keccak256(toUtf8Bytes("Matching"));
+var VERSION_HASH = keccak256(toUtf8Bytes("1.0"));
+var MATCHING_VERIFYING_CONTRACT = "0xeB8d770ec18DB98Db922E9D83260A585b9F0DeAD";
+function domainSeparator(network) {
+  return keccak256(
+    AbiCoder.defaultAbiCoder().encode(
+      ["bytes32", "bytes32", "bytes32", "uint256", "address"],
+      [DOMAIN_TYPEHASH, NAME_HASH, VERSION_HASH, network.chainId, getAddress2(MATCHING_VERIFYING_CONTRACT)]
+    )
+  );
+}
+
+// src/signing/action.ts
+var SignedAction = class {
+  fields;
+  domainSeparator;
+  signature;
+  constructor(fields, domainSeparator2) {
+    if (!isHexString(fields.data)) throw new Error("action data must be a 0x-prefixed hex string");
+    if (!/^\d+$/.test(fields.nonce)) throw new Error("action nonce must be a decimal string");
+    if (!isHexString(domainSeparator2, 32)) throw new Error("domainSeparator must be 32 bytes of hex");
+    this.fields = Object.freeze({
+      ...fields,
+      module: getAddress3(fields.module),
+      owner: getAddress3(fields.owner),
+      signer: getAddress3(fields.signer)
+    });
+    this.domainSeparator = domainSeparator2;
+  }
+  actionHash() {
+    const f = this.fields;
+    return keccak2562(
+      AbiCoder2.defaultAbiCoder().encode(
+        ["bytes32", "uint256", "uint256", "address", "bytes32", "uint256", "address", "address"],
+        [ACTION_TYPEHASH, f.subaccountId, f.nonce, f.module, keccak2562(f.data), f.expirySec, f.owner, f.signer]
+      )
+    );
+  }
+  digest() {
+    return keccak2562(concat(["0x1901", this.domainSeparator, this.actionHash()]));
+  }
+  /**
+   * Signs the digest with a raw signing key. The wallet must be the
+   * declared `signer` (the owner itself, or a registered session key).
+   */
+  sign(wallet) {
+    if (getAddress3(wallet.address) !== this.fields.signer) {
+      throw new Error(`signing wallet ${wallet.address} does not match declared signer ${this.fields.signer}`);
+    }
+    this.signature = wallet.signingKey.sign(this.digest()).serialized;
+    return this;
+  }
+};
+
+// src/api/orders.ts
+var OrdersApi = class {
+  constructor(ctx, marketData) {
+    this.ctx = ctx;
+    this.marketData = marketData;
+  }
+  ctx;
+  marketData;
+  /** Asset address/subId per instrument name are immutable — cache the lookups. */
+  instruments = /* @__PURE__ */ new Map();
+  /**
+   * Builds the signed wire payload shared by `place` and `quote`. The trade
+   * action commits only to asset/price/amount/fee/recipient — trigger,
+   * referral, algo and the other flags below are wire-only and never signed.
+   */
+  async buildOrderPayload(params) {
+    const amount = toE18(params.amount);
+    if (amount <= 0n) throw new Error("order amount must be positive");
+    const limitPrice = toE18(params.limitPrice);
+    const maxFee = toE18(params.maxFee ?? await this.defaultMaxFee(params.instrumentName, params.limitPrice));
+    if (maxFee < 0n) throw new Error("maxFee must not be negative");
+    const instrument = await this.instrument(params.instrumentName);
+    const nonce = params.nonce ?? randomNonce();
+    const expirySec = params.signatureExpirySec ?? expiresIn(DEFAULT_SIGNATURE_EXPIRY_SEC);
+    const { ownerAddress, signer } = this.ctx.credentials();
+    const action = new SignedAction(
+      {
+        subaccountId: params.subaccountId,
+        nonce,
+        module: this.ctx.network.modules.trade,
+        data: encodeTradeData({
+          assetAddress: instrument.base_asset_address,
+          subId: instrument.base_asset_sub_id,
+          limitPrice,
+          amount,
+          maxFee,
+          recipientSubaccountId: params.subaccountId,
+          isBid: params.direction === "buy"
+        }),
+        expirySec,
+        owner: ownerAddress,
+        signer: signer.address
+      },
+      domainSeparator(this.ctx.network)
+    ).sign(signer);
+    return {
+      subaccount_id: params.subaccountId,
+      instrument_name: params.instrumentName,
+      direction: params.direction,
+      // Wire decimals are formatted from the signed e18 words so the exchange re-derives the exact signed bytes.
+      limit_price: formatUnits(limitPrice, 18),
+      amount: formatUnits(amount, 18),
+      max_fee: formatUnits(maxFee, 18),
+      nonce,
+      signer: signer.address,
+      signature: action.signature,
+      signature_expiry_sec: expirySec,
+      order_type: params.orderType ?? "limit",
+      time_in_force: params.timeInForce,
+      label: params.label,
+      mmp: params.mmp,
+      reduce_only: params.reduceOnly,
+      trigger_type: params.triggerType,
+      trigger_price: params.triggerPrice === void 0 ? void 0 : formatUnits(toE18(params.triggerPrice), 18),
+      trigger_price_type: params.triggerPriceType,
+      referral_code: params.referralCode,
+      reject_post_only: params.rejectPostOnly,
+      is_atomic_signing: params.isAtomicSigning,
+      client: params.clientOrderId,
+      extra_fee: params.extraFee === void 0 ? void 0 : formatUnits(toE18(params.extraFee), 18),
+      reject_timestamp: params.rejectTimestamp,
+      algo_type: params.algoType,
+      algo_duration_sec: params.algoDurationSec,
+      algo_num_slices: params.algoNumSlices
+    };
+  }
+  async place(params) {
+    return this.ctx.send("private/order", await this.buildOrderPayload(params));
+  }
+  /**
+   * Prices an order without placing it. Signs like `place` (pass
+   * `{ public: true }` to hit the unauthenticated public estimate instead).
+   */
+  async getOrderQuote(params, options = {}) {
+    const payload = await this.buildOrderPayload(params);
+    return this.ctx.send(options.public ? "public/order_quote" : "private/order_quote", payload);
+  }
+  /** Cancels one order. Needs only authentication, not a signature. */
+  cancel(params) {
+    return this.ctx.send("private/cancel", {
+      subaccount_id: params.subaccountId,
+      order_id: params.orderId,
+      instrument_name: params.instrumentName
+    });
+  }
+  cancelAll(subaccountId, options) {
+    return this.ctx.send("private/cancel_all", {
+      subaccount_id: subaccountId,
+      cancel_trigger_orders: options?.cancelTriggerOrders ?? null,
+      cancel_algo_orders: options?.cancelAlgoOrders ?? null
+    });
+  }
+  cancelByLabel(params) {
+    return this.ctx.send("private/cancel_by_label", {
+      subaccount_id: params.subaccountId,
+      label: params.label,
+      instrument_name: params.instrumentName ?? null
+    });
+  }
+  getOrder(params) {
+    return this.ctx.send("private/get_order", {
+      subaccount_id: params.subaccountId,
+      order_id: params.orderId
+    });
+  }
+  async getOpenOrders(subaccountId) {
+    const result = await this.ctx.send("private/get_open_orders", { subaccount_id: subaccountId });
+    return result.orders;
+  }
+  /** Paginated closed/open order history; defaults to all of the wallet's subaccounts. */
+  getOrderHistory(query = {}) {
+    return this.ctx.send("private/get_order_history", {
+      subaccount_id: query.subaccountId ?? null,
+      from_timestamp: query.fromTimestamp ?? null,
+      to_timestamp: query.toTimestamp ?? null,
+      page: query.page ?? null,
+      page_size: query.pageSize ?? null
+    });
+  }
+  /** Sets the market-maker-protection limits for a currency; overwrites any existing config. */
+  setMmpConfig(params) {
+    return this.ctx.send("private/set_mmp_config", {
+      subaccount_id: params.subaccountId,
+      currency: params.currency,
+      mmp_frozen_time: params.mmpFrozenTime,
+      mmp_interval: params.mmpInterval,
+      mmp_amount_limit: params.mmpAmountLimit === void 0 ? void 0 : String(params.mmpAmountLimit),
+      mmp_delta_limit: params.mmpDeltaLimit === void 0 ? void 0 : String(params.mmpDeltaLimit)
+    });
+  }
+  /** Clears a tripped market-maker-protection freeze; scoped to one currency, or all when omitted. */
+  resetMmp(params) {
+    return this.ctx.send("private/reset_mmp", {
+      subaccount_id: params.subaccountId,
+      currency: params.currency ?? null
+    });
+  }
+  instrument(name) {
+    let lookup = this.instruments.get(name);
+    if (!lookup) {
+      lookup = this.marketData.getInstrument(name);
+      lookup.catch(() => this.instruments.delete(name));
+      this.instruments.set(name, lookup);
+    }
+    return lookup;
+  }
+  /**
+   * The signed max fee must cover whatever the exchange charges at match
+   * time or the order is rejected. The exchange bounds the per-unit fee at
+   * `2 x taker_fee_rate x max(index, limit) + base_fee`, where `index` is
+   * the underlying SPOT feed (`ticker.I`) — NOT the option mark
+   * (`ticker.M`). We mirror that and apply a 3x headroom for feed moves
+   * between signing and matching.
+   */
+  async defaultMaxFee(instrumentName, limitPrice) {
+    const [instrument, ticker] = await Promise.all([
+      this.instrument(instrumentName),
+      this.marketData.getTicker(instrumentName)
+    ]);
+    const feeBasis = Math.max(Number(ticker.I), Number(limitPrice));
+    const perUnitTakerCost = feeBasis * Number(instrument.taker_fee_rate) + Number(instrument.base_fee);
+    if (!Number.isFinite(perUnitTakerCost) || perUnitTakerCost < 0) {
+      throw new Error(`cannot derive a default max fee for ${instrumentName} \u2014 pass maxFee explicitly`);
+    }
+    return (perUnitTakerCost * 3).toFixed(6);
+  }
+};
+
+// src/api/positionTransfers.ts
+import { formatUnits as formatUnits2 } from "ethers";
+var PositionTransfersApi = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  ctx;
+  instruments = /* @__PURE__ */ new Map();
+  async transferPositions(params) {
+    if (params.makerSubaccountId === params.takerSubaccountId) {
+      throw new Error("makerSubaccountId and takerSubaccountId must be different");
+    }
+    if (params.legs.length === 0) {
+      throw new Error("transferPositions needs at least one leg");
+    }
+    const makerNonce = params.makerNonce ?? randomNonce();
+    const takerNonce = params.takerNonce ?? randomNonce();
+    if (makerNonce === takerNonce) {
+      throw new Error("makerNonce and takerNonce must be different");
+    }
+    const expirySec = params.signatureExpirySec ?? expiresIn(700);
+    const takerDirection = params.makerDirection === "buy" ? "sell" : "buy";
+    const legs = await this.resolveLegs(params.legs);
+    const maker = this.signAction(
+      params.makerSubaccountId,
+      makerNonce,
+      expirySec,
+      encodeRfqQuote({ maxFee: 0n, direction: params.makerDirection, legs })
+    );
+    const taker = this.signAction(
+      params.takerSubaccountId,
+      takerNonce,
+      expirySec,
+      encodeRfqExecute({ maxFee: 0n, direction: takerDirection, legs })
+    );
+    const wireLegs = legs.map(wireLeg);
+    return this.ctx.send("private/transfer_positions", {
+      wallet: this.ctx.credentials().ownerAddress,
+      maker_params: {
+        subaccount_id: params.makerSubaccountId,
+        direction: params.makerDirection,
+        legs: wireLegs,
+        max_fee: formatUnits2(0n, 18),
+        nonce: makerNonce,
+        signer: maker.signer,
+        signature: maker.signature,
+        signature_expiry_sec: expirySec
+      },
+      taker_params: {
+        subaccount_id: params.takerSubaccountId,
+        direction: takerDirection,
+        legs: wireLegs,
+        max_fee: formatUnits2(0n, 18),
+        nonce: takerNonce,
+        signer: taker.signer,
+        signature: taker.signature,
+        signature_expiry_sec: expirySec
+      }
+    });
+  }
+  async resolveLegs(legs) {
+    return sortRfqLegs(
+      await Promise.all(
+        legs.map(async (leg) => {
+          const instrument = await this.instrument(leg.instrumentName);
+          return {
+            instrumentName: leg.instrumentName,
+            assetAddress: instrument.base_asset_address,
+            subId: instrument.base_asset_sub_id,
+            price: toE18(leg.price),
+            amount: toE18(leg.amount),
+            direction: leg.direction
+          };
+        })
+      )
+    );
+  }
+  instrument(name) {
+    let lookup = this.instruments.get(name);
+    if (!lookup) {
+      lookup = this.ctx.send("public/get_instrument", { instrument_name: name });
+      lookup.catch(() => this.instruments.delete(name));
+      this.instruments.set(name, lookup);
+    }
+    return lookup;
+  }
+  signAction(subaccountId, nonce, expirySec, data) {
+    const { ownerAddress, signer } = this.ctx.credentials();
+    const action = new SignedAction(
+      {
+        subaccountId,
+        nonce,
+        module: this.ctx.network.modules.rfq,
+        data,
+        expirySec,
+        owner: ownerAddress,
+        signer: signer.address
+      },
+      domainSeparator(this.ctx.network)
+    ).sign(signer);
+    return { signer: action.fields.signer, signature: action.signature };
+  }
+};
+function wireLeg(leg) {
+  return {
+    amount: formatUnits2(leg.amount, 18),
+    direction: leg.direction,
+    instrument_name: leg.instrumentName,
+    price: formatUnits2(leg.price, 18)
+  };
+}
+
+// src/api/rfq.ts
+import { formatUnits as formatUnits3, getAddress as getAddress4 } from "ethers";
+var DEFAULT_QUOTE_EXPIRY_SEC = 700;
+var RfqApi = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  ctx;
+  /** Asset address/subId per instrument name are immutable — cache the lookups. */
+  instruments = /* @__PURE__ */ new Map();
+  // ── Taker ──────────────────────────────────────────────────────────
+  /** Requests quotes for a package of legs. Unsigned — only the eventual execute is. */
+  async sendRfq(params) {
+    return this.ctx.send("private/send_rfq", {
+      subaccount_id: params.subaccountId,
+      legs: unpricedWireLegs(params.legs),
+      label: params.label,
+      max_total_cost: params.maxTotalCost === void 0 ? void 0 : wireDecimal(params.maxTotalCost),
+      min_total_cost: params.minTotalCost === void 0 ? void 0 : wireDecimal(params.minTotalCost),
+      counterparties: params.counterparties?.map((wallet) => getAddress4(wallet)),
+      partial_fill_step: params.partialFillStep === void 0 ? void 0 : wireDecimal(params.partialFillStep)
+    });
+  }
+  /** Polls quotes received for the taker's RFQs (e.g. `status: 'open'`). */
+  async pollQuotes(params) {
+    return this.ctx.send("private/poll_quotes", {
+      subaccount_id: params.subaccountId,
+      rfq_id: params.rfqId,
+      quote_id: params.quoteId,
+      status: params.status,
+      from_timestamp: params.fromTimestamp,
+      to_timestamp: params.toTimestamp,
+      page: params.page,
+      page_size: params.pageSize
+    });
+  }
+  /** The exchange's pick of the best open quote for an RFQ, with margin/cost estimates. */
+  async getBestQuote(params) {
+    return this.ctx.send("private/rfq_get_best_quote", {
+      subaccount_id: params.subaccountId,
+      rfq_id: params.rfqId,
+      direction: params.direction,
+      legs: unpricedWireLegs(params.legs)
+    });
+  }
+  /**
+   * Executes a maker quote (from `pollQuotes` / `getBestQuote`). The taker
+   * trades opposite the quote's direction and signs a commitment to the
+   * maker's exact leg bundle, so legs and prices come from the quote itself.
+   */
+  async executeQuote(params) {
+    return this.ctx.send("private/execute_quote", await this.buildExecutePayload(params));
+  }
+  /**
+   * Debug helper: signs the execute exactly like `executeQuote` but submits it
+   * to `public/execute_quote_debug`, returning the server-computed encoded data
+   * and hashes instead of filling. Use it to verify your client-side signing.
+   */
+  async executeQuoteDebug(params) {
+    return this.ctx.send("public/execute_quote_debug", await this.buildExecutePayload(params));
+  }
+  async buildExecutePayload(params) {
+    const direction = params.quote.direction === "buy" ? "sell" : "buy";
+    const maxFee = toE18(params.maxFee);
+    const legs = await this.resolveLegs(
+      params.quote.legs.map((leg) => ({
+        instrumentName: leg.instrument_name,
+        amount: leg.amount,
+        price: leg.price,
+        direction: leg.direction
+      }))
+    );
+    const nonce = params.nonce ?? randomNonce();
+    const expirySec = params.signatureExpirySec ?? expiresIn(DEFAULT_QUOTE_EXPIRY_SEC);
+    const signed = this.signRfqAction(
+      params.subaccountId,
+      encodeRfqExecute({ maxFee, direction, legs }),
+      nonce,
+      expirySec
+    );
+    return {
+      subaccount_id: params.subaccountId,
+      rfq_id: params.quote.rfq_id,
+      quote_id: params.quote.quote_id,
+      direction,
+      legs: legs.map(pricedWireLeg),
+      max_fee: formatUnits3(maxFee, 18),
+      nonce,
+      signer: signed.signer,
+      signature: signed.signature,
+      signature_expiry_sec: expirySec,
+      enable_taker_protection: params.enableTakerProtection,
+      label: params.label
+    };
+  }
+  async cancelRfq(params) {
+    return this.ctx.send("private/cancel_rfq", {
+      subaccount_id: params.subaccountId,
+      rfq_id: params.rfqId
+    });
+  }
+  // ── Maker ──────────────────────────────────────────────────────────
+  /** Polls RFQs open for quoting (e.g. `status: 'open'`). */
+  async pollRfqs(params) {
+    return this.ctx.send("private/poll_rfqs", {
+      subaccount_id: params.subaccountId,
+      rfq_id: params.rfqId,
+      status: params.status,
+      from_timestamp: params.fromTimestamp,
+      to_timestamp: params.toTimestamp,
+      page: params.page,
+      page_size: params.pageSize
+    });
+  }
+  /**
+   * Signs and sends a quote against an open RFQ. Legs must match the RFQ's
+   * legs with prices added; `direction: 'sell'` quotes the package to a
+   * buying taker.
+   */
+  async sendQuote(params) {
+    return this.ctx.send("private/send_quote", await this.buildSendQuotePayload(params));
+  }
+  /**
+   * Debug helper: signs the quote exactly like `sendQuote` but submits it to
+   * `public/send_quote_debug`, returning the server-computed encoded data and
+   * hashes instead of posting. Use it to verify your client-side signing.
+   */
+  async sendQuoteDebug(params) {
+    return this.ctx.send("public/send_quote_debug", await this.buildSendQuotePayload(params));
+  }
+  async buildSendQuotePayload(params) {
+    const maxFee = toE18(params.maxFee);
+    const legs = await this.resolveLegs(params.legs);
+    const nonce = params.nonce ?? randomNonce();
+    const expirySec = params.signatureExpirySec ?? expiresIn(DEFAULT_QUOTE_EXPIRY_SEC);
+    const signed = this.signRfqAction(
+      params.subaccountId,
+      encodeRfqQuote({ maxFee, direction: params.direction, legs }),
+      nonce,
+      expirySec
+    );
+    return {
+      subaccount_id: params.subaccountId,
+      rfq_id: params.rfqId,
+      direction: params.direction,
+      legs: legs.map(pricedWireLeg),
+      max_fee: formatUnits3(maxFee, 18),
+      // The generated stub types nonce as number; the wire value is the decimal-string nanosecond nonce (> 2^53).
+      nonce,
+      signer: signed.signer,
+      signature: signed.signature,
+      signature_expiry_sec: expirySec,
+      mmp: params.mmp,
+      label: params.label
+    };
+  }
+  async cancelQuote(params) {
+    return this.ctx.send("private/cancel_quote", {
+      subaccount_id: params.subaccountId,
+      quote_id: params.quoteId,
+      rfq_id: params.rfqId
+    });
+  }
+  /** Cancels all the subaccount's open quotes, optionally scoped to one RFQ. */
+  async cancelBatchQuotes(params) {
+    return this.ctx.send("private/cancel_batch_quotes", {
+      subaccount_id: params.subaccountId,
+      rfq_id: params.rfqId
+    });
+  }
+  /** Cancels all the subaccount's open RFQs, optionally scoped to one RFQ id. */
+  async cancelBatchRfqs(params) {
+    return this.ctx.send("private/cancel_batch_rfqs", {
+      subaccount_id: params.subaccountId,
+      rfq_id: params.rfqId
+    });
+  }
+  /** Paginated quote history/read for the subaccount, filterable by rfq/quote/status. */
+  async getQuotes(params) {
+    return this.ctx.send("private/get_quotes", {
+      subaccount_id: params.subaccountId,
+      rfq_id: params.rfqId,
+      quote_id: params.quoteId,
+      status: params.status,
+      page: params.page,
+      page_size: params.pageSize,
+      from_timestamp: params.fromTimestamp,
+      to_timestamp: params.toTimestamp
+    });
+  }
+  /**
+   * Atomically cancels an existing quote and signs+sends a replacement on the
+   * same RFQ. Legs/price/maxFee sign the new quote exactly like `sendQuote`;
+   * identify the quote to cancel by `quoteIdToCancel` or `nonceToCancel`.
+   */
+  async replaceQuote(params) {
+    const maxFee = toE18(params.maxFee);
+    const legs = await this.resolveLegs(params.legs);
+    const nonce = params.nonce ?? randomNonce();
+    const expirySec = params.signatureExpirySec ?? expiresIn(DEFAULT_QUOTE_EXPIRY_SEC);
+    const signed = this.signRfqAction(
+      params.subaccountId,
+      encodeRfqQuote({ maxFee, direction: params.direction, legs }),
+      nonce,
+      expirySec
+    );
+    return this.ctx.send("private/replace_quote", {
+      subaccount_id: params.subaccountId,
+      rfq_id: params.rfqId,
+      direction: params.direction,
+      legs: legs.map(pricedWireLeg),
+      max_fee: formatUnits3(maxFee, 18),
+      nonce,
+      signer: signed.signer,
+      signature: signed.signature,
+      signature_expiry_sec: expirySec,
+      quote_id_to_cancel: params.quoteIdToCancel,
+      nonce_to_cancel: params.nonceToCancel,
+      mmp: params.mmp,
+      label: params.label
+    });
+  }
+  // ── Shared signing plumbing ────────────────────────────────────────
+  /** Attaches each leg's protocol asset address + sub id and sorts into the canonical signed order. */
+  async resolveLegs(legs) {
+    return sortRfqLegs(
+      await Promise.all(
+        legs.map(async (leg) => {
+          const instrument = await this.instrument(leg.instrumentName);
+          return {
+            instrumentName: leg.instrumentName,
+            assetAddress: instrument.base_asset_address,
+            subId: instrument.base_asset_sub_id,
+            price: toE18(leg.price),
+            amount: toE18(leg.amount),
+            direction: leg.direction
+          };
+        })
+      )
+    );
+  }
+  instrument(name) {
+    let lookup = this.instruments.get(name);
+    if (!lookup) {
+      lookup = this.ctx.send("public/get_instrument", { instrument_name: name });
+      lookup.catch(() => this.instruments.delete(name));
+      this.instruments.set(name, lookup);
+    }
+    return lookup;
+  }
+  signRfqAction(subaccountId, data, nonce, expirySec) {
+    const { ownerAddress, signer } = this.ctx.credentials();
+    const action = new SignedAction(
+      {
+        subaccountId,
+        nonce,
+        module: this.ctx.network.modules.rfq,
+        data,
+        expirySec,
+        owner: ownerAddress,
+        signer: signer.address
+      },
+      domainSeparator(this.ctx.network)
+    ).sign(signer);
+    return { signer: signer.address, signature: action.signature };
+  }
+};
+function wireDecimal(value) {
+  return formatUnits3(toE18(value), 18);
+}
+function unpricedWireLegs(legs) {
+  return sortRfqLegs(legs).map((leg) => {
+    const amount = toE18(leg.amount);
+    if (amount <= 0n) {
+      throw new Error(`rfq leg amount must be positive (direction carries the sign): ${leg.instrumentName}`);
+    }
+    return { amount: formatUnits3(amount, 18), direction: leg.direction, instrument_name: leg.instrumentName };
+  });
+}
+function pricedWireLeg(leg) {
+  return {
+    amount: formatUnits3(leg.amount, 18),
+    direction: leg.direction,
+    instrument_name: leg.instrumentName,
+    price: formatUnits3(leg.price, 18)
+  };
+}
+
+// src/api/sessionKeys.ts
+import { getAddress as getAddress5 } from "ethers";
+
+// src/auth/scopes.ts
+var ProtocolScopeCode = {
+  /** Superuser grant — allows every protocol action. Grant deliberately. */
+  Admin: 0,
+  /** Withdrawals, restricted to the account's whitelisted recipients. */
+  Withdraw: 1,
+  TradeAll: 2,
+  TradeOrderbookAll: 3,
+  TradeOrderbookSpot: 4,
+  TradeOrderbookPerp: 5,
+  TradeOrderbookOption: 6,
+  TradeRfqAll: 7,
+  TradeRfqSpot: 8,
+  TradeRfqPerp: 9,
+  TradeRfqOption: 10,
+  TransferAll: 11,
+  /** Between subaccounts of the same owner (spot, and positions via RFQ). */
+  TransferExistingSubaccount: 12,
+  /** Spot transfer that creates a new subaccount under the owner. */
+  TransferNewSubaccount: 13,
+  /** Spot transfer to a whitelisted different-owner wallet. */
+  TransferDifferentOwnerSubaccount: 14,
+  /** Create child session keys; the child must be a subset of this key. */
+  CreateSessionKey: 15,
+  Liquidate: 16,
+  VaultAll: 17,
+  VaultCuratorCreate: 18,
+  VaultCuratorMintAndBurn: 19,
+  VaultUserDeposit: 20,
+  VaultUserWithdraw: 21,
+  VaultUserCancel: 22
+};
+var ProtocolScopeWireString = {
+  [ProtocolScopeCode.Admin]: "admin",
+  [ProtocolScopeCode.Withdraw]: "withdraw",
+  [ProtocolScopeCode.TradeAll]: "trade:all",
+  [ProtocolScopeCode.TradeOrderbookAll]: "trade:orderbook:all",
+  [ProtocolScopeCode.TradeOrderbookSpot]: "trade:orderbook:spot",
+  [ProtocolScopeCode.TradeOrderbookPerp]: "trade:orderbook:perp",
+  [ProtocolScopeCode.TradeOrderbookOption]: "trade:orderbook:option",
+  [ProtocolScopeCode.TradeRfqAll]: "trade:rfq:all",
+  [ProtocolScopeCode.TradeRfqSpot]: "trade:rfq:spot",
+  [ProtocolScopeCode.TradeRfqPerp]: "trade:rfq:perp",
+  [ProtocolScopeCode.TradeRfqOption]: "trade:rfq:option",
+  [ProtocolScopeCode.TransferAll]: "transfer:all",
+  [ProtocolScopeCode.TransferExistingSubaccount]: "transfer:existing_subaccount",
+  [ProtocolScopeCode.TransferNewSubaccount]: "transfer:new_subaccount",
+  [ProtocolScopeCode.TransferDifferentOwnerSubaccount]: "transfer:different_owner_subaccount",
+  [ProtocolScopeCode.CreateSessionKey]: "create_session_key",
+  [ProtocolScopeCode.Liquidate]: "liquidate",
+  [ProtocolScopeCode.VaultAll]: "vault:all",
+  [ProtocolScopeCode.VaultCuratorCreate]: "vault:curator_create",
+  [ProtocolScopeCode.VaultCuratorMintAndBurn]: "vault:curator_mint_and_burn",
+  [ProtocolScopeCode.VaultUserDeposit]: "vault:user_deposit",
+  [ProtocolScopeCode.VaultUserWithdraw]: "vault:user_withdraw",
+  [ProtocolScopeCode.VaultUserCancel]: "vault:user_cancel"
+};
+var OffchainScope = {
+  AccountInfo: "account_info",
+  DeleteSessionKey: "delete_session_key"
+};
+
+// src/api/sessionKeys.ts
+var SessionKeysApi = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  ctx;
+  /**
+   * Registers a scoped session key. The action must be authorized by the
+   * account owner or by a registered session key holding the
+   * `create_session_key` scope — a child key must then be a subset of its
+   * creator (scopes, subaccounts, and expiry no later than the creator's).
+   * Signs with the client's action signer, so a client configured with an
+   * unscoped session key will be rejected server-side.
+   */
+  async create(params) {
+    const publicSessionKey = getAddress5(
+      typeof params.publicSessionKey === "string" ? params.publicSessionKey : params.publicSessionKey.address
+    );
+    const scopes = params.protocolScopes ?? [];
+    const offchainScopes = params.offchainScopes ?? [OffchainScope.AccountInfo];
+    const { ownerAddress, signer } = this.ctx.credentials();
+    const action = new SignedAction(
+      {
+        subaccountId: 0,
+        nonce: params.nonce ?? randomNonce(),
+        module: this.ctx.network.modules.createSessionKey,
+        data: encodeCreateSessionKeyActionData({
+          sessionKey: publicSessionKey,
+          expirySec: params.expirySec,
+          scopes,
+          subaccountIds: params.subaccountIds ?? []
+        }),
+        expirySec: params.signatureExpirySec ?? expiresIn(600),
+        owner: ownerAddress,
+        signer: signer.address
+      },
+      domainSeparator(this.ctx.network)
+    ).sign(signer);
+    return this.ctx.send("private/create_session_key", {
+      wallet: ownerAddress,
+      public_session_key: publicSessionKey,
+      expiry_sec: params.expirySec,
+      subaccount_ids: params.subaccountIds ?? null,
+      nonce: action.fields.nonce,
+      signer: action.fields.signer,
+      // sign() above guarantees the signature is set
+      signature: action.signature,
+      signature_expiry_sec: action.fields.expirySec,
+      protocol_scopes: scopes.map((code) => ProtocolScopeWireString[code]),
+      offchain_scopes: offchainScopes,
+      label: params.label,
+      ip_whitelist: params.ipWhitelist
+    });
+  }
+  /** All registered session keys of the owner wallet. */
+  async list() {
+    const result = await this.ctx.send("private/session_keys", {
+      wallet: this.ctx.credentials().ownerAddress
+    });
+    return result.public_session_keys;
+  }
+  /**
+   * Patches a key's OFF-CHAIN attributes. Protocol scopes, subaccounts,
+   * and expiry are committed in the signed registration and cannot be
+   * edited — register a replacement key instead. The public API has no
+   * revoke endpoint: a key stops working at its signed `expiry_sec`.
+   */
+  async edit(params) {
+    return this.ctx.send("private/edit_session_key", {
+      wallet: this.ctx.credentials().ownerAddress,
+      public_session_key: getAddress5(params.publicSessionKey),
+      label: params.label,
+      ip_whitelist: params.ipWhitelist,
+      offchain_scopes: params.offchainScopes
+    });
+  }
+};
+
+// src/api/spotTransfers.ts
+import { formatUnits as formatUnits4, getAddress as getAddress6 } from "ethers";
+async function resolveSpotAsset(ctx, asset) {
+  const wanted = asset.trim();
+  const wantedAddress = wanted.startsWith("0x") ? getAddress6(wanted) : void 0;
+  const currencies = await ctx.send("public/get_all_currencies", null);
+  for (const currency of currencies) {
+    const enabled = currency.spot.filter((s) => s.erc20.underlying_erc20 != null || s.erc20.decimals > 0);
+    let match;
+    if (wantedAddress) {
+      match = enabled.find((s) => getAddress6(s.address) === wantedAddress);
+    } else if (currency.currency.toUpperCase() === wanted.toUpperCase()) {
+      if (enabled.length > 1) {
+        throw new Error(
+          `currency ${currency.currency} has multiple deposit-enabled spot assets \u2014 pass the protocol asset address`
+        );
+      }
+      match = enabled[0];
+      if (!match) throw new Error(`currency ${currency.currency} has no deposit-enabled spot asset`);
+    }
+    if (match) {
+      return { name: currency.currency, address: getAddress6(match.address), decimals: match.erc20.decimals };
+    }
+  }
+  throw new Error(
+    `unknown asset ${asset} \u2014 expected a currency name (e.g. "USDC") or the address of a deposit-enabled spot asset`
+  );
+}
+function decimalString(value, scale = 18) {
+  return typeof value === "bigint" ? formatUnits4(value, scale) : String(value).trim();
+}
+var SpotTransfersApi = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  ctx;
+  /**
+   * Moves a spot balance between the owner's OWN subaccounts
+   * (`private/transfer_spot`). Destination is either an existing
+   * `toSubaccountId` or, when `newSubaccountManager` is set, a freshly
+   * created sender-owned subaccount under that manager. For a transfer
+   * to another wallet use `transferExternal`.
+   */
+  async transferInternal(params) {
+    const toSubaccountId = params.toSubaccountId ?? 0;
+    const newSubaccountManager = params.newSubaccountManager ?? 0;
+    if (toSubaccountId === 0 && newSubaccountManager === 0) {
+      throw new Error("specify toSubaccountId or, to create a new subaccount, newSubaccountManager");
+    }
+    const subId = params.subId ?? 0;
+    const maxFeeUsd = params.maxFeeUsd ?? "0";
+    if (newSubaccountManager !== 0 && toE18(maxFeeUsd) === 0n) {
+      throw new Error(
+        "creating a subaccount charges a transfer fee \u2014 set maxFeeUsd (>= 1) when newSubaccountManager is used"
+      );
+    }
+    const asset = await resolveSpotAsset(this.ctx, params.asset);
+    const action = this.signAction(
+      params.subaccountId,
+      this.ctx.network.modules.transfer,
+      encodeTransfer({
+        toSubaccountId,
+        newSubaccountManager,
+        asset: asset.address,
+        subId,
+        amount: params.amount,
+        maxFeeUsd
+      }),
+      params
+    );
+    return this.ctx.send("private/transfer_spot", {
+      subaccount_id: params.subaccountId,
+      to_subaccount_id: toSubaccountId,
+      new_subaccount_manager: newSubaccountManager,
+      asset_name: asset.name,
+      sub_id: subId,
+      amount: decimalString(params.amount),
+      max_fee_usd: decimalString(maxFeeUsd),
+      // Nonces are UTC-nanosecond decimal strings beyond 2^53; the API accepts string-or-number despite the generated `number`.
+      nonce: action.fields.nonce,
+      signer: action.fields.signer,
+      signature: action.signature,
+      signature_expiry_sec: action.fields.expirySec
+    });
+  }
+  /**
+   * Adds/removes recipient wallets on the owner's external-transfer
+   * whitelist (`private/update_whitelisted_recipients`). The resulting
+   * list is `(current ∪ add) \ remove`. Required before `transferExternal`
+   * can send to a given wallet.
+   */
+  async updateWhitelistedRecipients(params) {
+    const add = params.add ?? [];
+    const remove = params.remove ?? [];
+    if (add.length === 0 && remove.length === 0) {
+      throw new Error("updateWhitelistedRecipients needs at least one address to add or remove");
+    }
+    const { ownerAddress } = this.ctx.credentials();
+    const action = this.signAction(
+      0,
+      this.ctx.network.modules.whitelistedRecipient,
+      encodeUpdateWhitelistedRecipients({ add, remove }),
+      params
+    );
+    return this.ctx.send("private/update_whitelisted_recipients", {
+      wallet: ownerAddress,
+      add: add.map((a) => getAddress6(a)),
+      remove: remove.map((a) => getAddress6(a)),
+      // Nonces are UTC-nanosecond decimal strings beyond 2^53; the API accepts string-or-number despite the generated `number`.
+      nonce: action.fields.nonce,
+      signer: action.fields.signer,
+      signature: action.signature,
+      signature_expiry_sec: action.fields.expirySec
+    });
+  }
+  /**
+   * Moves a spot balance to another owner's wallet
+   * (`private/transfer_spot_external`). The recipient must already be on
+   * the sender's whitelist — call `updateWhitelistedRecipients` first;
+   * otherwise the exchange rejects with RPC error 11033 "Transfer
+   * recipient not whitelisted".
+   */
+  async transferExternal(params) {
+    const recipient = getAddress6(params.recipient);
+    const toSubaccountId = params.toSubaccountId ?? 0;
+    const newSubaccountManager = params.newSubaccountManager ?? 0;
+    if (toSubaccountId === 0 && newSubaccountManager === 0) {
+      throw new Error("specify the recipient's toSubaccountId or, to create one for them, newSubaccountManager");
+    }
+    const subId = params.subId ?? 0;
+    const asset = await resolveSpotAsset(this.ctx, params.asset);
+    const action = this.signAction(
+      params.subaccountId,
+      this.ctx.network.modules.externalTransfer,
+      encodeExternalTransfer({
+        toSubaccountId,
+        newSubaccountManager,
+        asset: asset.address,
+        subId,
+        amount: params.amount,
+        maxFeeUsd: params.maxFeeUsd,
+        recipient
+      }),
+      params
+    );
+    return this.ctx.send("private/transfer_spot_external", {
+      subaccount_id: params.subaccountId,
+      recipient_address: recipient,
+      to_subaccount_id: toSubaccountId,
+      new_subaccount_manager: newSubaccountManager,
+      asset_name: asset.name,
+      sub_id: subId,
+      amount: decimalString(params.amount),
+      max_fee_usd: decimalString(params.maxFeeUsd),
+      // Nonces are UTC-nanosecond decimal strings beyond 2^53; the API accepts string-or-number despite the generated `number`.
+      nonce: action.fields.nonce,
+      signer: action.fields.signer,
+      signature: action.signature,
+      signature_expiry_sec: action.fields.expirySec
+    });
+  }
+  signAction(subaccountId, module, data, overrides) {
+    const { ownerAddress, signer } = this.ctx.credentials();
+    return new SignedAction(
+      {
+        subaccountId,
+        nonce: overrides.nonce ?? randomNonce(),
+        module,
+        data,
+        expirySec: overrides.signatureExpirySec ?? expiresIn(DEFAULT_SIGNATURE_EXPIRY_SEC),
+        owner: ownerAddress,
+        signer: signer.address
+      },
+      domainSeparator(this.ctx.network)
+    ).sign(signer);
+  }
+};
+
+// src/api/subaccounts.ts
+var SubaccountsApi = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  ctx;
+  /** Ids of all subaccounts owned by the authenticated wallet. */
+  async list() {
+    const result = await this.ctx.send("private/get_subaccounts", {
+      wallet: this.ctx.credentials().ownerAddress
+    });
+    return result.subaccount_ids;
+  }
+  /**
+   * Full portfolio snapshot: collaterals, positions, open orders, and
+   * the margin figures (there is no separate margin endpoint).
+   */
+  get(subaccountId) {
+    return this.ctx.send("private/get_subaccount", { subaccount_id: subaccountId });
+  }
+  /** Account-level info for the authenticated wallet: fee tiers, subaccount ids, and rate limits. */
+  getAccount() {
+    return this.ctx.send("private/get_account", {
+      wallet: this.ctx.credentials().ownerAddress
+    });
+  }
+  /** Full portfolio snapshot for every subaccount owned by the authenticated wallet. */
+  getAllPortfolios() {
+    return this.ctx.send("private/get_all_portfolios", {
+      wallet: this.ctx.credentials().ownerAddress
+    });
+  }
+  /** Open positions for a subaccount. */
+  getPositions(subaccountId) {
+    return this.ctx.send("private/get_positions", { subaccount_id: subaccountId });
+  }
+  /** Rename a subaccount. */
+  changeLabel(params) {
+    return this.ctx.send("private/change_subaccount_label", {
+      subaccount_id: params.subaccountId,
+      label: params.label
+    });
+  }
+  /** Filtered and paginated fills; defaults to all of the wallet's subaccounts. */
+  getTradeHistory(query = {}) {
+    return this.ctx.send("private/get_trade_history", {
+      subaccount_id: query.subaccountId ?? null,
+      instrument_name: query.instrumentName ?? null,
+      order_id: query.orderId ?? null,
+      quote_id: query.quoteId ?? null,
+      from_timestamp: query.fromTimestamp ?? null,
+      to_timestamp: query.toTimestamp ?? null,
+      page: query.page ?? null,
+      page_size: query.pageSize ?? null
+    });
+  }
+  /** Realized interest settlements, newest first; defaults to the whole wallet. Capped at 1000 rows. */
+  getInterestHistory(query = {}) {
+    return this.ctx.send("private/get_interest_history", {
+      wallet: query.subaccountId == null ? this.ctx.credentials().ownerAddress : void 0,
+      subaccount_id: query.subaccountId ?? void 0,
+      start_timestamp: query.startTimestamp ?? void 0,
+      end_timestamp: query.endTimestamp ?? void 0
+    });
+  }
+  /** Internal ERC-20 transfers touching the wallet's subaccounts; defaults to the whole wallet. Capped at 1000 rows. */
+  getErc20TransferHistory(query = {}) {
+    return this.ctx.send("private/get_erc20_transfer_history", {
+      wallet: query.subaccountId == null ? this.ctx.credentials().ownerAddress : void 0,
+      subaccount_id: query.subaccountId ?? void 0,
+      start_timestamp: query.startTimestamp ?? void 0,
+      end_timestamp: query.endTimestamp ?? void 0
+    });
+  }
+  /** Settled option positions; defaults to the whole wallet, pass `subaccountId` to scope to one. */
+  getOptionSettlementHistory(query = {}) {
+    return this.ctx.send("private/get_option_settlement_history", {
+      wallet: query.subaccountId == null ? this.ctx.credentials().ownerAddress : void 0,
+      subaccount_id: query.subaccountId ?? void 0
+    });
+  }
+  /**
+   * Margin figures for a subaccount, optionally under simulated position/collateral changes.
+   * Predates the schema, so it is absent from the generated EndpointMap and sent untyped.
+   */
+  getMargin(query) {
+    return this.ctx.send(
+      "private/get_margin",
+      {
+        subaccount_id: query.subaccountId,
+        simulated_position_changes: query.simulatedPositionChanges?.map((p) => ({
+          instrument_name: p.instrumentName,
+          amount: p.amount,
+          entry_price: p.entryPrice ?? null
+        })) ?? null,
+        simulated_collateral_changes: query.simulatedCollateralChanges?.map((c) => ({
+          asset_name: c.assetName,
+          amount: c.amount
+        })) ?? null
+      }
+    );
+  }
+  /**
+   * Auctions in which a subaccount (or the whole wallet) was liquidated.
+   * Predates the schema, so it is absent from the generated EndpointMap and sent untyped.
+   */
+  getLiquidationHistory(query = {}) {
+    return this.ctx.send(
+      "private/get_liquidation_history",
+      {
+        wallet: query.subaccountId == null ? this.ctx.credentials().ownerAddress : void 0,
+        subaccount_id: query.subaccountId ?? void 0,
+        start_timestamp: query.startTimestamp ?? void 0,
+        end_timestamp: query.endTimestamp ?? void 0
+      }
+    );
+  }
+  /**
+   * Paginated auctions a subaccount participated in as the liquidator.
+   * Predates the schema, so it is absent from the generated EndpointMap and sent untyped.
+   */
+  getLiquidatorHistory(query) {
+    return this.ctx.send(
+      "private/get_liquidator_history",
+      {
+        subaccount_id: query.subaccountId,
+        start_timestamp: query.startTimestamp ?? null,
+        end_timestamp: query.endTimestamp ?? null,
+        page: query.page ?? null,
+        page_size: query.pageSize ?? null
+      }
+    );
+  }
+};
+
+// src/api/vaults.ts
+import { formatUnits as formatUnits5, getAddress as getAddress7 } from "ethers";
+var SHAREHOLDER_INTENT_TTL_SEC = 600;
+function signVaultAction(ctx, subaccountId, data, overrides, defaultTtlSec) {
+  const { ownerAddress, signer } = ctx.credentials();
+  const action = new SignedAction(
+    {
+      subaccountId,
+      nonce: overrides.nonce ?? randomNonce(),
+      module: ctx.network.modules.vault,
+      data,
+      expirySec: overrides.signatureExpirySec ?? expiresIn(defaultTtlSec),
+      owner: ownerAddress,
+      signer: signer.address
+    },
+    domainSeparator(ctx.network)
+  );
+  return action.sign(signer);
+}
+function signedEnvelope(action) {
+  return {
+    subaccount_id: Number(action.fields.subaccountId),
+    // The API deserializes nonce via string_or_number; nanosecond nonces
+    // exceed 2^53, so send the decimal string despite the generated type.
+    nonce: action.fields.nonce,
+    signature_expiry_sec: action.fields.expirySec,
+    signer: action.fields.signer,
+    signature: action.signature
+    // set by sign() above
+  };
+}
+var ShareholderVaultsApi = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  ctx;
+  /** The vault subaccount ids the wallet holds shares in. */
+  async getShareholderVaults() {
+    return this.ctx.send("private/get_shareholder_vaults", { wallet: this.ctx.credentials().ownerAddress });
+  }
+  /** The wallet's share balance plus the full vault row for every vault it holds shares in. */
+  async getShares() {
+    return this.ctx.send("private/get_vault_shares", { wallet: this.ctx.credentials().ownerAddress });
+  }
+  /** The wallet's queued deposit/withdraw intents still awaiting curator settlement. */
+  async getLiveRequests() {
+    return this.ctx.send("private/get_live_vault_requests", { wallet: this.ctx.credentials().ownerAddress });
+  }
+  /** The wallet's full vault action history (every lifecycle status). */
+  async getRequestHistory(options = {}) {
+    return this.ctx.send("private/get_vault_request_history", {
+      wallet: this.ctx.credentials().ownerAddress,
+      page: options.page,
+      page_size: options.pageSize
+    });
+  }
+  /**
+   * Queues a deposit into a vault. The curator later mints shares at a
+   * quoted price committed to this exact signed payload; funds are held
+   * from the source subaccount until then (or until cancelled).
+   */
+  async requestDeposit(request) {
+    const amountE18 = toE18(request.amount);
+    const data = encodeVaultDeposit({
+      vaultSubaccountId: request.vaultSubaccountId,
+      depositSpotAsset: request.depositSpotAsset,
+      amount: amountE18
+    });
+    const action = signVaultAction(this.ctx, request.subaccountId, data, request, SHAREHOLDER_INTENT_TTL_SEC);
+    return this.ctx.send("private/request_vault_deposit", {
+      ...signedEnvelope(action),
+      vault_subaccount_id: request.vaultSubaccountId,
+      deposit_spot_asset: getAddress7(request.depositSpotAsset),
+      amount: formatUnits5(amountE18, 18)
+    });
+  }
+  /** Queues a share redemption; the curator later burns the shares at a quoted price. */
+  async requestWithdraw(request) {
+    const sharesE18 = toE18(request.sharesToBurn);
+    const data = encodeVaultWithdraw({
+      vaultSubaccountId: request.vaultSubaccountId,
+      sharesToBurn: sharesE18
+    });
+    const action = signVaultAction(this.ctx, request.subaccountId, data, request, SHAREHOLDER_INTENT_TTL_SEC);
+    return this.ctx.send("private/request_vault_withdraw", {
+      ...signedEnvelope(action),
+      vault_subaccount_id: request.vaultSubaccountId,
+      shares_to_burn: formatUnits5(sharesE18, 18)
+    });
+  }
+  /** Cancels ALL of the wallet's pending intents for a vault (deposits and withdrawals). */
+  async cancelAllRequests(request) {
+    const data = encodeVaultCancel(request.vaultSubaccountId);
+    const action = signVaultAction(this.ctx, request.subaccountId, data, request, SHAREHOLDER_INTENT_TTL_SEC);
+    return this.ctx.send("private/cancel_all_vault_requests", {
+      ...signedEnvelope(action),
+      vault_subaccount_id: request.vaultSubaccountId
+    });
+  }
+};
+var CuratorVaultsApi = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  ctx;
+  /** The vault subaccount ids this wallet curates. */
+  async getCuratedVaults() {
+    return this.ctx.send("private/get_curated_vaults", { wallet: this.ctx.credentials().ownerAddress });
+  }
+  /**
+   * Creates a vault funded from the signer's subaccount; the signer
+   * becomes its curator. Fee rates and max slippage are immutable
+   * afterwards.
+   */
+  async createVault(request) {
+    const initialDepositE18 = toE18(request.initialDeposit);
+    const maxFeeUsdE18 = toE18(request.maxFeeUsd);
+    const sharePriceUsdE18 = toE18(request.initialSharePriceUsd);
+    const benchmarkAsset = request.benchmarkAsset === void 0 ? void 0 : getAddress7(request.benchmarkAsset);
+    const data = encodeVaultCreate({
+      managerId: request.managerId,
+      depositSpotAsset: request.depositSpotAsset,
+      initialDeposit: initialDepositE18,
+      managementFeeBps: request.managementFeeBps,
+      performanceFeeBps: request.performanceFeeBps,
+      maxSlippageBps: request.maxSlippageBps,
+      cooldownSec: request.cooldownSec,
+      maxFeeUsd: maxFeeUsdE18,
+      initialSharePriceUsd: sharePriceUsdE18,
+      benchmarkAsset
+    });
+    const action = signVaultAction(this.ctx, request.subaccountId, data, request, DEFAULT_SIGNATURE_EXPIRY_SEC);
+    return this.ctx.send("private/create_vault", {
+      ...signedEnvelope(action),
+      manager_id: request.managerId,
+      deposit_spot_asset: getAddress7(request.depositSpotAsset),
+      initial_deposit: formatUnits5(initialDepositE18, 18),
+      management_fee_bps: request.managementFeeBps,
+      performance_fee_bps: request.performanceFeeBps,
+      max_slippage_bps: request.maxSlippageBps,
+      cooldown_sec: request.cooldownSec,
+      max_fee_usd: formatUnits5(maxFeeUsdE18, 18),
+      initial_share_price_usd: formatUnits5(sharePriceUsdE18, 18),
+      // Presence drives the signed hasBenchmark flag; the exchange derives it the same way.
+      benchmark_asset: benchmarkAsset ?? null
+    });
+  }
+  /** Settles one queued shareholder deposit, minting shares at the quoted price. */
+  async mintShares(request) {
+    const sharePriceE18 = toE18(request.sharePrice);
+    const data = encodeVaultMintShares({ sharePrice: sharePriceE18, depositHash: request.depositHash });
+    const action = signVaultAction(this.ctx, request.vaultSubaccountId, data, request, DEFAULT_SIGNATURE_EXPIRY_SEC);
+    return this.ctx.send("private/mint_vault_shares", {
+      ...signedEnvelope(action),
+      share_price: formatUnits5(sharePriceE18, 18),
+      deposit_hash: request.depositHash,
+      request_id: request.requestId
+    });
+  }
+  /** Settles one queued shareholder withdrawal, burning shares at the quoted price. */
+  async burnShares(request) {
+    const sharePriceE18 = toE18(request.sharePrice);
+    const data = encodeVaultBurnShares({ sharePrice: sharePriceE18, withdrawHash: request.withdrawHash });
+    const action = signVaultAction(this.ctx, request.vaultSubaccountId, data, request, DEFAULT_SIGNATURE_EXPIRY_SEC);
+    return this.ctx.send("private/burn_vault_shares", {
+      ...signedEnvelope(action),
+      share_price: formatUnits5(sharePriceE18, 18),
+      withdraw_hash: request.withdrawHash,
+      request_id: request.requestId
+    });
+  }
+  /** Updates the vault's advisory metadata (unsigned; an ownership check gates it to the curator). */
+  async updateInfo(request) {
+    return this.ctx.send("private/update_vault_info", {
+      subaccount_id: request.vaultSubaccountId,
+      name: request.name,
+      description: request.description,
+      mtm_cap: request.mtmCap === void 0 ? void 0 : formatUnits5(toE18(request.mtmCap), 18),
+      whitelist_only: request.whitelistOnly
+    });
+  }
+  /** The vault's queued deposit intents awaiting a `mintShares` settlement, FIFO-ordered with the queue total. */
+  async getLiveMintRequests(vaultSubaccountId, limit = 100) {
+    return this.ctx.send("private/get_live_mint_requests", { subaccount_id: vaultSubaccountId, limit });
+  }
+  /** The vault's queued withdraw intents awaiting a `burnShares` settlement, FIFO-ordered with the queue total. */
+  async getLiveBurnRequests(vaultSubaccountId, limit = 100) {
+    return this.ctx.send("private/get_live_burn_requests", { subaccount_id: vaultSubaccountId, limit });
+  }
+  /** Rejects a queued deposit intent, releasing the holder's funds without minting shares. */
+  async rejectDepositRequest(requestId, reason) {
+    return this.ctx.send("private/reject_deposit_request", {
+      request_id: requestId,
+      reason,
+      wallet: this.ctx.credentials().ownerAddress
+    });
+  }
+  /**
+   * Force-exits a holder at mark-to-market with no curator price quote (unsigned;
+   * an ownership check gates it to the curator of `vaultSubaccountId`).
+   */
+  async forceBurn(vaultSubaccountId, holder) {
+    return this.ctx.send("private/force_burn", { subaccount_id: vaultSubaccountId, holder });
+  }
+};
+var VaultsApi = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+    this.shareholder = new ShareholderVaultsApi(ctx);
+    this.curator = new CuratorVaultsApi(ctx);
+  }
+  ctx;
+  shareholder;
+  curator;
+  async getVault(vaultSubaccountId) {
+    return this.ctx.send("public/get_vault", { subaccount_id: vaultSubaccountId });
+  }
+  async listVaults(options = {}) {
+    return this.ctx.send("public/get_vaults", { page: options.page, page_size: options.pageSize });
+  }
+  async getActionHistory(vaultSubaccountId, options = {}) {
+    return this.ctx.send("public/get_vault_action_history", {
+      subaccount_id: vaultSubaccountId,
+      event_type: options.eventType,
+      page: options.page,
+      page_size: options.pageSize
+    });
+  }
+  async getPerformanceHistory(vaultSubaccountId, resolution, options = {}) {
+    return this.ctx.send("public/get_vault_performance_history", {
+      subaccount_id: vaultSubaccountId,
+      resolution,
+      ...options
+    });
+  }
+};
+
+// src/api/withdrawals.ts
+import { getAddress as getAddress8 } from "ethers";
+var WithdrawalsApi = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  ctx;
+  /** Builds the signed wire payload shared by `withdraw` and `withdrawDebug`. */
+  async buildWithdrawPayload(params) {
+    const { ownerAddress, signer } = this.ctx.credentials();
+    const recipient = getAddress8(params.recipient ?? signer.address);
+    if (recipient !== getAddress8(signer.address)) {
+      throw new Error(
+        `the exchange pays withdrawals out to the action signer (${signer.address}); recipient ${recipient} cannot be honored`
+      );
+    }
+    const asset = await resolveSpotAsset(this.ctx, params.asset);
+    if (params.decimals !== void 0 && params.decimals !== asset.decimals) {
+      throw new Error(
+        `decimals ${params.decimals} does not match the exchange's metadata for ${asset.name} (${asset.decimals}) \u2014 the signature would be rejected`
+      );
+    }
+    const forceBatch = params.forceBatch ?? false;
+    const maxFeeUsd = params.maxFeeUsd ?? (forceBatch ? "10" : "1");
+    const data = encodeWithdrawal({
+      protocolAsset: asset.address,
+      maxFeeUsd,
+      recipient,
+      amount: params.amount,
+      decimals: asset.decimals,
+      forceBatch
+    });
+    const action = new SignedAction(
+      {
+        subaccountId: params.subaccountId,
+        nonce: params.nonce ?? randomNonce(),
+        module: this.ctx.network.modules.withdrawal,
+        data,
+        expirySec: params.signatureExpirySec ?? expiresIn(DEFAULT_SIGNATURE_EXPIRY_SEC),
+        owner: ownerAddress,
+        signer: signer.address
+      },
+      domainSeparator(this.ctx.network)
+    ).sign(signer);
+    return {
+      subaccount_id: params.subaccountId,
+      asset_name: asset.name,
+      amount_in_underlying: decimalString(params.amount, asset.decimals),
+      max_fee_usd: decimalString(maxFeeUsd),
+      force_batch: forceBatch,
+      // Nonces are UTC-nanosecond decimal strings beyond 2^53; the API accepts string-or-number despite the generated `number`.
+      nonce: action.fields.nonce,
+      signer: action.fields.signer,
+      signature: action.signature,
+      signature_expiry_sec: action.fields.expirySec
+    };
+  }
+  async withdraw(params) {
+    return this.ctx.send("private/withdraw", await this.buildWithdrawPayload(params));
+  }
+  /**
+   * Debug helper: signs the withdrawal exactly like `withdraw` but submits it
+   * to `public/withdraw_debug`, which returns the server-computed encoded data
+   * and action/typed-data hashes instead of executing. Use it to verify your
+   * client-side signing matches the exchange's.
+   */
+  async withdrawDebug(params) {
+    return this.ctx.send("public/withdraw_debug", await this.buildWithdrawPayload(params));
+  }
+  /**
+   * Withdrawal history rows (up to 1000). Scoped to one subaccount when
+   * `subaccountId` is given, otherwise to the whole owner wallet.
+   * Timestamps are unix milliseconds.
+   */
+  async getHistory(options = {}) {
+    return this.ctx.send("private/get_withdrawal_history", {
+      subaccount_id: options.subaccountId,
+      wallet: options.subaccountId === void 0 ? this.ctx.credentials().ownerAddress : void 0,
+      start_timestamp: options.startTimestampMs,
+      end_timestamp: options.endTimestampMs
+    });
+  }
+};
+
+// src/auth/auth.ts
+async function authHeaders(credentials) {
+  const timestamp = Date.now().toString();
+  const signature = await credentials.signer.signMessage(timestamp);
+  return {
+    "X-LyraWallet": credentials.ownerAddress,
+    "X-LyraTimestamp": timestamp,
+    "X-LyraSignature": signature
+  };
+}
+async function loginParams(credentials) {
+  const timestamp = Date.now().toString();
+  return {
+    wallet: credentials.ownerAddress,
+    timestamp,
+    signature: await credentials.signer.signMessage(timestamp)
+  };
+}
+
+// src/signing/modules.ts
+var V3_MODULE_ADDRESSES = {
+  trade: "0xB8D20c2B7a1Ad2EE33Bc50eF10876eD3035b5e7b",
+  transfer: "0x01259207A40925b794C8ac320456F7F6c8FE2636",
+  withdrawal: "0x9d0E8f5b25384C7310CB8C6aE32C8fbeb645d083",
+  rfq: "0x9371352CCef6f5b36EfDFE90942fFE622Ab77F1D",
+  externalTransfer: "0x8F9B8f12ddA05FB1F0DDDDe8f5af8cECF54f8aC9",
+  whitelistedRecipient: "0xB86D6DE1b76c9839e4BA860848CD98A1dABd6B54",
+  vault: "0x2885c174ebf5524aED9c721d60c12b1537685186",
+  liquidation: "0x66d23e59DaEEF13904eFA2D4B8658aeD05f59a92",
+  createSessionKey: "0xe330CF64ff6EbF41699aad344Cb21d78db1D2bb6"
+};
+
+// src/config/networks.ts
+var NETWORKS = {
+  mainnet: {
+    name: "mainnet",
+    httpUrl: "https://api.derive.xyz/v3",
+    wsUrl: "wss://api.derive.xyz/v3/ws",
+    chainId: 1,
+    // Ethereum L1
+    modules: { ...V3_MODULE_ADDRESSES },
+    contracts: {
+      // Placeholder — set the mainnet ActionManager address once published.
+      actionManager: "0x0000000000000000000000000000000000000000",
+      usdc: "0x6879287835A86F50f784313dBEd5E5cCC5bb8481",
+      cash: "0x57B03E14d409ADC7fAb6CFc44b5886CAD2D5f02b"
+    }
+  },
+  testnet: {
+    name: "testnet",
+    httpUrl: "https://testnet.api.derive.xyz/v3",
+    wsUrl: "wss://testnet.api.derive.xyz/v3/ws",
+    chainId: 11155111,
+    // Sepolia
+    modules: { ...V3_MODULE_ADDRESSES },
+    contracts: {
+      actionManager: "0xcd84E4CC2996787D2F6794Ce99FeCda5Edb10E86",
+      usdc: "0x7F4B9B80863b937340202f26Ad555CC7D3ABD2BA"
+    }
+  },
+  local: {
+    name: "local",
+    httpUrl: "http://localhost:8080",
+    wsUrl: "ws://localhost:3000/ws",
+    chainId: 31337,
+    // anvil
+    modules: { ...V3_MODULE_ADDRESSES },
+    contracts: {
+      actionManager: "0x0165878A594ca255338adfa4d48449f69242Eb8F",
+      usdc: "0xA51c1fc2f0D1a1b8494Ed1FE312d7C3a78Ed91C0"
+    }
+  }
+};
+function resolveNetwork(network) {
+  if (typeof network !== "string") return network;
+  const preset = NETWORKS[network];
+  if (!preset) {
+    throw new Error(`unknown network preset '${network}' \u2014 pass a full NetworkConfig instead`);
+  }
+  return preset;
+}
+
+// src/subscriptions/subscriptions.ts
+var STREAM_BUFFER_LIMIT = 1e4;
+var Subscriptions = class {
+  constructor(ctx, ws) {
+    this.ctx = ctx;
+    this.ws = ws;
+    ws.onNotification = (channelName, data) => this.dispatch(channelName, data);
+  }
+  ctx;
+  ws;
+  handlers = /* @__PURE__ */ new Map();
+  /**
+   * Subscribes to a channel and registers `handler` for its
+   * notifications. Multiple handlers share one wire subscription per
+   * channel: the `subscribe` RPC is sent only for the first handler on a
+   * channel, and `unsubscribe` only when the last is removed.
+   */
+  async subscribe(ch, handler) {
+    const entry = (data) => handler(data);
+    const existing = this.handlers.get(ch.name);
+    if (existing) {
+      existing.add(entry);
+    } else {
+      const set = /* @__PURE__ */ new Set([entry]);
+      this.handlers.set(ch.name, set);
+      try {
+        await this.sendChannelRpc("subscribe", [ch.name]);
+      } catch (error) {
+        set.delete(entry);
+        if (set.size === 0) this.handlers.delete(ch.name);
+        throw error;
+      }
+    }
+    return {
+      channel: ch.name,
+      unsubscribe: async () => {
+        const current = this.handlers.get(ch.name);
+        if (!current?.delete(entry)) return;
+        if (current.size === 0) {
+          this.handlers.delete(ch.name);
+          await this.sendChannelRpc("unsubscribe", [ch.name]);
+        }
+      }
+    };
+  }
+  /**
+   * The channel as an async iterator: subscribes on the first `next()`,
+   * buffers notifications the consumer has not yet read (dropping the
+   * oldest beyond `STREAM_BUFFER_LIMIT`), and unsubscribes when the
+   * loop ends (`break` / `return()` / `throw()`).
+   */
+  stream(ch) {
+    const queue = [];
+    const waiters = [];
+    let subscribing;
+    let done = false;
+    let overflowWarned = false;
+    const onData = (data) => {
+      if (done) return;
+      const waiter = waiters.shift();
+      if (waiter) {
+        waiter({ value: data, done: false });
+        return;
+      }
+      queue.push(data);
+      if (queue.length > STREAM_BUFFER_LIMIT) {
+        queue.shift();
+        if (!overflowWarned) {
+          overflowWarned = true;
+          this.ctx.logger(
+            "warn",
+            `stream ${ch.name}: buffer exceeded ${STREAM_BUFFER_LIMIT} notifications; dropping oldest`
+          );
+        }
+      }
+    };
+    const finish = async () => {
+      if (done) return;
+      done = true;
+      for (const waiter of waiters.splice(0)) waiter({ value: void 0, done: true });
+      const subscription = await subscribing?.catch(() => void 0);
+      await subscription?.unsubscribe();
+    };
+    return {
+      [Symbol.asyncIterator]() {
+        return this;
+      },
+      next: async () => {
+        if (done) return { value: void 0, done: true };
+        subscribing ??= this.subscribe(ch, onData);
+        await subscribing;
+        if (done) return { value: void 0, done: true };
+        if (queue.length > 0) return { value: queue.shift(), done: false };
+        return new Promise((resolve) => waiters.push(resolve));
+      },
+      return: async () => {
+        await finish();
+        return { value: void 0, done: true };
+      },
+      throw: async (error) => {
+        await finish();
+        throw error;
+      }
+    };
+  }
+  /** Re-sends `subscribe` for every active channel; the client calls this after a websocket reconnect. */
+  async resubscribeAll() {
+    const channels = [...this.handlers.keys()];
+    if (channels.length === 0) return;
+    const result = await this.ws.send("subscribe", { channels });
+    for (const name of channels) {
+      const status = result.status[name];
+      if (status !== "ok" && status !== "already subscribed") {
+        this.ctx.logger("error", `resubscribe to ${name} failed`, status);
+      }
+    }
+  }
+  /**
+   * `subscribe`/`unsubscribe` exist only over the websocket, so they go
+   * straight to the ws transport (never the client's HTTP fallback). A
+   * per-channel `status` other than 'ok'/'already subscribed' throws.
+   */
+  async sendChannelRpc(method, channels) {
+    const result = await this.ws.send(method, { channels });
+    for (const name of channels) {
+      const status = result.status[name];
+      if (status !== "ok" && status !== "already subscribed") {
+        throw new Error(`${method} ${name} failed: ${String(status)}`);
+      }
+    }
+  }
+  dispatch(channelName, data) {
+    const set = this.handlers.get(channelName);
+    if (!set || set.size === 0) {
+      this.ctx.logger("debug", `dropping notification for unhandled channel ${channelName}`);
+      return;
+    }
+    for (const handler of set) {
+      try {
+        handler(data);
+      } catch (error) {
+        this.ctx.logger("error", `subscription handler for ${channelName} threw`, error);
+      }
+    }
+  }
+};
+
+// src/methodGuard.ts
+var PUBLIC_METHOD_PREFIXES = ["public/", "private/"];
+var WS_CONTROL_METHODS = /* @__PURE__ */ new Set(["subscribe", "unsubscribe"]);
+function isPublicApiMethod(method) {
+  return PUBLIC_METHOD_PREFIXES.some((prefix) => method.startsWith(prefix));
+}
+
+// src/transport/jsonrpc.ts
+var METHOD_FORMAT = /^[a-z]+\/[a-z0-9_]+$/;
+function assertPublicMethod(method) {
+  if (WS_CONTROL_METHODS.has(method)) return;
+  if (!METHOD_FORMAT.test(method)) {
+    throw new Error(`invalid method '${method}': expected the form namespace/name`);
+  }
+  if (!isPublicApiMethod(method)) {
+    throw new Error(`${method} is not part of the public Derive API`);
+  }
+}
+function unwrapResponse(method, raw) {
+  if (raw.error) throw new DeriveRpcError(method, raw.error);
+  if (!("result" in raw)) throw new Error(`${method}: malformed response \u2014 neither result nor error present`);
+  return raw.result;
+}
+
+// src/transport/http.ts
+var HttpTransport = class {
+  constructor(options) {
+    this.options = options;
+  }
+  options;
+  async send(method, params) {
+    assertPublicMethod(method);
+    const { baseUrl, timeoutMs, logger, authHeaders: authHeaders2 } = this.options;
+    const headers = {
+      "content-type": "application/json",
+      // The API rejects UA-less requests; browsers ignore this
+      // (the browser UA is a forbidden header) and send their own.
+      "user-agent": `derive-ts/${SDK_VERSION}`
+    };
+    if (method.startsWith("private/")) {
+      if (!authHeaders2) {
+        throw new Error(`${method} requires authentication \u2014 construct the client with a wallet or session key`);
+      }
+      Object.assign(headers, await authHeaders2());
+    }
+    logger("debug", `HTTP ${method}`, params);
+    let response;
+    try {
+      response = await fetch(`${baseUrl}/${method}`, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(params),
+        // Never follow a redirect: it would forward the signed X-Lyra*
+        // auth headers to the redirect target.
+        redirect: "error",
+        signal: AbortSignal.timeout(timeoutMs)
+      });
+    } catch (cause) {
+      if (cause instanceof DOMException && cause.name === "TimeoutError") {
+        throw new DeriveTimeoutError(`${method}: no response within ${timeoutMs}ms`);
+      }
+      throw cause;
+    }
+    let body;
+    try {
+      body = await response.json();
+    } catch {
+      throw new Error(`${method}: non-JSON response with HTTP status ${response.status}`);
+    }
+    return unwrapResponse(method, body);
+  }
+};
+
+// src/transport/ws.ts
+var WS_OPEN = 1;
+var RECONNECT_MAX_ATTEMPTS = 5;
+var RECONNECT_BASE_DELAY_MS = 500;
+var RECONNECT_MAX_DELAY_MS = 8e3;
+async function defaultWebSocketFactory(url) {
+  const globalWs = globalThis.WebSocket;
+  if (globalWs) return new globalWs(url);
+  const { WebSocket: nodeWs } = await import("ws");
+  return new nodeWs(url);
+}
+var WsTransport = class {
+  constructor(options) {
+    this.options = options;
+  }
+  options;
+  /** Set by the subscriptions layer; receives every pub/sub notification. */
+  onNotification;
+  /** Set by the client; runs after an automatic reconnect succeeds. */
+  onReconnected;
+  socket;
+  nextId = 0;
+  pending = /* @__PURE__ */ new Map();
+  intentionallyClosed = false;
+  connecting;
+  get connected() {
+    return this.socket?.readyState === WS_OPEN;
+  }
+  async connect() {
+    if (this.connected) return;
+    this.connecting ??= (async () => {
+      this.intentionallyClosed = false;
+      this.socket = await this.open();
+    })().finally(() => {
+      this.connecting = void 0;
+    });
+    return this.connecting;
+  }
+  async open() {
+    const factory = this.options.wsFactory ?? defaultWebSocketFactory;
+    const socket = await factory(this.options.url);
+    await new Promise((resolve, reject) => {
+      if (socket.readyState === WS_OPEN) return resolve();
+      socket.onopen = () => resolve();
+      socket.onerror = (event) => reject(new DeriveConnectionError(`failed to connect to ${this.options.url}`, { cause: event }));
+    });
+    socket.onerror = (event) => this.options.logger("warn", "websocket error", event);
+    socket.onmessage = (event) => this.handleMessage(event.data);
+    socket.onclose = (event) => this.handleClose(event.code);
+    return socket;
+  }
+  async send(method, params) {
+    assertPublicMethod(method);
+    if (!this.connected) {
+      throw new DeriveConnectionError("websocket is not connected \u2014 call connect() first");
+    }
+    const id = ++this.nextId;
+    const raw = await new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(id);
+        reject(new DeriveTimeoutError(`${method}: no response within ${this.options.timeoutMs}ms`));
+      }, this.options.timeoutMs);
+      this.pending.set(id, { method, resolve, reject, timer });
+      this.options.logger("debug", `WS ${method}`, params);
+      try {
+        this.socket.send(JSON.stringify({ id, method, params }));
+      } catch (cause) {
+        clearTimeout(timer);
+        this.pending.delete(id);
+        reject(new DeriveConnectionError("websocket send failed", { cause }));
+      }
+    });
+    return unwrapResponse(method, raw);
+  }
+  async close() {
+    this.intentionallyClosed = true;
+    const socket = this.socket;
+    if (!socket || socket.readyState !== WS_OPEN) return;
+    this.rejectAllPending(new DeriveConnectionError("websocket closed by client"));
+    await new Promise((resolve) => {
+      const timer = setTimeout(() => {
+        socket.onclose = null;
+        socket.onerror = null;
+        resolve();
+      }, 1e3);
+      socket.onclose = () => {
+        clearTimeout(timer);
+        resolve();
+      };
+      socket.close();
+    });
+  }
+  handleMessage(payload) {
+    let message;
+    try {
+      message = JSON.parse(String(payload));
+    } catch {
+      this.options.logger("warn", "ignoring non-JSON websocket message");
+      return;
+    }
+    if (typeof message.id === "number" && this.pending.has(message.id)) {
+      const request = this.pending.get(message.id);
+      this.pending.delete(message.id);
+      clearTimeout(request.timer);
+      request.resolve(message);
+      return;
+    }
+    if (message.method === "subscription" && message.params?.channel) {
+      this.onNotification?.(message.params.channel, message.params.data);
+      return;
+    }
+    this.options.logger("debug", "unmatched websocket message", message);
+  }
+  handleClose(code) {
+    this.rejectAllPending(new DeriveTimeoutError("websocket closed before a response was received"));
+    if (this.intentionallyClosed) return;
+    this.options.logger("warn", `websocket closed unexpectedly (code ${code}); reconnecting`);
+    void this.reconnect();
+  }
+  rejectAllPending(error) {
+    for (const request of this.pending.values()) {
+      clearTimeout(request.timer);
+      request.reject(error);
+    }
+    this.pending.clear();
+  }
+  async reconnect() {
+    for (let attempt = 1; attempt <= RECONNECT_MAX_ATTEMPTS; attempt++) {
+      const delay = Math.min(RECONNECT_BASE_DELAY_MS * 2 ** (attempt - 1), RECONNECT_MAX_DELAY_MS);
+      await new Promise((resolve) => setTimeout(resolve, delay));
+      if (this.intentionallyClosed) return;
+      let socket;
+      try {
+        socket = await this.open();
+        this.socket = socket;
+        await this.onReconnected?.();
+        this.options.logger("info", `websocket reconnected after ${attempt} attempt(s)`);
+        return;
+      } catch (error) {
+        try {
+          socket?.close();
+        } catch {
+        }
+        this.options.logger("warn", `reconnect attempt ${attempt}/${RECONNECT_MAX_ATTEMPTS} failed`, error);
+      }
+    }
+    this.options.logger("error", "websocket reconnection failed; connection abandoned");
+  }
+};
+
+// src/client.ts
+var noopLogger = () => {
+};
+function toWallet(input) {
+  return typeof input === "string" ? new Wallet(input) : input;
+}
+var DeriveClient = class {
+  network;
+  ws;
+  http;
+  marketData;
+  subaccounts;
+  orders;
+  rfq;
+  spotTransfers;
+  positionTransfers;
+  withdrawals;
+  deposits;
+  vaults;
+  sessionKeys;
+  subscriptions;
+  logger;
+  owner;
+  sessionKey;
+  accountOwner;
+  loggedIn = false;
+  constructor(options) {
+    this.network = resolveNetwork(options.network);
+    this.logger = options.logger ?? noopLogger;
+    this.owner = toWallet(options.wallet);
+    this.sessionKey = toWallet(options.sessionKey);
+    this.accountOwner = options.ownerAddress ?? this.owner?.address;
+    if (this.sessionKey && !this.accountOwner) {
+      throw new Error("a session key acts for an account owner \u2014 also pass `wallet` or `ownerAddress`");
+    }
+    const timeoutMs = options.requestTimeoutMs ?? 2e4;
+    this.http = new HttpTransport({
+      baseUrl: this.network.httpUrl,
+      timeoutMs,
+      logger: this.logger,
+      authHeaders: () => authHeaders(this.credentials())
+    });
+    this.ws = new WsTransport({
+      url: this.network.wsUrl,
+      timeoutMs,
+      logger: this.logger,
+      wsFactory: options.wsFactory
+    });
+    this.ws.onReconnected = async () => {
+      if (this.loggedIn) await this.login();
+      await this.subscriptions.resubscribeAll();
+    };
+    this.marketData = new MarketDataApi(this);
+    this.subaccounts = new SubaccountsApi(this);
+    this.orders = new OrdersApi(this, this.marketData);
+    this.rfq = new RfqApi(this);
+    this.spotTransfers = new SpotTransfersApi(this);
+    this.positionTransfers = new PositionTransfersApi(this);
+    this.withdrawals = new WithdrawalsApi(this);
+    this.deposits = new DepositsApi(this);
+    this.vaults = new VaultsApi(this);
+    this.sessionKeys = new SessionKeysApi(this);
+    this.subscriptions = new Subscriptions(this, this.ws);
+  }
+  /**
+   * The identity requests act as: the owner address plus whichever
+   * wallet signs (session key when configured, otherwise the owner).
+   */
+  credentials() {
+    const signer = this.sessionKey ?? this.owner;
+    if (!signer || !this.accountOwner) {
+      throw new Error("this operation requires authentication \u2014 construct DeriveClient with a wallet or session key");
+    }
+    return { ownerAddress: this.accountOwner, signer };
+  }
+  /** Opens the websocket. REST-only usage can skip this. */
+  async connect() {
+    await this.ws.connect();
+  }
+  /**
+   * Authenticates the websocket connection (REST requests instead carry
+   * signed headers per request). Re-runs automatically after reconnects.
+   */
+  async login() {
+    if (!this.ws.connected) {
+      throw new Error("login runs over the websocket \u2014 call connect() first");
+    }
+    const result = await this.ws.send("public/login", await loginParams(this.credentials()));
+    this.loggedIn = true;
+    return result;
+  }
+  async close() {
+    this.loggedIn = false;
+    await this.ws.close();
+  }
+  /**
+   * Typed escape hatch for any public RPC method: uses the websocket
+   * when connected, REST otherwise.
+   */
+  send(method, params) {
+    return this.ws.connected ? this.ws.send(method, params) : this.http.send(method, params);
+  }
+};
+
+// src/subscriptions/channels.ts
+function channel(template, params) {
+  const values = params;
+  const used = /* @__PURE__ */ new Set();
+  const name = template.replace(/\{(\w+)\}/g, (_token, key) => {
+    const value = values[key];
+    if (value === void 0 || value === null || String(value) === "") {
+      throw new Error(`channel ${template}: missing value for {${key}}`);
+    }
+    used.add(key);
+    return String(value);
+  });
+  for (const key of Object.keys(values)) {
+    if (!used.has(key)) {
+      throw new Error(`channel ${template}: unknown param '${key}'`);
+    }
+  }
+  return { name };
+}
+export {
+  ACTION_TYPEHASH,
+  ContractCallDeposits,
+  CuratorVaultsApi,
+  DepositAddressDeposits,
+  DepositsApi,
+  DeriveClient,
+  DeriveConnectionError,
+  DeriveRpcError,
+  DeriveTimeoutError,
+  MarketDataApi,
+  NETWORKS,
+  OffchainScope,
+  OrdersApi,
+  PositionTransfersApi,
+  ProtocolScopeCode,
+  ProtocolScopeWireString,
+  RfqApi,
+  SDK_VERSION,
+  SessionKeysApi,
+  ShareholderVaultsApi,
+  SignedAction,
+  SpotTransfersApi,
+  SubaccountsApi,
+  Subscriptions,
+  V3_MODULE_ADDRESSES,
+  VaultsApi,
+  WithdrawalsApi,
+  authHeaders,
+  channel,
+  domainSeparator,
+  expiresIn,
+  loginParams,
+  randomNonce,
+  resolveNetwork,
+  toE18,
+  toScaled
+};
+//# sourceMappingURL=index.js.map