@trusset/sdk 0.1.0 → 0.5.0

package/dist/chunk-4MNJZAXE.mjs

@@ -0,0 +1,2260 @@
+import {
+  BUILD,
+  CONFIRM,
+  CONFIRM_ONCE,
+  DOCUMENT_TIMEOUT_MS,
+  LENDING_BASE,
+  LendingArea,
+  LendingContext,
+  compact,
+  enc
+} from "./chunk-DQCX2GYT.mjs";
+import {
+  ConfirmationError,
+  TrussetError,
+  ValidationError,
+  assertInputIsNotOptions,
+  attachTransactions,
+  checkSignedPrice,
+  clampInt,
+  confirmExecuted,
+  execute,
+  isConfirmOptions,
+  isSignOptions,
+  optionalAmount,
+  optionalBoolean,
+  optionalInt,
+  optionalOneOf,
+  optionalWallet,
+  planOf,
+  preflightChain,
+  requireAmount,
+  requireBoolean,
+  requireHash,
+  requireInt,
+  requireIntegerString,
+  requireMarketId,
+  requireOneOf,
+  requirePositiveId,
+  requireRecordId,
+  requireSigner,
+  requireString,
+  requireTxHash,
+  requireWallet,
+  sameAddress,
+  signTypedData,
+  signerAddress,
+  splitSignature,
+  walletOf
+} from "./chunk-3YF42MHV.mjs";
+
+// src/modules/lending/markets.ts
+var PRICE_SOURCES = ["MARKET", "NAV", "ORACLE", "FIXED"];
+var COLLATERAL_MODES = ["FREEZE", "CUSTODY"];
+var RATE_MODES = ["CURVE", "CLAMPED", "FIXED"];
+var UPGRADE_TARGETS = ["market", "rateModel", "router", "insuranceFund", "oracle"];
+var UPGRADE_ACTIONS = ["propose", "cancel", "execute"];
+var PRICE_HALT_ACTIONS = ["halt", "lift"];
+var MAX_PRICE_HALT_SECONDS = 86400;
+var HISTORY_RANGES = ["24h", "7d", "30d", "90d", "1y", "all"];
+var HISTORY_RESOLUTIONS = ["hour", "day"];
+var STATEMENT_CATEGORIES = ["config", "roles", "encumbrances", "loans", "liquidations", "auctions"];
+var CONFIGURE_ACTIONS = [
+  "authorizeOnRouter",
+  "grantLiquidatorRole",
+  "upgradeMarket",
+  "upgradeRouter",
+  "verifyAdapterAsHolder",
+  "verifyRouterAsHolder",
+  "authorizeAdapterOnToken",
+  "authorizeRouterOnToken",
+  "authorizeVenueOnToken",
+  "verifyVenueAsHolder",
+  "setInsuranceFund",
+  "grantAgentRoleToAdapter",
+  "authorizeRelayerOnOracle"
+];
+var HOLDER_ACTIONS = ["verifyAdapterAsHolder", "verifyRouterAsHolder", "verifyVenueAsHolder"];
+var PROFILE_KEY_RE = /^[A-Za-z0-9_-]{1,60}$/;
+var ACCESS_LIST_ID_RE = /^[A-Za-z0-9_-]{1,64}$/;
+var PRICE_RE = /^\d+(\.\d{1,18})?$/;
+var DATE_RE = /^\d{4}-\d{2}-\d{2}$/;
+var CLAIM_SIGNATURE_RE = /^0x[a-fA-F0-9]{130}$/;
+function optionalProfileKey(value, field) {
+  if (value === void 0 || value === null) return void 0;
+  const s = typeof value === "string" ? value.trim() : "";
+  if (!PROFILE_KEY_RE.test(s)) throw new ValidationError(`${field} must be a verification profile key (letters, digits, underscores and hyphens, at most 60 characters)`);
+  return s;
+}
+function optionalAccessListId(value, field) {
+  if (value === void 0 || value === null) return void 0;
+  const s = typeof value === "string" ? value.trim() : "";
+  if (!ACCESS_LIST_ID_RE.test(s)) throw new ValidationError(`${field} must be a whitelist id (letters, digits, underscores and hyphens, at most 64 characters)`);
+  return s;
+}
+function optionalRegister(value, field) {
+  if (value === void 0) return void 0;
+  if (value === null || value === "") return null;
+  return requireWallet(value, field, { allowZero: true });
+}
+function rateOfferingCheck(input) {
+  const floorGiven = input.rateFloorBps !== void 0 && input.rateFloorBps !== null;
+  const capGiven = input.rateCapBps !== void 0 && input.rateCapBps !== null;
+  const fixedGiven = input.fixedRateBps !== void 0 && input.fixedRateBps !== null;
+  if (input.rateMode === "FIXED") {
+    if (!fixedGiven) throw new ValidationError("A FIXED rate mode requires fixedRateBps");
+    if (floorGiven || capGiven) throw new ValidationError("A FIXED rate mode takes fixedRateBps only; rateFloorBps and rateCapBps belong to CLAMPED");
+  } else if (input.rateMode === "CLAMPED") {
+    if (!capGiven) throw new ValidationError("A CLAMPED rate mode requires rateCapBps");
+    if (fixedGiven) throw new ValidationError("A CLAMPED rate mode takes rateFloorBps and rateCapBps only; fixedRateBps belongs to FIXED");
+  } else if (floorGiven || capGiven || fixedGiven) {
+    throw new ValidationError("Rate bounds need a rateMode of CLAMPED or FIXED; the CURVE default takes none");
+  }
+}
+function terminalDueDateOf(value) {
+  if (value === void 0 || value === null) return void 0;
+  if (typeof value === "number" && Number.isInteger(value) && value > 0) return value;
+  if (typeof value === "string" && value.trim().length > 0) return value.trim();
+  throw new ValidationError("terminalDueDate must be unix seconds or an ISO date string");
+}
+function deployBody(input) {
+  if (!input || typeof input !== "object") throw new ValidationError("deploy needs the market parameters");
+  if (input.operatorShareBps !== void 0) {
+    throw new ValidationError("operatorShareBps is no longer accepted: every market pays its operator and distributors the fixed shares the factory sets");
+  }
+  const priceSource = optionalOneOf(input.priceSource, "priceSource", PRICE_SOURCES);
+  const oracleAddress = optionalWallet(input.oracleAddress, "oracleAddress");
+  let initialPrice;
+  if (input.initialPrice !== void 0) {
+    initialPrice = requireAmount(input.initialPrice, "initialPrice");
+    if (!PRICE_RE.test(initialPrice)) throw new ValidationError("initialPrice must have at most 18 decimal places");
+  }
+  if (priceSource === "ORACLE") {
+    if (!oracleAddress) throw new ValidationError("The ORACLE price source needs oracleAddress: the external feed the market reads prices from");
+  } else {
+    if (oracleAddress) throw new ValidationError("oracleAddress only applies to the ORACLE price source");
+    if (initialPrice === void 0) throw new ValidationError("initialPrice is required for the NAV, MARKET and FIXED price sources");
+  }
+  const rateMode = optionalOneOf(input.rateMode, "rateMode", RATE_MODES);
+  const body = {
+    collateralTokenAddress: requireWallet(input.collateralTokenAddress, "collateralTokenAddress"),
+    priceSource,
+    initialPrice,
+    oracleAddress,
+    mode: optionalOneOf(input.mode, "mode", COLLATERAL_MODES),
+    borrowAssetAddress: optionalWallet(input.borrowAssetAddress, "borrowAssetAddress"),
+    identityRegistry: optionalWallet(input.identityRegistry, "identityRegistry", { allowZero: true }),
+    providerRegistry: optionalWallet(input.providerRegistry, "providerRegistry", { allowZero: true }),
+    identityRegistryProfile: optionalProfileKey(input.identityRegistryProfile, "identityRegistryProfile"),
+    providerRegistryProfile: optionalProfileKey(input.providerRegistryProfile, "providerRegistryProfile"),
+    identityRegistryAccessList: optionalAccessListId(input.identityRegistryAccessList, "identityRegistryAccessList"),
+    providerRegistryAccessList: optionalAccessListId(input.providerRegistryAccessList, "providerRegistryAccessList"),
+    attestIdentifiedMembers: optionalBoolean(input.attestIdentifiedMembers, "attestIdentifiedMembers"),
+    fallbackDecimals: optionalInt(input.fallbackDecimals, "fallbackDecimals", 0, 36),
+    openToAnyCurator: optionalBoolean(input.openToAnyCurator, "openToAnyCurator"),
+    acknowledgeFixedPriceMismatch: optionalBoolean(input.acknowledgeFixedPriceMismatch, "acknowledgeFixedPriceMismatch"),
+    rateMode,
+    rateFloorBps: optionalInt(input.rateFloorBps, "rateFloorBps", 0, 5e4),
+    rateCapBps: optionalInt(input.rateCapBps, "rateCapBps", 1, 5e4),
+    fixedRateBps: optionalInt(input.fixedRateBps, "fixedRateBps", 1, 5e4),
+    maxLoanDurationDays: optionalInt(input.maxLoanDurationDays, "maxLoanDurationDays", 1, 3650),
+    termGracePeriodDays: optionalInt(input.termGracePeriodDays, "termGracePeriodDays", 1, 30),
+    terminalDueDate: terminalDueDateOf(input.terminalDueDate)
+  };
+  if (input.candidates !== void 0) {
+    if (!Array.isArray(input.candidates) || input.candidates.length > 20) throw new ValidationError("candidates must be a list of at most 20 wallet addresses");
+    body.candidates = input.candidates.map((c, i) => requireWallet(c, `candidates[${i}]`));
+  }
+  if (rateMode === "FIXED" && body.maxLoanDurationDays === void 0) {
+    throw new ValidationError("A FIXED rate mode requires a term offering: set maxLoanDurationDays");
+  }
+  rateOfferingCheck(input);
+  if (body.maxLoanDurationDays === void 0 && body.terminalDueDate === void 0 && body.termGracePeriodDays !== void 0) {
+    throw new ValidationError("A grace period needs loan terms: set maxLoanDurationDays or terminalDueDate as well");
+  }
+  return compact(body);
+}
+function deployConfirmFields(source) {
+  if (!source) return {};
+  const out = {};
+  for (const key of ["collateralTokenAddress", "mode", "priceSource", "borrowAssetAddress", "identityRegistry"]) {
+    const value = source[key];
+    if (value !== void 0 && value !== null && value !== "") out[key] = value;
+  }
+  return out;
+}
+function configBody(config) {
+  if (!config || typeof config !== "object") throw new ValidationError("config must be the full 12-member risk configuration");
+  const collateralFactor = requireInt(config.collateralFactor, "config.collateralFactor", 1e3, 9e3);
+  const liquidationThreshold = requireInt(config.liquidationThreshold, "config.liquidationThreshold", 1e3, 9500);
+  if (liquidationThreshold <= collateralFactor) throw new ValidationError("config.liquidationThreshold must be strictly greater than config.collateralFactor; the market contract refuses anything else");
+  const useDutchAuction = requireBoolean(config.useDutchAuction, "config.useDutchAuction");
+  const auctionStartPremium = requireInt(config.auctionStartPremium, "config.auctionStartPremium", 1e4, 2e4);
+  const auctionMinPremium = requireInt(config.auctionMinPremium, "config.auctionMinPremium", 8e3, 1e4);
+  if (useDutchAuction && auctionStartPremium <= auctionMinPremium) throw new ValidationError("config.auctionStartPremium must be strictly greater than config.auctionMinPremium while auctions are on");
+  return {
+    collateralFactor,
+    liquidationThreshold,
+    liquidationPenalty: requireInt(config.liquidationPenalty, "config.liquidationPenalty", 0, 5e3),
+    protocolFeeRate: requireInt(config.protocolFeeRate, "config.protocolFeeRate", 0, 1e4),
+    minBorrowAmount: requireAmount(config.minBorrowAmount, "config.minBorrowAmount", { allowZero: true }),
+    closeFactor: requireInt(config.closeFactor, "config.closeFactor", 1e3, 5e3),
+    maxTotalCollateral: requireAmount(config.maxTotalCollateral, "config.maxTotalCollateral", { allowZero: true }),
+    maxUserCollateral: requireAmount(config.maxUserCollateral, "config.maxUserCollateral", { allowZero: true }),
+    useDutchAuction,
+    auctionDuration: requireInt(config.auctionDuration, "config.auctionDuration", 600, 86400),
+    auctionStartPremium,
+    auctionMinPremium
+  };
+}
+function identityGatesBody(input) {
+  if (!input || typeof input !== "object") throw new ValidationError("setIdentityGates needs the registers to set");
+  return compact({
+    borrowerRegistry: optionalRegister(input.borrowerRegistry, "borrowerRegistry"),
+    providerRegistry: optionalRegister(input.providerRegistry, "providerRegistry"),
+    borrowerProfile: optionalProfileKey(input.borrowerProfile, "borrowerProfile"),
+    providerProfile: optionalProfileKey(input.providerProfile, "providerProfile"),
+    borrowerAccessList: optionalAccessListId(input.borrowerAccessList, "borrowerAccessList"),
+    providerAccessList: optionalAccessListId(input.providerAccessList, "providerAccessList"),
+    attestIdentifiedMembers: optionalBoolean(input.attestIdentifiedMembers, "attestIdentifiedMembers")
+  });
+}
+function configureBody(input) {
+  const action = optionalOneOf(input.action, "action", CONFIGURE_ACTIONS);
+  const body = { action, acknowledgeFeeModelImpact: optionalBoolean(input.acknowledgeFeeModelImpact, "acknowledgeFeeModelImpact") };
+  if (action && HOLDER_ACTIONS.includes(action)) {
+    body.identityAddress = optionalWallet(input.identityAddress, "identityAddress");
+    body.country = optionalInt(input.country, "country", 0, 65535);
+    body.signerAddress = optionalWallet(input.signerAddress, "signerAddress");
+    if (input.claimSignatures !== void 0) {
+      if (!Array.isArray(input.claimSignatures) || input.claimSignatures.length > 10) throw new ValidationError("claimSignatures must list at most 10 signed claims");
+      body.claimSignatures = input.claimSignatures.map((c, i) => {
+        if (typeof c?.signature !== "string" || !CLAIM_SIGNATURE_RE.test(c.signature)) throw new ValidationError(`claimSignatures[${i}].signature must be a 65-byte hex signature`);
+        if (c.claimType !== void 0 && c.claimType !== null && (typeof c.claimType !== "string" || c.claimType.length > 66)) throw new ValidationError(`claimSignatures[${i}].claimType must be at most 66 characters`);
+        let issuedAt;
+        if (c.issuedAt !== void 0 && c.issuedAt !== null) {
+          const n = typeof c.issuedAt === "string" && /^\d+$/.test(c.issuedAt.trim()) ? Number(c.issuedAt.trim()) : c.issuedAt;
+          if (typeof n !== "number" || !Number.isSafeInteger(n) || n <= 0) throw new ValidationError(`claimSignatures[${i}].issuedAt must be the unix time in seconds the holder plan's message carried`);
+          issuedAt = n;
+        }
+        return compact({ walletAddress: requireWallet(c.walletAddress, `claimSignatures[${i}].walletAddress`), signature: c.signature, claimType: c.claimType ?? void 0, issuedAt });
+      });
+    }
+    if (input.identities !== void 0) {
+      const entries = Object.entries(input.identities ?? {});
+      if (entries.length > 4) throw new ValidationError("identities must map at most 4 wallets to their ONCHAINID");
+      body.identities = Object.fromEntries(entries.map(([w, id]) => [requireWallet(w, "identities wallet"), requireWallet(id, "identities identity")]));
+    }
+  } else if (input.signerAddress !== void 0 || input.identityAddress !== void 0 || input.country !== void 0 || input.claimSignatures !== void 0 || input.identities !== void 0) {
+    throw new ValidationError("identityAddress, country, signerAddress, claimSignatures and identities only apply to the verify*AsHolder actions");
+  }
+  return compact(body);
+}
+var LendingMarkets = class extends LendingArea {
+  path(marketId, rest = "") {
+    return `${LENDING_BASE}/markets/${enc(requireMarketId(marketId))}${rest ? `/${rest}` : ""}`;
+  }
+  async list(options = {}) {
+    return this.http.get(`${LENDING_BASE}/markets`, { includeOnChain: optionalBoolean(options.includeOnChain, "includeOnChain") ? "true" : void 0 });
+  }
+  async get(marketId) {
+    return this.http.get(this.path(marketId));
+  }
+  async metrics(marketId) {
+    return this.http.get(this.path(marketId, "metrics"));
+  }
+  async config(marketId) {
+    return this.http.get(this.path(marketId, "config"));
+  }
+  async supplyCaps(marketId) {
+    return this.http.get(this.path(marketId, "supply-caps"));
+  }
+  async maxBorrow(marketId, collateralAmount) {
+    return this.http.get(this.path(marketId, "max-borrow"), { collateralAmount: requireAmount(collateralAmount, "collateralAmount") });
+  }
+  async transactions(marketId, options = {}) {
+    return this.http.get(this.path(marketId, "transactions"), {
+      limit: clampInt(options.limit, 1, 200, 50),
+      offset: clampInt(options.offset, 0, Number.MAX_SAFE_INTEGER, 0)
+    });
+  }
+  async history(marketId, options = {}) {
+    return this.http.get(this.path(marketId, "history"), {
+      range: optionalOneOf(options.range, "range", HISTORY_RANGES),
+      resolution: optionalOneOf(options.resolution, "resolution", HISTORY_RESOLUTIONS)
+    });
+  }
+  async indexStatus(marketId) {
+    return this.http.get(this.path(marketId, "index-status"));
+  }
+  async lifecycleStatement(marketId, options = {}) {
+    let categories;
+    if (options.categories !== void 0) {
+      if (!Array.isArray(options.categories) || options.categories.length === 0) throw new ValidationError("categories must be a non-empty list");
+      categories = options.categories.map((c) => requireOneOf(c, "categories", STATEMENT_CATEGORIES)).join(",");
+    }
+    let loanId;
+    if (options.loanId !== void 0) {
+      loanId = String(options.loanId);
+      if (!/^\d{1,18}$/.test(loanId) || /^0+$/.test(loanId)) throw new ValidationError("loanId must be a positive whole number of at most 18 digits");
+    }
+    for (const [field, value] of [["from", options.from], ["to", options.to]]) {
+      if (value !== void 0 && (typeof value !== "string" || !DATE_RE.test(value))) throw new ValidationError(`${field} must be a date written as YYYY-MM-DD`);
+    }
+    return this.http.getBinary(this.path(marketId, "lifecycle-statement"), {
+      categories,
+      loanId,
+      from: options.from,
+      to: options.to,
+      allowStale: optionalBoolean(options.allowStale, "allowStale") ? "true" : void 0
+    }, { timeoutMs: DOCUMENT_TIMEOUT_MS });
+  }
+  async borrowAssets() {
+    return this.http.get(`${LENDING_BASE}/markets/borrow-assets`);
+  }
+  async savedStablecoins() {
+    return this.http.get("/instances/api/saved-stablecoins");
+  }
+  async forgetStablecoin(address) {
+    return this.http.delete(`/instances/api/saved-stablecoins/${requireWallet(address, "address")}`);
+  }
+  async deploymentOptions() {
+    return this.http.get(`${LENDING_BASE}/markets/deployment-options`);
+  }
+  async configurationStatus(marketId) {
+    return this.http.get(this.path(marketId, "configuration-status"));
+  }
+  async setupSteps(marketId) {
+    return this.http.get(this.path(marketId, "setup-steps"));
+  }
+  async upgradeStatus(marketId) {
+    return this.http.get(this.path(marketId, "upgrade"));
+  }
+  async guardians(marketId, address) {
+    return this.http.get(this.path(marketId, "guardians"), { address: optionalWallet(address, "address") });
+  }
+  async priceHalt(marketId) {
+    return this.http.get(this.path(marketId, "oracle-halt"));
+  }
+  async thresholdCooldown(marketId) {
+    return this.http.get(this.path(marketId, "threshold-cooldown"));
+  }
+  async setPriceHalt(marketId, input, options) {
+    const path = this.path(marketId, "oracle-halt");
+    const action = requireOneOf(input?.action, "action", PRICE_HALT_ACTIONS);
+    if (action === "lift" && input.durationSeconds !== void 0) throw new ValidationError("durationSeconds applies to a halt only; a lift ends the running halt");
+    const durationSeconds = action === "halt" ? requireInt(input.durationSeconds, "durationSeconds", 1, MAX_PRICE_HALT_SECONDS) : void 0;
+    const signerAddress2 = isSignOptions(options) ? await walletOf(options, void 0, "signerAddress") : void 0;
+    return this.twoLeg(options, {
+      build: () => this.http.post(path, compact({ action, durationSeconds, signerAddress: signerAddress2 }), BUILD),
+      confirm: (txHash) => this.http.post(path, { action, txHash }, CONFIRM),
+      check: async (prepared, signer) => {
+        if (prepared.requiredSigner && !sameAddress(prepared.requiredSigner, signer)) {
+          throw new ValidationError(`Lifting the price halt must be signed by the oracle owner ${prepared.requiredSigner}, but the signer is ${signer}. Nothing was signed`);
+        }
+      }
+    });
+  }
+  async setPaused(marketId, paused, options) {
+    const path = this.path(marketId, "pause-state");
+    const state = requireBoolean(paused, "paused");
+    const signerAddress2 = isSignOptions(options) ? await walletOf(options, void 0, "signerAddress") : void 0;
+    return this.twoLeg(options, {
+      build: () => this.http.post(path, compact({ paused: state, signerAddress: signerAddress2 }), BUILD),
+      confirm: (txHash) => this.http.post(path, { paused: state, txHash }, CONFIRM)
+    });
+  }
+  async identityGates(marketId) {
+    return this.http.get(this.path(marketId, "identity-gates"));
+  }
+  async deploy(input, options) {
+    const path = `${LENDING_BASE}/markets/deploy`;
+    if (isConfirmOptions(options)) {
+      const hints = input ?? {};
+      const fields = compact({
+        collateralTokenAddress: optionalWallet(hints.collateralTokenAddress, "collateralTokenAddress"),
+        mode: optionalOneOf(hints.mode, "mode", COLLATERAL_MODES),
+        priceSource: optionalOneOf(hints.priceSource, "priceSource", PRICE_SOURCES),
+        borrowAssetAddress: optionalWallet(hints.borrowAssetAddress, "borrowAssetAddress"),
+        identityRegistry: optionalWallet(hints.identityRegistry, "identityRegistry", { allowZero: true })
+      });
+      return this.http.post(path, { ...fields, txHash: requireTxHash(options.txHash) }, CONFIRM);
+    }
+    const body = deployBody(input);
+    return this.twoLeg(options, {
+      build: () => this.http.post(path, body, BUILD),
+      confirm: (txHash, prepared) => this.http.post(
+        path,
+        { ...deployConfirmFields(prepared?.confirmWith?.body ?? body), txHash },
+        CONFIRM
+      )
+    });
+  }
+  async updateConfig(marketId, config, options) {
+    const path = this.path(marketId, "config");
+    const validated = configBody(config);
+    if (isSignOptions(options)) {
+      await this.assertSignerHoldsAny(marketId, await walletOf(options, void 0, "signer"), ["MARKET_ISSUER"]);
+    }
+    return this.twoLeg(options, {
+      build: () => this.http.post(path, { config: validated }, BUILD),
+      confirm: (txHash) => this.http.post(path, { config: validated, txHash }, CONFIRM)
+    });
+  }
+  async configure(marketId, input, options) {
+    assertInputIsNotOptions(input, "configure(marketId, { action }, { signer })");
+    const buildPath = this.path(marketId, "configure");
+    const confirmPath = this.path(marketId, "confirm-configuration");
+    const confirm = (txHash, action) => this.http.post(confirmPath, compact({ txHash, action }), CONFIRM);
+    if (isConfirmOptions(options)) {
+      const action = optionalOneOf(input?.action, "action", CONFIGURE_ACTIONS);
+      return confirm(requireTxHash(options.txHash), action);
+    }
+    const full = { ...input ?? {} };
+    if (!isSignOptions(options)) {
+      return this.http.post(buildPath, configureBody(full), BUILD);
+    }
+    if (!full.action) {
+      throw new ValidationError("Pass an action to configure with a signer: without one the API lists every outstanding step, and each step is signed by its own authority");
+    }
+    if (HOLDER_ACTIONS.includes(full.action)) {
+      full.signerAddress = await walletOf(options, full.signerAddress ? requireWallet(full.signerAddress, "signerAddress") : void 0, "signerAddress");
+    }
+    await preflightChain(this.ctx, options);
+    const prepared = await this.http.post(buildPath, configureBody(full), BUILD);
+    if (prepared.holderPlan) {
+      throw new ValidationError(`The ${full.action} step needs a holder onboarding plan (${prepared.holderPlan.phase}), which signs claims and registers identities on the token's registry. Prepare it without a signer and run the plan from the onboarding wallet; confirm the registration with configure(marketId, { action }, { txHash })`);
+    }
+    const entries = Object.entries(prepared.configurationCalldata ?? {});
+    if (entries.length === 0) return attachTransactions(prepared, []);
+    const transactions = [];
+    let result = null;
+    for (const [key, entry] of entries) {
+      const plan = planOf(entry, { confirmIndex: 0 });
+      if (!plan) throw new ValidationError(`The ${key} step carries no transaction the SDK can sign`);
+      const executed = await execute(this.ctx, plan, options);
+      const action = key === "pokeSnapshot" ? "upgradeMarket" : key;
+      const confirmed = await confirmExecuted({ transactions: [...transactions, ...executed.transactions], confirmHash: executed.confirmHash }, (txHash) => confirm(txHash, action));
+      transactions.push(...executed.transactions);
+      result = confirmed;
+    }
+    return attachTransactions(result, transactions);
+  }
+  async upgrade(marketId, input = {}, options) {
+    assertInputIsNotOptions(input, "upgrade(marketId, {}, { signer })");
+    const path = this.path(marketId, "upgrade");
+    const target = optionalOneOf(input?.target, "target", UPGRADE_TARGETS) ?? "market";
+    const action = optionalOneOf(input?.action, "action", UPGRADE_ACTIONS);
+    const acknowledgeFeeModelImpact = optionalBoolean(input?.acknowledgeFeeModelImpact, "acknowledgeFeeModelImpact");
+    return this.twoLeg(options, {
+      build: () => this.http.post(path, compact({ target, action, acknowledgeFeeModelImpact }), BUILD),
+      confirm: async (txHash, prepared) => {
+        const signed = prepared?.upgradeAction ?? action ?? "execute";
+        const confirmed = await this.http.post(path, { txHash, target, action: signed }, CONFIRM);
+        if (!prepared || signed !== "execute") return confirmed;
+        return { ...confirmed, ...compact({ pokeSnapshot: prepared.pokeSnapshot, followUps: prepared.followUps }) };
+      }
+    });
+  }
+  async setIdentityGates(marketId, input, options) {
+    const path = this.path(marketId, "identity-gates");
+    const attest = optionalBoolean(input?.attestIdentifiedMembers, "attestIdentifiedMembers");
+    if (isConfirmOptions(options)) {
+      return this.http.post(path, compact({ txHash: requireTxHash(options.txHash), attestIdentifiedMembers: attest }), CONFIRM);
+    }
+    const body = identityGatesBody(input);
+    return this.twoLeg(options, {
+      build: () => this.http.post(path, body, BUILD),
+      confirm: (txHash, prepared) => this.http.post(
+        path,
+        compact({ txHash, attestIdentifiedMembers: attest === true || prepared?.attestedIdentifiedMembers === true ? true : void 0 }),
+        CONFIRM
+      )
+    });
+  }
+};
+
+// src/modules/lending/operators.ts
+var ROLE_KEYS = ["MARKET_ADMIN", "MARKET_ISSUER", "MARKET_LIQUIDATOR", "MARKET_GUARDIAN", "ROUTER_ADMIN", "ROUTER_OPERATOR", "ORACLE_SIGNER"];
+var HANDOVER_SCOPES = ["market", "router", "both"];
+var ROLE_ACTIONS = ["grant", "revoke"];
+var REALIZATION_MODES = ["EXCHANGE_SALE", "ISSUER_REDEMPTION", "AUCTION"];
+var BYTES32_RE = /^0x[0-9a-fA-F]{64}$/;
+var COMMITMENT_RE = /^\d+(\.\d{1,18})?$/;
+function optionalBytes32(value, field) {
+  if (value === void 0 || value === null) return void 0;
+  if (typeof value !== "string" || !BYTES32_RE.test(value)) throw new ValidationError(`${field} must be a 32-byte hex value: 0x followed by 64 hex characters`);
+  return value;
+}
+function termsBody(terms) {
+  if (!terms || typeof terms !== "object") throw new ValidationError("accept needs the curator terms");
+  let liquidityCommitment;
+  if (terms.liquidityCommitment !== void 0) {
+    liquidityCommitment = requireAmount(terms.liquidityCommitment, "liquidityCommitment", { allowZero: true });
+    if (!COMMITMENT_RE.test(liquidityCommitment)) throw new ValidationError("liquidityCommitment must have at most 18 decimal places");
+  }
+  return compact({
+    admin: requireWallet(terms.admin, "admin"),
+    issuer: requireWallet(terms.issuer, "issuer"),
+    collateralAgent: requireWallet(terms.collateralAgent, "collateralAgent"),
+    saleRecipient: requireWallet(terms.saleRecipient, "saleRecipient"),
+    liquidationOperator: requireWallet(terms.liquidationOperator, "liquidationOperator"),
+    oracleOwner: requireWallet(terms.oracleOwner, "oracleOwner"),
+    priceSigner: requireWallet(terms.priceSigner, "priceSigner"),
+    realizationMode: requireOneOf(terms.realizationMode, "realizationMode", REALIZATION_MODES),
+    identityRegistry: optionalRegister(terms.identityRegistry, "identityRegistry"),
+    providerRegistry: optionalRegister(terms.providerRegistry, "providerRegistry"),
+    liquidator: optionalRegister(terms.liquidator, "liquidator"),
+    vault: optionalRegister(terms.vault, "vault"),
+    liquidityCommitment,
+    maxFixedRateBps: optionalInt(terms.maxFixedRateBps, "maxFixedRateBps", 1, 5e4),
+    claimSalt: optionalBytes32(terms.claimSalt, "claimSalt"),
+    identityRegistryProfile: optionalProfileKey(terms.identityRegistryProfile, "identityRegistryProfile"),
+    providerRegistryProfile: optionalProfileKey(terms.providerRegistryProfile, "providerRegistryProfile"),
+    identityRegistryAccessList: optionalAccessListId(terms.identityRegistryAccessList, "identityRegistryAccessList"),
+    providerRegistryAccessList: optionalAccessListId(terms.providerRegistryAccessList, "providerRegistryAccessList"),
+    attestIdentifiedMembers: optionalBoolean(terms.attestIdentifiedMembers, "attestIdentifiedMembers"),
+    assetDataHash: optionalBytes32(terms.assetDataHash, "assetDataHash"),
+    acknowledgeAssetData: optionalBoolean(terms.acknowledgeAssetData, "acknowledgeAssetData")
+  });
+}
+var ROLE_AUTHORITY = {
+  MARKET_ADMIN: "MARKET_ADMIN",
+  MARKET_ISSUER: "MARKET_ADMIN",
+  MARKET_LIQUIDATOR: "MARKET_ADMIN",
+  MARKET_GUARDIAN: "MARKET_ADMIN",
+  ROUTER_ADMIN: "ROUTER_ADMIN",
+  ROUTER_OPERATOR: "ROUTER_ADMIN",
+  ORACLE_SIGNER: "ORACLE_OWNER"
+};
+async function assertSignerIs(options, expected, label2) {
+  if (typeof expected !== "string") return;
+  const actual = await signerAddress(requireSigner(options.signer));
+  if (!sameAddress(actual, expected)) {
+    throw new ValidationError(`This transaction must be signed by ${expected} (${label2}), but the signer is ${actual}. Nothing was signed`);
+  }
+}
+var LendingOperators = class extends LendingArea {
+  marketPath(marketId, rest) {
+    return `${LENDING_BASE}/markets/${enc(requireMarketId(marketId))}/${rest}`;
+  }
+  queuedPath(marketAddress, rest) {
+    return `${LENDING_BASE}/markets/queued/${requireWallet(marketAddress, "marketAddress")}/${rest}`;
+  }
+  async pending(options = {}) {
+    return this.http.get(`${LENDING_BASE}/markets/queue/pending`, {
+      offset: clampInt(options.offset, 0, Number.MAX_SAFE_INTEGER, 0),
+      limit: clampInt(options.limit, 1, 100, 25)
+    });
+  }
+  async queued() {
+    return this.http.get(`${LENDING_BASE}/markets/queued`);
+  }
+  async queuedMarket(marketAddress) {
+    return this.http.get(this.queuedPath(marketAddress, "details"));
+  }
+  async operator(marketId) {
+    return this.http.get(this.marketPath(marketId, "operator"));
+  }
+  async handover(marketId) {
+    return this.http.get(this.marketPath(marketId, "handover"));
+  }
+  async nominations(marketId) {
+    return this.http.get(this.marketPath(marketId, "nominations"));
+  }
+  async adminHandover(marketId, input) {
+    return this.http.post(this.marketPath(marketId, "admin-handover"), compact({
+      successor: requireWallet(input?.successor, "successor"),
+      scope: optionalOneOf(input?.scope, "scope", HANDOVER_SCOPES),
+      signerAddress: optionalWallet(input?.signerAddress, "signerAddress")
+    }), BUILD);
+  }
+  async accessRole(marketId, address, role) {
+    return this.http.get(this.marketPath(marketId, `access-role/${requireWallet(address, "address")}`), {
+      role: requireOneOf(role, "role", ROLE_KEYS)
+    });
+  }
+  async accept(marketAddress, terms, options) {
+    const acceptPath = this.queuedPath(marketAddress, "accept");
+    const confirmPath = this.queuedPath(marketAddress, "confirm-accept");
+    const attest = optionalBoolean(terms?.attestIdentifiedMembers, "attestIdentifiedMembers");
+    const confirm = (txHash, adoptionAttested2) => this.http.post(
+      confirmPath,
+      compact({ txHash, attestIdentifiedMembers: attest === true || adoptionAttested2 ? true : void 0 }),
+      CONFIRM
+    );
+    if (isConfirmOptions(options)) return confirm(requireTxHash(options.txHash), false);
+    const body = termsBody(terms);
+    if (!isSignOptions(options)) return this.http.post(acceptPath, body, BUILD);
+    await preflightChain(this.ctx, options);
+    const prepared = await this.http.post(acceptPath, body, BUILD);
+    await assertSignerIs(options, prepared.signer, prepared.functionName === "commitCuratorClaim" ? "the wallet the claim commitment names" : "the nominated wallet that takes the lender role");
+    const plan = planOf(prepared, { confirmIndex: 0 });
+    if (!plan) throw new TrussetError("The acceptance build returned no transaction to sign", "NOTHING_TO_SIGN", 0);
+    if ("claimFlow" in prepared && prepared.claimFlow === true) {
+      const executed2 = await execute(this.ctx, plan, options);
+      return {
+        status: "CLAIM_COMMITTED",
+        marketAddress: prepared.marketAddress,
+        signer: prepared.signer,
+        commitment: prepared.commitment,
+        claimSalt: prepared.claimSalt,
+        claimDelaySeconds: prepared.claimDelaySeconds,
+        claimWindowSeconds: prepared.claimWindowSeconds,
+        transactions: executed2.transactions
+      };
+    }
+    const adoption = prepared;
+    const adoptionAttested = adoption.attestedIdentifiedMembers === true;
+    const executed = await execute(this.ctx, plan, options);
+    return confirmExecuted(executed, async (txHash) => ({
+      ...await confirm(txHash, adoptionAttested),
+      ...compact({ warnings: adoption.warnings, requiredFollowUp: adoption.requiredFollowUp })
+    }));
+  }
+  async nominate(marketId, candidate, options) {
+    return this.nomination(this.marketPath(marketId, "nominations"), candidate, options);
+  }
+  async withdrawNomination(marketId, candidate, options) {
+    return this.nomination(this.marketPath(marketId, "nominations/withdraw"), candidate, options);
+  }
+  async setAccessRole(marketId, input, options) {
+    const body = {
+      address: requireWallet(input?.address, "address"),
+      action: requireOneOf(input?.action, "action", ROLE_ACTIONS),
+      role: requireOneOf(input?.role, "role", ROLE_KEYS)
+    };
+    return this.roleChange(marketId, this.marketPath(marketId, "access-role"), body, ROLE_AUTHORITY[body.role], options);
+  }
+  async setLiquidatorRole(marketId, input, options) {
+    const body = {
+      address: requireWallet(input?.address, "address"),
+      action: requireOneOf(input?.action, "action", ROLE_ACTIONS)
+    };
+    return this.roleChange(marketId, this.marketPath(marketId, "liquidator-role"), body, "MARKET_ADMIN", options);
+  }
+  async nomination(path, candidate, options) {
+    const body = { candidate: requireWallet(candidate, "candidate") };
+    if (options === void 0) return this.http.post(path, body, BUILD);
+    if (isConfirmOptions(options)) {
+      throw new ValidationError("Nominations have no confirm leg: the factory records them, and nominations() reads them back from the chain");
+    }
+    if (!isSignOptions(options)) throw new ValidationError("Pass { signer } to sign, or no options to get the unsigned transaction");
+    await preflightChain(this.ctx, options);
+    const prepared = await this.http.post(path, body, BUILD);
+    await assertSignerIs(options, prepared.signer, "the market's deployer or the factory owner");
+    const plan = planOf(prepared, { confirmIndex: null });
+    if (!plan) throw new TrussetError("The nomination build returned no transaction to sign", "NOTHING_TO_SIGN", 0);
+    const executed = await execute(this.ctx, plan, options);
+    return { transactions: executed.transactions };
+  }
+  async roleChange(marketId, path, body, authority, options) {
+    const confirm = (txHash) => this.http.post(path, { ...body, txHash }, CONFIRM);
+    if (isConfirmOptions(options)) return confirm(requireTxHash(options.txHash));
+    if (!isSignOptions(options)) return this.http.post(path, body, BUILD);
+    await preflightChain(this.ctx, options);
+    const prepared = await this.http.post(path, body, BUILD);
+    if ("unchanged" in prepared && prepared.unchanged === true) return attachTransactions(prepared, []);
+    if (authority === "ORACLE_OWNER") {
+      await assertSignerIs(options, prepared.requiredSigner?.wallet, "the oracle owner");
+    } else {
+      await this.assertSignerRoles(marketId, await signerAddress(requireSigner(options.signer)), [authority]);
+    }
+    const plan = planOf(prepared, { confirmIndex: 0 });
+    if (!plan) throw new TrussetError("The role build returned no transaction to sign", "NOTHING_TO_SIGN", 0);
+    const executed = await execute(this.ctx, plan, options);
+    return confirmExecuted(executed, confirm);
+  }
+};
+
+// src/modules/lending/rates.ts
+var RATE_MODES2 = ["CURVE", "CLAMPED", "FIXED"];
+var EXTENSION_KINDS = ["LOAN", "BATCH", "FLOOR"];
+var ROLE_READS = {
+  ISSUER_ROLE: ["MARKET_ISSUER"],
+  DEFAULT_ADMIN_ROLE: ["MARKET_ADMIN"],
+  ISSUER_OR_ADMIN: ["MARKET_ISSUER", "MARKET_ADMIN"]
+};
+async function requireSignerIs(options, required, role) {
+  if (!required) return;
+  const address = await signerAddress(requireSigner(options.signer));
+  if (!sameAddress(address, required)) {
+    throw new ValidationError(`This transaction must be sent by ${required} (${role}), but the signer is ${address}. Nothing was signed: hand the prepared transaction to that wallet, or sign with it`);
+  }
+}
+function checkRateOffering(input) {
+  const rateMode = requireOneOf(input.rateMode, "rateMode", RATE_MODES2);
+  const rateFloorBps = optionalInt(input.rateFloorBps, "rateFloorBps", 0, 5e4);
+  const rateCapBps = optionalInt(input.rateCapBps, "rateCapBps", 1, 5e4);
+  const fixedRateBps = optionalInt(input.fixedRateBps, "fixedRateBps", 1, 5e4);
+  if (rateMode === "FIXED") {
+    if (fixedRateBps === void 0) throw new ValidationError("A FIXED rate mode requires fixedRateBps");
+    if (rateFloorBps !== void 0 || rateCapBps !== void 0) throw new ValidationError("A FIXED rate mode takes fixedRateBps only; rateFloorBps and rateCapBps belong to CLAMPED");
+  }
+  if (rateMode === "CLAMPED") {
+    if (rateCapBps === void 0) throw new ValidationError("A CLAMPED rate mode requires rateCapBps");
+    if (fixedRateBps !== void 0) throw new ValidationError("A CLAMPED rate mode takes rateFloorBps and rateCapBps only; fixedRateBps belongs to FIXED");
+    if (rateFloorBps !== void 0 && rateFloorBps > rateCapBps) throw new ValidationError("A CLAMPED cap must be at least the floor");
+  }
+  if (rateMode === "CURVE" && (rateFloorBps !== void 0 || rateCapBps !== void 0 || fixedRateBps !== void 0)) {
+    throw new ValidationError("Rate bounds need a rateMode of CLAMPED or FIXED; the CURVE default takes none");
+  }
+  return compact({ rateMode, rateFloorBps, rateCapBps, fixedRateBps });
+}
+function checkTermConfig(input) {
+  const maxLoanDurationDays = requireInt(input.maxLoanDurationDays, "maxLoanDurationDays", 0, 3650);
+  const termGracePeriodDays = optionalInt(input.termGracePeriodDays, "termGracePeriodDays", 1, 30);
+  const termPenaltyBps = optionalInt(input.termPenaltyBps, "termPenaltyBps", 0, 5e4);
+  let terminalDueDate;
+  if (input.terminalDueDate !== void 0 && input.terminalDueDate !== null) {
+    terminalDueDate = typeof input.terminalDueDate === "number" ? requireInt(input.terminalDueDate, "terminalDueDate", 1, Number.MAX_SAFE_INTEGER) : requireString(input.terminalDueDate, "terminalDueDate");
+  }
+  return compact({ maxLoanDurationDays, termGracePeriodDays, terminalDueDate, termPenaltyBps });
+}
+function checkNewDueAt(value) {
+  if (typeof value === "number") return requireInt(value, "newDueAt", 1, Number.MAX_SAFE_INTEGER);
+  if (typeof value === "string" && /^\d+$/.test(value.trim()) && Number(value.trim()) > 0) return value.trim();
+  throw new ValidationError("newDueAt must be a unix timestamp in seconds");
+}
+function checkProposalId(value) {
+  if (typeof value === "number" && Number.isSafeInteger(value) && value >= 0) return String(value);
+  if (typeof value === "string" && /^\d+$/.test(value.trim())) return value.trim();
+  throw new ValidationError("proposalId must be the whole-number proposal id from extensions()");
+}
+var LendingRates = class extends LendingArea {
+  path(marketId, rest) {
+    return `${LENDING_BASE}/markets/${enc(requireMarketId(marketId))}/${rest}`;
+  }
+  async rateMode(marketId) {
+    return this.http.get(this.path(marketId, "rate-mode"));
+  }
+  async termConfig(marketId) {
+    return this.http.get(this.path(marketId, "term-config"));
+  }
+  async exitLiquidity(marketId) {
+    return this.http.get(this.path(marketId, "exit-liquidity"));
+  }
+  async extensions(marketId) {
+    return this.http.get(this.path(marketId, "extensions"));
+  }
+  async setRateMode(marketId, input, options) {
+    return this.offering(marketId, "rate-mode", options, () => checkRateOffering(input), "the interest model owner");
+  }
+  async setMaxFixedRate(marketId, maxFixedRateBps, options) {
+    return this.offering(marketId, "max-fixed-rate", options, () => ({ maxFixedRateBps: requireInt(maxFixedRateBps, "maxFixedRateBps", 1, 5e4) }), "the interest model owner");
+  }
+  async setTermConfig(marketId, input, options) {
+    return this.offering(marketId, "term-config", options, () => checkTermConfig(input), "the market issuer");
+  }
+  async setAllowExtension(marketId, allowed, options) {
+    return this.offering(marketId, "allow-extension", options, () => ({ allowed: requireBoolean(allowed, "allowed") }), "the market admin");
+  }
+  async setReserveRatio(marketId, reserveRatioBps, options) {
+    return this.offering(marketId, "reserve-ratio", options, () => ({ reserveRatioBps: requireInt(reserveRatioBps, "reserveRatioBps", 0, 5e3) }), "the market issuer");
+  }
+  async proposeExtension(marketId, input, options) {
+    return this.extension(marketId, "extensions", options, () => {
+      const full = input;
+      const kind = requireOneOf(full.kind, "kind", EXTENSION_KINDS);
+      const loanId = full.loanId === void 0 || full.loanId === null ? void 0 : requirePositiveId(full.loanId, "loanId");
+      if (kind === "LOAN" && loanId === void 0) throw new ValidationError("A LOAN extension needs loanId");
+      if (kind !== "LOAN" && loanId !== void 0) throw new ValidationError(`A ${kind} extension takes no loanId`);
+      return compact({ kind, loanId, newDueAt: checkNewDueAt(full.newDueAt) });
+    });
+  }
+  async confirmExtension(marketId, proposalId, options) {
+    return this.extensionAction(marketId, proposalId, "confirm", void 0, options);
+  }
+  async applyExtension(marketId, proposalId, loanIds, options) {
+    return this.extensionAction(marketId, proposalId, "apply", loanIds ?? void 0, options);
+  }
+  async cancelExtension(marketId, proposalId, options) {
+    return this.extensionAction(marketId, proposalId, "cancel", void 0, options);
+  }
+  async checkSigner(marketId, options, prepared, label2) {
+    if (prepared.requiredSigner) return requireSignerIs(options, prepared.requiredSigner, label2);
+    const roles = prepared.requiredRole ? ROLE_READS[prepared.requiredRole] : void 0;
+    if (roles) return this.assertSignerHoldsAny(marketId, await signerAddress(requireSigner(options.signer)), roles);
+    if (prepared.requiredRole === "INTEREST_MODEL_OWNER") {
+      throw new TrussetError("The interest model owner could not be read just now, so nothing was signed. Retry shortly", "ROLE_UNREADABLE", 503);
+    }
+  }
+  async offering(marketId, route, options, body, role) {
+    const path = this.path(marketId, route);
+    const confirm = (txHash) => this.http.post(path, { txHash }, CONFIRM);
+    const built = options !== void 0 && !isSignOptions(options) ? null : body();
+    return this.twoLeg(options, {
+      build: async () => {
+        const prepared = await this.http.post(path, built, BUILD);
+        if (isSignOptions(options)) await this.checkSigner(marketId, options, prepared, role);
+        return prepared;
+      },
+      confirm
+    });
+  }
+  async extension(marketId, route, options, body) {
+    const path = this.path(marketId, route);
+    const confirmPath = this.path(marketId, "extensions/confirm-tx");
+    const built = options !== void 0 && !isSignOptions(options) ? null : body();
+    return this.twoLeg(options, {
+      build: async () => {
+        const prepared = await this.http.post(path, built, BUILD);
+        if (isSignOptions(options)) await this.checkSigner(marketId, options, prepared, "the role this step needs");
+        return prepared;
+      },
+      confirm: (txHash) => this.http.post(confirmPath, { txHash }, CONFIRM)
+    });
+  }
+  async extensionAction(marketId, proposalId, action, loanIds, options) {
+    const confirming = options !== void 0 && !isSignOptions(options);
+    const route = confirming ? "extensions" : `extensions/${checkProposalId(proposalId)}/${action}`;
+    return this.extension(marketId, route, options, () => {
+      if (action !== "apply") return {};
+      if (!Array.isArray(loanIds) || loanIds.length === 0 || loanIds.length > 200) {
+        throw new ValidationError("applyExtension needs 1 to 200 loanIds per page");
+      }
+      return { loanIds: loanIds.map((id, i) => requirePositiveId(id, `loanIds[${i}]`)) };
+    });
+  }
+};
+
+// src/modules/lending/asset-data.ts
+var MODES = ["FREEZE", "CUSTODY"];
+var PRICE_SOURCES2 = ["MARKET", "NAV", "ORACLE", "FIXED"];
+var ZERO_HASH = `0x${"0".repeat(64)}`;
+function checkInitialPrice(value) {
+  if (value === void 0 || value === null) return void 0;
+  if (typeof value !== "string" || !/^\d+(\.\d{1,18})?$/.test(value.trim()) || !/[1-9]/.test(value)) {
+    throw new ValidationError("initialPrice must be a positive decimal string with at most 18 decimal places");
+  }
+  return value.trim();
+}
+var LendingAssetData = class extends LendingArea {
+  path(marketAddress, rest) {
+    return `${LENDING_BASE}/markets/${requireWallet(marketAddress, "marketAddress")}/asset-data${rest}`;
+  }
+  async preview(input) {
+    return this.http.get(`${LENDING_BASE}/markets/asset-data/preview`, {
+      collateralTokenAddress: requireWallet(input?.collateralTokenAddress, "collateralTokenAddress"),
+      mode: optionalOneOf(input.mode, "mode", MODES),
+      priceSource: optionalOneOf(input.priceSource, "priceSource", PRICE_SOURCES2),
+      initialPrice: checkInitialPrice(input.initialPrice),
+      borrowAssetAddress: optionalWallet(input.borrowAssetAddress, "borrowAssetAddress")
+    });
+  }
+  async get(marketAddress) {
+    return this.http.get(this.path(marketAddress, ""));
+  }
+  async bundle(marketAddress, options = {}) {
+    const hash = options.hash === void 0 ? void 0 : requireHash(options.hash, "hash");
+    return this.http.get(this.path(marketAddress, "/bundle"), { hash });
+  }
+  async attest(marketAddress, options) {
+    const buildPath = this.path(marketAddress, "/attest");
+    const confirmPath = this.path(marketAddress, "/attest/confirm");
+    return this.twoLeg(options, {
+      build: async () => {
+        const prepared = await this.http.post(buildPath, {}, BUILD);
+        if (isSignOptions(options)) await requireSignerIs(options, prepared.signer, "the asset data attestor");
+        return prepared;
+      },
+      confirm: (txHash) => this.http.post(confirmPath, { txHash }, CONFIRM)
+    });
+  }
+  async acknowledge(marketAddress, contentHash, options) {
+    const buildPath = this.path(marketAddress, "/acknowledge");
+    const confirmPath = this.path(marketAddress, "/acknowledge/confirm");
+    const confirming = options !== void 0 && !isSignOptions(options);
+    let hash = null;
+    if (!confirming) {
+      hash = requireHash(contentHash, "contentHash");
+      if (hash.toLowerCase() === ZERO_HASH) throw new ValidationError("contentHash must be the hash of the asset data version you reviewed, not the zero hash");
+    }
+    return this.twoLeg(options, {
+      build: () => this.http.post(buildPath, { contentHash: hash }, BUILD),
+      confirm: (txHash) => this.http.post(confirmPath, { txHash }, CONFIRM)
+    });
+  }
+};
+
+// src/modules/lending/access-lists.ts
+var PURPOSES = ["BORROWER", "DEPOSITOR", "ANY"];
+var LIST_ID_RE = /^[A-Za-z0-9_-]{1,64}$/;
+var MAX_BATCH = 200;
+var MAX_ACCOUNTS = 2e3;
+var MAX_LIVE_WALLETS = 200;
+function listName(value) {
+  const name = requireString(value, "name");
+  if (name.length < 3 || name.length > 64) throw new ValidationError("name must be 3 to 64 characters");
+  return name;
+}
+function wallets(value, field, max, min = 0) {
+  if (value === void 0 && min === 0) return [];
+  if (!Array.isArray(value)) throw new ValidationError(`${field} must be an array of wallet addresses`);
+  if (value.length < min) throw new ValidationError(`${field} must name at least ${min} wallet`);
+  if (value.length > max) throw new ValidationError(`${field} takes at most ${max} wallets per request`);
+  return value.map((entry, index) => requireWallet(entry, `${field}[${index}]`));
+}
+function withoutTransactions(value) {
+  const copy = { ...value };
+  delete copy.transactions;
+  return copy;
+}
+var LendingAccessLists = class extends LendingArea {
+  path(listId, rest = "") {
+    const base = `${LENDING_BASE}/access-lists`;
+    if (listId === void 0) return rest ? `${base}/${rest}` : base;
+    const id = requireString(listId, "listId");
+    if (!LIST_ID_RE.test(id)) throw new ValidationError("listId must be the whitelist id the API returned (letters, digits, underscores and hyphens, at most 64 characters)");
+    return rest ? `${base}/${enc(id)}/${rest}` : `${base}/${enc(id)}`;
+  }
+  async list(options = {}) {
+    return this.http.get(this.path(), { includeArchived: optionalBoolean(options.includeArchived, "includeArchived") ? "true" : void 0 });
+  }
+  async get(listId, options = {}) {
+    const live = options.wallets === void 0 ? void 0 : wallets(options.wallets, "wallets", MAX_LIVE_WALLETS);
+    return this.http.get(this.path(listId), { wallets: live === void 0 ? void 0 : live.join(",") });
+  }
+  async create(input, options) {
+    const name = listName(input?.name);
+    const purpose = optionalOneOf(input?.purpose, "purpose", PURPOSES);
+    const confirm = (txHash) => this.http.post(this.path(void 0, "confirm-create"), compact({ txHash, name, purpose }), CONFIRM);
+    if (isConfirmOptions(options)) return confirm(requireTxHash(options.txHash));
+    const full = input;
+    const body = {
+      name,
+      purpose,
+      managers: full.managers === void 0 ? void 0 : wallets(full.managers, "managers", MAX_BATCH),
+      members: full.members === void 0 ? void 0 : wallets(full.members, "members", MAX_BATCH),
+      signerAddress: optionalWallet(full.signerAddress, "signerAddress")
+    };
+    if (isSignOptions(options)) body.signerAddress = await walletOf(options, body.signerAddress, "signerAddress");
+    return this.twoLeg(options, {
+      build: () => this.http.post(this.path(), compact(body), BUILD),
+      confirm
+    });
+  }
+  async setMembers(listId, input, options) {
+    const confirmPath = this.path(listId, "members/confirm");
+    const confirm = (txHash) => this.http.post(confirmPath, { txHash }, CONFIRM);
+    if (isConfirmOptions(options)) return confirm(requireTxHash(options.txHash));
+    const body = {
+      accounts: wallets(input?.accounts, "accounts", MAX_ACCOUNTS, 1),
+      listed: requireBoolean(input?.listed, "listed"),
+      signerAddress: optionalWallet(input?.signerAddress, "signerAddress")
+    };
+    const build = () => this.http.post(this.path(listId, "members"), compact(body), BUILD);
+    if (!isSignOptions(options)) return build();
+    body.signerAddress = await walletOf(options, body.signerAddress, "signerAddress");
+    await preflightChain(this.ctx, options);
+    const prepared = await build();
+    const units = prepared.action === "SIGN_TRANSACTIONS" ? prepared.steps : [prepared];
+    const transactions = [];
+    const confirmations = [];
+    for (const unit of units) {
+      const plan = planOf(unit);
+      if (!plan) throw new ValidationError("A step of the whitelist plan carries no transaction to sign");
+      try {
+        const executed = await execute(this.ctx, plan, options);
+        const confirmed = await confirmExecuted(executed, confirm);
+        transactions.push(...executed.transactions);
+        confirmations.push(withoutTransactions(confirmed));
+      } catch (err) {
+        if (transactions.length === 0) throw err;
+        const failed = err instanceof ConfirmationError ? err.transactions : [];
+        throw new ConfirmationError(
+          `The whitelist update stopped after ${confirmations.length} of ${units.length} confirmed transactions: ${err instanceof Error ? err.message : String(err)}. Confirm any listed hash with { txHash }, or rescan the list`,
+          err instanceof ConfirmationError ? err.code : "TRANSACTION_FAILED",
+          [...transactions, ...failed],
+          err instanceof ConfirmationError ? err.txHash : null,
+          err
+        );
+      }
+    }
+    return { confirmations, transactions };
+  }
+  async setManager(listId, input, options) {
+    const confirmPath = this.path(listId, "managers/confirm");
+    const confirm = (txHash) => this.http.post(confirmPath, { txHash }, CONFIRM);
+    if (isConfirmOptions(options)) return confirm(requireTxHash(options.txHash));
+    const body = {
+      account: requireWallet(input?.account, "account"),
+      enabled: requireBoolean(input?.enabled, "enabled"),
+      signerAddress: optionalWallet(input?.signerAddress, "signerAddress")
+    };
+    if (isSignOptions(options)) body.signerAddress = await walletOf(options, body.signerAddress, "signerAddress");
+    return this.twoLeg(options, {
+      build: () => this.http.post(this.path(listId, "managers"), compact(body), BUILD),
+      confirm
+    });
+  }
+  async transferOwnership(listId, newOwner, input, options) {
+    assertInputIsNotOptions(input, "transferOwnership(listId, newOwner, {}, { signer })");
+    if (isConfirmOptions(options)) return this.ownerLeg(listId, {}, options);
+    return this.ownerLeg(listId, { newOwner: requireWallet(newOwner, "newOwner"), signerAddress: optionalWallet(input?.signerAddress, "signerAddress") }, options);
+  }
+  async acceptOwnership(listId, input, options) {
+    assertInputIsNotOptions(input, "acceptOwnership(listId, {}, { signer })");
+    if (isConfirmOptions(options)) return this.ownerLeg(listId, {}, options);
+    return this.ownerLeg(listId, { accept: true, signerAddress: optionalWallet(input?.signerAddress, "signerAddress") }, options);
+  }
+  async rescan(listId) {
+    return this.http.post(this.path(listId, "rescan"), void 0, BUILD);
+  }
+  async update(listId, input) {
+    const body = compact({
+      name: input?.name === void 0 ? void 0 : listName(input.name),
+      purpose: optionalOneOf(input?.purpose, "purpose", PURPOSES),
+      archived: optionalBoolean(input?.archived, "archived")
+    });
+    if (Object.keys(body).length === 0) throw new ValidationError("Send a new name, a purpose or an archived flag");
+    return this.http.patch(this.path(listId), body, BUILD);
+  }
+  async ownerLeg(listId, fields, options) {
+    const confirmPath = this.path(listId, "owner/confirm");
+    const confirm = (txHash) => this.http.post(confirmPath, { txHash }, CONFIRM);
+    if (isConfirmOptions(options)) return confirm(requireTxHash(options.txHash));
+    const body = { ...fields };
+    if (isSignOptions(options)) body.signerAddress = await walletOf(options, body.signerAddress, "signerAddress");
+    return this.twoLeg(options, {
+      build: () => this.http.post(this.path(listId, "owner"), compact(body), BUILD),
+      confirm
+    });
+  }
+};
+
+// src/modules/lending/terms.ts
+var TERMS_FORMATS = ["markdown", "html"];
+var EXPORT_FORMATS = ["pdf", "text", "markdown"];
+var MAX_CONTENT = 262144;
+var CONTROL_CHARS = /[\u0000-\u0008\u000B\u000C\u000E-\u001F\u007F]/;
+var LendingTerms = class extends LendingArea {
+  path(marketId, rest) {
+    return `${LENDING_BASE}/markets/${enc(requireMarketId(marketId))}/${rest}`;
+  }
+  async get(marketId, options = {}) {
+    return this.http.get(this.path(marketId, "terms"), { format: optionalOneOf(options.format, "format", TERMS_FORMATS) });
+  }
+  async versions(marketId, options = {}) {
+    return this.http.get(this.path(marketId, "terms/versions"), { limit: options.limit === void 0 ? void 0 : clampInt(options.limit, 1, 100, 25) });
+  }
+  async version(marketId, version, options = {}) {
+    const v = String(version).trim();
+    if (!/^\d{1,6}$/.test(v)) throw new ValidationError("version must be a whole number of at most 6 digits");
+    return this.http.get(this.path(marketId, `terms/versions/${v}`), { format: optionalOneOf(options.format, "format", TERMS_FORMATS) });
+  }
+  async save(marketId, input) {
+    const content = input.content === void 0 ? void 0 : requireString(input.content, "content");
+    if (content !== void 0) {
+      const normalized = input.content.replace(/\r\n/g, "\n");
+      if (new TextEncoder().encode(normalized).length > MAX_CONTENT) throw new ValidationError(`content must be at most ${MAX_CONTENT} bytes of UTF-8`);
+      if (CONTROL_CHARS.test(normalized)) throw new ValidationError("content contains control characters that cannot be stored");
+    }
+    const templateId = input.templateId === void 0 ? void 0 : requireString(input.templateId, "templateId");
+    if (templateId !== void 0 && templateId.length > 100) throw new ValidationError("templateId must be at most 100 characters");
+    if (content === void 0 && templateId === void 0) throw new ValidationError("Provide content, or templateId to bind a template from the instance terms library");
+    if (input.title !== void 0 && (typeof input.title !== "string" || input.title.length > 200)) throw new ValidationError("title must be a string of at most 200 characters");
+    const body = compact({
+      content: input.content,
+      title: input.title,
+      published: optionalBoolean(input.published, "published"),
+      templateId
+    });
+    return this.http.put(this.path(marketId, "terms"), body, BUILD);
+  }
+  async unpublish(marketId) {
+    return this.http.delete(this.path(marketId, "terms"), BUILD);
+  }
+  async export(marketId, options = {}) {
+    return this.http.getBinary(this.path(marketId, "terms/export"), { format: optionalOneOf(options.format, "format", EXPORT_FORMATS) }, { timeoutMs: DOCUMENT_TIMEOUT_MS });
+  }
+};
+
+// src/modules/lending/oracle.ts
+function checkPriceSignature(input, exact) {
+  if (!input || typeof input !== "object") throw new ValidationError("Provide { price, timestamp, validUntil, signature }");
+  if (typeof input.price !== "string" || !/^\d+$/.test(input.price)) throw new ValidationError("price must be the raw integer price in the settlement asset's smallest unit, as a string of digits");
+  const timestamp = requireInt(input.timestamp, "timestamp", 1, Number.MAX_SAFE_INTEGER);
+  const validUntil = requireInt(input.validUntil, "validUntil", 1, Number.MAX_SAFE_INTEGER);
+  const pattern = exact ? /^0x[0-9a-fA-F]{130}$/ : /^0x[0-9a-fA-F]+$/;
+  if (typeof input.signature !== "string" || !pattern.test(input.signature)) {
+    throw new ValidationError(exact ? "signature must be the 65-byte EIP-712 signature: 0x followed by 130 hex characters" : "signature must be 0x-prefixed hex");
+  }
+  return { price: input.price, timestamp, validUntil, signature: input.signature };
+}
+var LendingOracle = class extends LendingArea {
+  path(marketId, rest) {
+    return `${LENDING_BASE}/markets/${enc(requireMarketId(marketId))}/${rest}`;
+  }
+  async status(marketId) {
+    return this.http.get(this.path(marketId, "oracle-status"));
+  }
+  async verifySigner(marketId) {
+    return this.http.get(this.path(marketId, "verify-signer"));
+  }
+  async history(marketId, options = {}) {
+    return this.http.get(this.path(marketId, "oracle-history"), {
+      limit: options.limit === void 0 ? void 0 : clampInt(options.limit, 1, 100, 20),
+      offset: optionalInt(options.offset, "offset", 0, Number.MAX_SAFE_INTEGER)
+    });
+  }
+  async verifyPrice(marketId, signedPrice) {
+    return this.http.post(this.path(marketId, "verify-price"), checkPriceSignature(signedPrice, false), { retry: "read" });
+  }
+  async recordAttestation(marketId, attestation) {
+    return this.http.post(this.path(marketId, "price-attestation"), checkPriceSignature(attestation, true), BUILD);
+  }
+  async sync(marketId, input, options) {
+    const path = this.path(marketId, "sync-oracle");
+    const price = requireAmount(input?.price, "price");
+    const confirm = (txHash) => this.http.post(path, { price, txHash }, CONFIRM);
+    if (isConfirmOptions(options)) return confirm(requireTxHash(options.txHash));
+    let signerAddress2 = optionalWallet(input.signerAddress, "signerAddress");
+    if (isSignOptions(options)) signerAddress2 = await walletOf(options, signerAddress2, "signerAddress");
+    return this.twoLeg(options, {
+      build: () => this.http.post(path, compact({ price, signerAddress: signerAddress2 }), BUILD),
+      confirm
+    });
+  }
+  async signPrice(marketId, input, options) {
+    if (options !== void 0 && !isSignOptions(options)) {
+      throw new ValidationError("signPrice has no confirm leg: pass { signer } to sign and record the attestation, or no options to get the typed data");
+    }
+    const price = requireAmount(input?.price, "price");
+    const validitySeconds = optionalInt(input.validitySeconds, "validitySeconds", 0, Number.MAX_SAFE_INTEGER);
+    let signerAddress2 = optionalWallet(input.signerAddress, "signerAddress");
+    if (options) {
+      signerAddress2 = await walletOf(options, signerAddress2, "signerAddress");
+      await preflightChain(this.ctx, options);
+    }
+    const request = await this.http.post(this.path(marketId, "sign-price"), compact({ price, validitySeconds, signerAddress: signerAddress2 }), BUILD);
+    if (!options) return request;
+    const signature = await signTypedData(this.ctx, options, request.typedData);
+    const message = request.typedData.message;
+    const signedPrice = {
+      price: String(message.price),
+      timestamp: Number(message.timestamp),
+      validUntil: Number(message.validUntil),
+      signature
+    };
+    const recorded = await this.recordAttestation(marketId, signedPrice);
+    return { ...recorded, signedPrice };
+  }
+};
+
+// src/modules/lending/liquidity.ts
+var LendingLiquidity = class extends LendingArea {
+  positionsPath(marketId, rest) {
+    return `${LENDING_BASE}/positions/${enc(requireMarketId(marketId))}/${rest}`;
+  }
+  marketsPath(marketId, rest) {
+    return `${LENDING_BASE}/markets/${enc(requireMarketId(marketId))}/${rest}`;
+  }
+  async providers(marketId) {
+    return this.http.get(this.positionsPath(marketId, "providers"));
+  }
+  async providerBalance(marketId, provider) {
+    return this.http.get(this.positionsPath(marketId, `provider-balance/${requireWallet(provider, "provider")}`));
+  }
+  async add(marketId, input, options) {
+    const path = this.positionsPath(marketId, "add-liquidity");
+    const confirm = (txHash) => this.http.post(path, { txHash }, CONFIRM);
+    if (isConfirmOptions(options)) return confirm(requireTxHash(options.txHash));
+    const amount = requireAmount(input?.amount, "amount");
+    let provider = optionalWallet(input?.provider, "provider");
+    if (isSignOptions(options)) provider = await walletOf(options, provider, "provider");
+    return this.twoLeg(options, {
+      build: () => this.http.post(path, compact({ amount, provider }), BUILD),
+      confirm
+    });
+  }
+  async remove(marketId, input, options) {
+    const path = this.positionsPath(marketId, "remove-liquidity");
+    const confirm = (txHash) => this.http.post(path, { txHash }, CONFIRM);
+    if (isConfirmOptions(options)) return confirm(requireTxHash(options.txHash));
+    const shares = requireAmount(input?.shares, "shares");
+    let provider = optionalWallet(input?.provider, "provider");
+    if (isSignOptions(options)) provider = await walletOf(options, provider, "provider");
+    else if (!provider) throw new ValidationError("provider is required: it is the wallet whose shares are redeemed and that signs removeLiquidity");
+    return this.twoLeg(options, {
+      build: () => this.http.post(path, { shares, provider }, BUILD),
+      confirm
+    });
+  }
+  async vaultLiquidity(marketId) {
+    return this.http.get(this.marketsPath(marketId, "vault-liquidity"));
+  }
+  async setVaultLiquidity(marketId, enabled, options) {
+    const path = this.marketsPath(marketId, "vault-liquidity");
+    const body = { enabled: requireBoolean(enabled, "enabled") };
+    return this.oneLeg(options, () => this.http.post(path, body, BUILD));
+  }
+  async registerVault(marketId, vaultAddress, options) {
+    return this.vaultRegistration(marketId, "register", vaultAddress, options);
+  }
+  async deregisterVault(marketId, vaultAddress, options) {
+    return this.vaultRegistration(marketId, "deregister", vaultAddress, options);
+  }
+  async connectedVaults(marketId) {
+    return this.http.get(this.marketsPath(marketId, "connected-vaults"));
+  }
+  async depositToVault(marketId, vaultAddress, input, options) {
+    const path = this.marketsPath(marketId, `vaults/${requireWallet(vaultAddress, "vaultAddress")}/deposit`);
+    const confirm = (txHash) => this.http.post(path, { txHash }, CONFIRM);
+    if (isConfirmOptions(options)) return confirm(requireTxHash(options.txHash));
+    const amount = requireAmount(input?.amount, "amount");
+    let holderAddress = optionalWallet(input?.holderAddress, "holderAddress");
+    if (isSignOptions(options)) holderAddress = await walletOf(options, holderAddress, "holderAddress");
+    return this.twoLeg(options, {
+      build: () => this.http.post(path, compact({ amount, holderAddress }), BUILD),
+      confirm
+    });
+  }
+  async redeemFromVault(marketId, vaultAddress, input, options) {
+    const path = this.marketsPath(marketId, `vaults/${requireWallet(vaultAddress, "vaultAddress")}/redeem`);
+    const confirm = (txHash) => this.http.post(path, { txHash }, CONFIRM);
+    if (isConfirmOptions(options)) return confirm(requireTxHash(options.txHash));
+    const shares = requireAmount(input?.shares, "shares");
+    let holderAddress = optionalWallet(input?.holderAddress, "holderAddress");
+    if (isSignOptions(options)) holderAddress = await walletOf(options, holderAddress, "holderAddress");
+    else if (!holderAddress) throw new ValidationError("holderAddress is required: it is the wallet whose vault shares are redeemed");
+    return this.twoLeg(options, {
+      build: () => this.http.post(path, { shares, holderAddress }, BUILD),
+      confirm
+    });
+  }
+  async vaultRegistration(marketId, action, vaultAddress, options) {
+    const path = this.marketsPath(marketId, `vault-liquidity/${action}`);
+    const body = { vaultAddress: requireWallet(vaultAddress, "vaultAddress") };
+    return this.oneLeg(options, () => this.http.post(path, body, BUILD));
+  }
+};
+
+// src/modules/lending/loans.ts
+var REPAY_MODES = ["sequential", "permit", "batch"];
+function repayAmountFields(input) {
+  const all = optionalBoolean(input.all, "all");
+  const amount = optionalAmount(input.amount, "amount");
+  if (all === true && amount !== void 0) throw new ValidationError("Send either amount or all: true, not both");
+  if (all !== true && amount === void 0) throw new ValidationError("Provide amount, or all: true to repay the loan in full");
+  return all === true ? { all: true } : { amount };
+}
+var LendingLoans = class extends LendingArea {
+  path(marketId, rest) {
+    return `${LENDING_BASE}/positions/${enc(requireMarketId(marketId))}/${rest}`;
+  }
+  async list(marketId) {
+    return this.http.get(this.path(marketId, "positions"));
+  }
+  async get(marketId, positionId) {
+    return this.http.get(this.path(marketId, `positions/${enc(requireRecordId(positionId, "positionId"))}`));
+  }
+  async statement(marketId, positionId) {
+    return this.http.getBinary(this.path(marketId, `positions/${enc(requireRecordId(positionId, "positionId"))}/statement`), void 0, { timeoutMs: DOCUMENT_TIMEOUT_MS });
+  }
+  async getByLoanId(marketId, loanId) {
+    return this.http.get(this.path(marketId, `loan/${requirePositiveId(loanId, "loanId")}`));
+  }
+  async byWallet(marketId, walletAddress) {
+    return this.http.get(this.path(marketId, `user-loans/${requireWallet(walletAddress, "walletAddress")}`));
+  }
+  async collateral(marketId, walletAddress) {
+    return this.http.get(this.path(marketId, `user-collateral/${requireWallet(walletAddress, "walletAddress")}`));
+  }
+  async escrowedCollateral(marketId, holderAddress) {
+    return this.http.get(this.path(marketId, `escrowed-collateral/${requireWallet(holderAddress, "holderAddress")}`));
+  }
+  async escrowedSurplus(marketId, holderAddress) {
+    return this.http.get(this.path(marketId, `escrowed-surplus/${requireWallet(holderAddress, "holderAddress")}`));
+  }
+  async open(marketId, input, options) {
+    const path = this.path(marketId, "open-loan");
+    const clientReference = input.clientReference === void 0 ? void 0 : requireString(input.clientReference, "clientReference");
+    if (clientReference !== void 0 && clientReference.length > 120) throw new ValidationError("clientReference must be at most 120 characters");
+    const reattribute = optionalBoolean(input.reattribute, "reattribute");
+    const confirm = (txHash) => this.http.post(path, compact({ txHash, clientReference, reattribute }), CONFIRM);
+    if (isConfirmOptions(options)) return confirm(requireTxHash(options.txHash));
+    const full = input;
+    const body = {
+      collateralAmount: requireAmount(full.collateralAmount, "collateralAmount"),
+      borrowAmount: requireAmount(full.borrowAmount, "borrowAmount"),
+      borrowerAddress: optionalWallet(full.borrowerAddress, "borrowerAddress"),
+      signedPrice: checkSignedPrice(full.signedPrice),
+      clientReference,
+      payToAddress: full.payToAddress === null ? null : optionalWallet(full.payToAddress, "payToAddress")
+    };
+    if (isSignOptions(options)) body.borrowerAddress = await walletOf(options, body.borrowerAddress, "borrowerAddress");
+    else if (!body.borrowerAddress) throw new ValidationError("borrowerAddress is required: the borrower is the wallet that signs openLoan");
+    return this.twoLeg(options, {
+      build: () => this.http.post(path, compact(body), BUILD),
+      confirm
+    });
+  }
+  async addCollateral(marketId, input, options) {
+    return this.loanAction(marketId, "add-collateral", input, options, (full) => ({ amount: requireAmount(full.amount, "amount") }));
+  }
+  async withdrawCollateral(marketId, input, options) {
+    return this.loanAction(marketId, "withdraw-collateral", input, options, (full) => ({ amount: requireAmount(full.amount, "amount"), signedPrice: checkSignedPrice(full.signedPrice) }));
+  }
+  async borrowMore(marketId, input, options) {
+    return this.loanAction(marketId, "borrow-more", input, options, (full) => ({ amount: requireAmount(full.amount, "amount"), signedPrice: checkSignedPrice(full.signedPrice) }));
+  }
+  async close(marketId, loanId, options) {
+    return this.loanAction(marketId, "close-loan", { loanId }, options, () => ({}));
+  }
+  async permitQuote(marketId, input) {
+    const body = compact({
+      loanId: requirePositiveId(input.loanId, "loanId"),
+      ...repayAmountFields(input),
+      payer: requireWallet(input.payer, "payer"),
+      deadlineSeconds: optionalInt(input.deadlineSeconds, "deadlineSeconds", 300, 1800)
+    });
+    return this.http.post(this.path(marketId, "permit-quote"), body, BUILD);
+  }
+  async repay(marketId, input, options) {
+    const path = this.path(marketId, "repay");
+    const loanId = requirePositiveId(input.loanId, "loanId");
+    if (isConfirmOptions(options)) {
+      const hint = input.all === true ? { all: true } : input.amount !== void 0 ? { amount: requireAmount(input.amount, "amount") } : {};
+      return this.http.post(path, { loanId, txHash: requireTxHash(options.txHash), ...hint }, CONFIRM);
+    }
+    const full = input;
+    const amountFields = repayAmountFields(full);
+    const mode = optionalOneOf(full.mode, "mode", REPAY_MODES) ?? (full.permit ? "permit" : void 0);
+    let payer = optionalWallet(full.payer, "payer");
+    const signedPrice = mode === "permit" ? void 0 : checkSignedPrice(full.signedPrice);
+    const confirm = (txHash) => this.http.post(path, { loanId, txHash, ...amountFields }, CONFIRM);
+    const build = (body) => this.http.post(path, compact(body), BUILD);
+    if (!isSignOptions(options)) {
+      if (mode === "permit") {
+        if (!full.permit) throw new ValidationError("A permit repayment needs permit { value, deadline, v, r, s }: get it from permitQuote and sign its typedData, or pass { signer } and the SDK does both");
+        if (!payer) throw new ValidationError("A permit repayment needs payer, the wallet that signed the permit");
+      }
+      return build({ loanId, ...amountFields, payer, mode, signedPrice, permit: full.permit });
+    }
+    if (mode === "batch") {
+      throw new ValidationError("mode batch is for a wallet that sends all steps as one atomic bundle (wallet_sendCalls). Prepare it without a signer and confirm with { txHash } of the bundle, or use mode sequential or permit with a signer");
+    }
+    payer = await walletOf(options, payer, "payer");
+    await preflightChain(this.ctx, options);
+    let permit = full.permit;
+    let quoted = null;
+    if (mode === "permit" && !permit) {
+      const quote = await this.permitQuote(marketId, { loanId, ...amountFields, payer, deadlineSeconds: full.deadlineSeconds });
+      const signature = await signTypedData(this.ctx, options, quote.typedData);
+      const { v, r, s } = splitSignature(signature);
+      permit = { value: quote.permit.value, deadline: quote.permit.deadline, v, r, s };
+      quoted = { mode: "permit", payer: quote.repay.payer, ...quote.repay.all ? { all: true } : { amount: quote.repay.amount } };
+    }
+    const prepared = await build({ loanId, ...amountFields, payer, mode, signedPrice, permit, ...quoted ?? {} });
+    const plan = planOf(prepared);
+    if (!plan) throw new ValidationError("The repayment build returned no transaction to sign");
+    const executed = await execute(this.ctx, plan, options);
+    return confirmExecuted(executed, confirm);
+  }
+  async claimEscrowedCollateral(marketId, input = {}, options) {
+    assertInputIsNotOptions(input, "claimEscrowedCollateral(marketId, {}, { signer })");
+    const path = this.path(marketId, "claim-escrowed-collateral");
+    let holderAddress = optionalWallet(input?.holderAddress, "holderAddress");
+    if (isSignOptions(options)) holderAddress = await walletOf(options, holderAddress, "holderAddress");
+    return this.twoLeg(options, {
+      build: () => this.http.post(path, compact({ holderAddress }), BUILD),
+      confirm: (txHash) => this.http.post(path, compact({ holderAddress, txHash }), CONFIRM)
+    });
+  }
+  async claimSurplus(marketId, input, options) {
+    const path = this.path(marketId, "claim-surplus");
+    let holderAddress = optionalWallet(input?.holderAddress, "holderAddress");
+    if (isSignOptions(options)) holderAddress = await walletOf(options, holderAddress, "holderAddress");
+    else if (!isConfirmOptions(options) && !holderAddress) throw new ValidationError("holderAddress is required: the surplus is claimed by the borrower whose loan was realized");
+    return this.twoLeg(options, {
+      build: () => this.http.post(path, { holderAddress }, BUILD),
+      confirm: (txHash) => this.http.post(path, { txHash }, CONFIRM)
+    });
+  }
+  async loanAction(marketId, route, input, options, fields) {
+    const path = this.path(marketId, route);
+    const loanId = requirePositiveId(input.loanId, "loanId");
+    const confirm = (txHash) => this.http.post(path, { loanId, txHash }, CONFIRM);
+    if (isConfirmOptions(options)) return confirm(requireTxHash(options.txHash));
+    const body = compact({ loanId, ...fields(input) });
+    return this.twoLeg(options, {
+      build: () => this.http.post(path, body, BUILD),
+      confirm
+    });
+  }
+};
+
+// src/modules/lending/fees.ts
+var LendingFees = class extends LendingArea {
+  path(marketId, rest) {
+    return `${LENDING_BASE}/markets/${enc(requireMarketId(marketId))}/${rest}`;
+  }
+  async split(marketId) {
+    return this.http.get(this.path(marketId, "fee-split"));
+  }
+  async cashflows(marketId) {
+    return this.http.get(this.path(marketId, "cashflows"));
+  }
+  async sweepOperatorFees(marketId, options) {
+    return this.sweep(this.path(marketId, "operator-fees/sweep"), {}, options);
+  }
+  async sweepProtocolFees(marketId, options) {
+    return this.sweep(this.path(marketId, "protocol-fees/sweep"), {}, options);
+  }
+  async sweepInfrastructureFees(marketId, options) {
+    return this.sweep(this.path(marketId, "infrastructure-fees/sweep"), {}, options);
+  }
+  async sweepDistributorFees(marketId, input = {}, options) {
+    assertInputIsNotOptions(input, "sweepDistributorFees(marketId, {}, { signer })");
+    const provider = optionalWallet(input?.provider, "provider");
+    return this.sweep(this.path(marketId, "distributor-fees/sweep"), compact({ provider }), options);
+  }
+  async rotateOperatorWallet(marketId, input, options) {
+    const path = this.path(marketId, "operator-wallet");
+    const confirm = (txHash) => this.http.post(path, { txHash }, CONFIRM);
+    if (isConfirmOptions(options)) return confirm(requireTxHash(options.txHash));
+    const full = input;
+    const newRecipient = requireWallet(full?.newRecipient, "newRecipient");
+    let signerAddress2 = optionalWallet(full.signerAddress, "signerAddress");
+    if (isSignOptions(options)) signerAddress2 = await walletOf(options, signerAddress2, "signerAddress");
+    return this.twoLeg(options, {
+      build: async () => {
+        const prepared = await this.http.post(path, compact({ newRecipient, signerAddress: signerAddress2 }), BUILD);
+        if (isSignOptions(options)) await requireSignerIs(options, prepared.requiredSigner, "the current operator wallet");
+        return prepared;
+      },
+      confirm
+    });
+  }
+  async sweep(path, body, options) {
+    return this.twoLeg(options, {
+      build: () => this.http.post(path, body, BUILD),
+      confirm: (txHash) => this.http.post(path, { txHash }, CONFIRM)
+    });
+  }
+};
+
+// src/modules/lending/insurance.ts
+var WITHDRAWAL_ACTIONS = ["propose", "cancel", "execute"];
+var LendingInsurance = class extends LendingArea {
+  path(marketId, rest) {
+    return `${LENDING_BASE}/markets/${enc(requireMarketId(marketId))}/${rest}`;
+  }
+  async status(marketId) {
+    return this.http.get(this.path(marketId, "insurance/status"));
+  }
+  async topUp(marketId, input, options) {
+    const amount = requireAmount(input?.amount, "amount");
+    let fromAddress = optionalWallet(input.fromAddress, "fromAddress");
+    if (isSignOptions(options)) fromAddress = await walletOf(options, fromAddress, "fromAddress");
+    if (!fromAddress) throw new ValidationError("fromAddress is required: it is the wallet that funds the top-up");
+    const from = fromAddress;
+    const confirm = (txHash) => this.http.post(this.path(marketId, "insurance/record-topup"), { amount, fromAddress: from, txHash }, CONFIRM);
+    if (isConfirmOptions(options)) return confirm(requireTxHash(options.txHash));
+    return this.twoLeg(options, {
+      build: () => this.http.post(this.path(marketId, "insurance/top-up"), { amount, fromAddress: from }, BUILD),
+      confirm
+    });
+  }
+  async withdraw(marketId, input, options) {
+    const path = this.path(marketId, "insurance/withdraw-calldata");
+    const action = optionalOneOf(input?.action, "action", WITHDRAWAL_ACTIONS) ?? "execute";
+    if (isConfirmOptions(options)) {
+      return this.http.post(path, { action, txHash: requireTxHash(options.txHash) }, CONFIRM);
+    }
+    const body = action === "cancel" ? { action } : { action, amount: requireAmount(input?.amount, "amount"), recipient: requireWallet(input?.recipient, "recipient") };
+    const build = async () => {
+      const prepared2 = await this.http.post(path, body, BUILD);
+      if (isSignOptions(options)) {
+        if (!prepared2.fundOwner || /^0x0{40}$/i.test(prepared2.fundOwner)) {
+          throw new TrussetError("The insurance fund owner could not be read just now, so the withdrawal was not signed. Retry shortly", "FUND_OWNER_UNREADABLE", 503);
+        }
+        await requireSignerIs(options, prepared2.fundOwner, "the insurance fund owner");
+      }
+      return prepared2;
+    };
+    if (!isSignOptions(options)) return this.oneLeg(options, build);
+    await preflightChain(this.ctx, options);
+    const prepared = await build();
+    const plan = planOf(prepared.calldata, { confirmIndex: 0 });
+    if (!plan) throw new TrussetError("The withdrawal build returned no transaction to sign", "NOTHING_TO_SIGN", 0);
+    const executed = await execute(this.ctx, plan, options);
+    if (prepared.notice?.supported !== true) return { transactions: executed.transactions };
+    return confirmExecuted(executed, (txHash) => this.http.post(path, { action: prepared.action ?? action, txHash }, CONFIRM));
+  }
+};
+
+// src/modules/lending/liquidations.ts
+function liquidationIdOf(value) {
+  if (typeof value === "number") return requirePositiveId(value, "liquidationId");
+  return requireRecordId(value, "liquidationId");
+}
+var LendingLiquidations = class extends LendingArea {
+  marketPath(marketId, rest) {
+    return `${LENDING_BASE}/liquidations/${enc(requireMarketId(marketId))}/${rest}`;
+  }
+  recordPath(prefix, liquidationId, suffix = "") {
+    return `${LENDING_BASE}/liquidations/${prefix}/${enc(liquidationIdOf(liquidationId))}${suffix}`;
+  }
+  async config(marketId, query = {}) {
+    return this.http.get(this.marketPath(marketId, "config"), { signerAddress: optionalWallet(query.signerAddress, "signerAddress") });
+  }
+  async liquidatable(marketId) {
+    return this.http.get(this.marketPath(marketId, "liquidatable-loans"));
+  }
+  async pending(marketId) {
+    return this.http.get(this.marketPath(marketId, "pending-liquidations"));
+  }
+  async settled(marketId, options = {}) {
+    return this.http.get(this.marketPath(marketId, "settled-liquidations"), {
+      limit: clampInt(options.limit, 1, 200, 50),
+      offset: clampInt(options.offset, 0, Number.MAX_SAFE_INTEGER, 0)
+    });
+  }
+  async stats(marketId) {
+    return this.http.get(this.marketPath(marketId, "liquidation-stats"));
+  }
+  async routerStats(marketId) {
+    return this.http.get(`${LENDING_BASE}/liquidations/router-stats`, { marketId: requireMarketId(marketId) });
+  }
+  async atomicSale(marketId, query = {}) {
+    return this.http.get(this.marketPath(marketId, "atomic-sale"), { signerAddress: optionalWallet(query.signerAddress, "signerAddress") });
+  }
+  async setAtomicMode(marketId, input, options) {
+    const path = this.marketPath(marketId, "atomic-mode");
+    const confirm = (txHash) => this.http.post(path, { txHash }, CONFIRM);
+    if (isConfirmOptions(options)) return confirm(requireTxHash(options.txHash));
+    const mode = requireInt(input?.mode, "mode", 0, 1);
+    let signerAddress2 = optionalWallet(input?.signerAddress, "signerAddress");
+    if (isSignOptions(options)) signerAddress2 = await walletOf(options, signerAddress2, "signerAddress");
+    return this.twoLeg(options, {
+      build: () => this.http.post(path, compact({ mode, signerAddress: signerAddress2 }), BUILD),
+      confirm
+    });
+  }
+  async setSaleBid(marketId, input, options) {
+    const path = this.marketPath(marketId, "sale-bid");
+    const confirm = (txHash) => this.http.post(path, { txHash }, CONFIRM);
+    if (isConfirmOptions(options)) return confirm(requireTxHash(options.txHash));
+    const priceFactorBps = requireInt(input?.priceFactorBps, "priceFactorBps", 0, 2e4);
+    if (priceFactorBps !== 0 && priceFactorBps < 9500) {
+      throw new ValidationError("priceFactorBps must be 0 to withdraw the bid, or between 9500 and 20000");
+    }
+    const validUntil = optionalInt(input?.validUntil, "validUntil", 0, Number.MAX_SAFE_INTEGER);
+    if (priceFactorBps !== 0 && validUntil === void 0) {
+      throw new ValidationError("validUntil (unix seconds) is required when a bid is set");
+    }
+    const allowance = optionalAmount(input?.allowance, "allowance", { allowZero: true });
+    if (priceFactorBps === 0 && allowance !== void 0 && /[1-9]/.test(allowance)) {
+      throw new ValidationError('Withdrawing the bid (priceFactorBps 0) cannot raise the allowance at the same time: that plan ends on an approval the API cannot confirm. Send allowance "0" or leave it out, and set the allowance with the next bid');
+    }
+    let signerAddress2 = optionalWallet(input?.signerAddress, "signerAddress");
+    if (isSignOptions(options)) signerAddress2 = await walletOf(options, signerAddress2, "signerAddress");
+    return this.twoLeg(options, {
+      build: () => this.http.post(path, compact({ priceFactorBps, validUntil, allowance, signerAddress: signerAddress2 }), BUILD),
+      confirm
+    });
+  }
+  async liquidate(marketId, loanId, input = {}, options) {
+    assertInputIsNotOptions(input, "liquidate(marketId, loanId, {}, { signer })");
+    const path = this.marketPath(marketId, `liquidate/${requirePositiveId(loanId, "loanId")}`);
+    const confirm = (txHash) => this.http.post(path, { txHash }, CONFIRM);
+    if (isConfirmOptions(options)) return confirm(requireTxHash(options.txHash));
+    const signedPrice = checkSignedPrice(input?.signedPrice);
+    let signerAddress2 = optionalWallet(input?.signerAddress, "signerAddress");
+    if (isSignOptions(options)) signerAddress2 = await walletOf(options, signerAddress2, "signerAddress");
+    return this.twoLeg(options, {
+      build: () => this.http.post(path, compact({ signedPrice, signerAddress: signerAddress2 }), BUILD),
+      confirm
+    });
+  }
+  async sell(liquidationId, input, options) {
+    const path = this.recordPath("liquidation", liquidationId, "/sell");
+    const marketId = requireMarketId(input?.marketId);
+    const confirm = (txHash) => this.http.post(path, { marketId, txHash }, CONFIRM);
+    if (isConfirmOptions(options)) return confirm(requireTxHash(options.txHash));
+    let signerAddress2 = optionalWallet(input.signerAddress, "signerAddress");
+    if (isSignOptions(options)) signerAddress2 = await walletOf(options, signerAddress2, "signerAddress");
+    return this.twoLeg(options, {
+      build: () => this.http.post(path, compact({ marketId, signerAddress: signerAddress2 }), BUILD),
+      confirm
+    });
+  }
+  async withdrawCollateralForSale(liquidationId, input, options) {
+    const path = this.recordPath("withdraw-collateral", liquidationId);
+    const body = compact({
+      marketId: requireMarketId(input?.marketId),
+      amount: requireAmount(input?.amount, "amount"),
+      recipientAddress: optionalWallet(input?.recipientAddress, "recipientAddress")
+    });
+    return this.recordWrite(path, body, options, CONFIRM_ONCE);
+  }
+  async reportPartialSale(liquidationId, input, options) {
+    const path = this.recordPath("report-partial-sale", liquidationId);
+    const body = {
+      marketId: requireMarketId(input?.marketId),
+      collateralSold: requireAmount(input?.collateralSold, "collateralSold"),
+      usdcProceeds: requireAmount(input?.usdcProceeds, "usdcProceeds")
+    };
+    return this.recordWrite(path, body, options, CONFIRM_ONCE);
+  }
+  async settle(liquidationId, input, options) {
+    const path = this.recordPath("settle", liquidationId);
+    const body = {
+      marketId: requireMarketId(input?.marketId),
+      usdcProceeds: requireAmount(input?.usdcProceeds, "usdcProceeds", { allowZero: true })
+    };
+    return this.recordWrite(path, body, options, CONFIRM);
+  }
+  async close(liquidationId, input, options) {
+    const path = this.recordPath("close", liquidationId);
+    return this.recordWrite(path, { marketId: requireMarketId(input?.marketId) }, options, CONFIRM);
+  }
+  async handleTimeout(liquidationId, input, options) {
+    const path = this.recordPath("handle-timeout", liquidationId);
+    return this.recordWrite(path, { marketId: requireMarketId(input?.marketId) }, options, CONFIRM_ONCE);
+  }
+  async reopen(liquidationId, input, options) {
+    const path = this.recordPath("reopen", liquidationId);
+    return this.recordWrite(path, { marketId: requireMarketId(input?.marketId) }, options, CONFIRM);
+  }
+  async recordWrite(path, body, options, confirmRetry) {
+    const confirm = (txHash) => this.http.post(path, { ...body, txHash }, confirmRetry);
+    if (isConfirmOptions(options)) return confirm(requireTxHash(options.txHash));
+    return this.twoLeg(options, {
+      build: () => this.http.post(path, body, BUILD),
+      confirm
+    });
+  }
+};
+
+// src/modules/lending/auctions.ts
+async function deployedAddress(signer, txHash) {
+  if (!txHash) return null;
+  const provider = signer.provider;
+  if (!provider || typeof provider.getTransactionReceipt !== "function") return null;
+  try {
+    const receipt = await provider.getTransactionReceipt(txHash);
+    return receipt?.contractAddress ?? null;
+  } catch {
+    return null;
+  }
+}
+var LendingAuctions = class extends LendingArea {
+  liquidationsPath(marketId, rest) {
+    return `${LENDING_BASE}/liquidations/${enc(requireMarketId(marketId))}/${rest}`;
+  }
+  modulePath(marketId) {
+    return `${LENDING_BASE}/markets/${enc(requireMarketId(marketId))}/auction-module`;
+  }
+  async module(marketId) {
+    return this.http.get(this.modulePath(marketId));
+  }
+  async wireModule(marketId, input = {}, options) {
+    assertInputIsNotOptions(input, "wireModule(marketId, {}, { signer })");
+    const path = this.modulePath(marketId);
+    const body = compact({ moduleAddress: optionalWallet(input?.moduleAddress, "moduleAddress") });
+    const build = () => this.http.post(path, body, BUILD);
+    if (options === void 0) return build();
+    if (isConfirmOptions(options)) {
+      throw new ValidationError("Wiring an auction venue has no confirm leg: the venue is read back from the chain on the next read");
+    }
+    if (!isSignOptions(options)) {
+      throw new ValidationError("Pass { signer } to sign, or no options to get the unsigned transactions");
+    }
+    await preflightChain(this.ctx, options);
+    const prepared = await build();
+    const wiredModule = prepared.action === "SIGN_TRANSACTIONS" ? prepared.moduleAddress : null;
+    const plan = planOf(prepared, { confirmIndex: null });
+    if (!plan) return { transactions: [], moduleAddress: wiredModule };
+    if (prepared.action === "SIGN_TRANSACTIONS") {
+      const keys = new Set(prepared.steps.map((step) => step.key));
+      if (keys.has("authorizeVenueOnToken") || keys.has("verifyVenueAsHolder")) {
+        throw new ValidationError("This wiring plan includes collateral token steps that only the token's agent or its register agent can sign. Prepare it without a signer and sign each step from the wallet that holds its authority");
+      }
+      const signer = await walletOf(options, void 0, "signer");
+      await this.assertSignerRoles(requireMarketId(marketId), signer, [
+        ...keys.has("setAuctionModule") ? ["MARKET_ADMIN"] : [],
+        ...keys.has("authorizeModuleOnRouter") ? ["ROUTER_ADMIN"] : []
+      ]);
+    }
+    const executed = await execute(this.ctx, plan, options);
+    const moduleAddress = prepared.action === "SIGN_TRANSACTION" ? await deployedAddress(options.signer, executed.transactions[0]?.txHash ?? null) : wiredModule;
+    return { transactions: executed.transactions, moduleAddress };
+  }
+  async list(marketId) {
+    return this.http.get(this.liquidationsPath(marketId, "auctions"));
+  }
+  async get(marketId, auctionId) {
+    return this.http.get(this.liquidationsPath(marketId, `auctions/${requirePositiveId(auctionId, "auctionId")}`));
+  }
+  async forLoan(marketId, loanId) {
+    return this.http.get(this.liquidationsPath(marketId, `loan-auction/${requirePositiveId(loanId, "loanId")}`));
+  }
+  async bid(marketId, input, options) {
+    const path = this.liquidationsPath(marketId, "bid-on-auction");
+    const auctionId = Number(requirePositiveId(input?.auctionId, "auctionId"));
+    const collateralAmount = requireAmount(input?.collateralAmount, "collateralAmount");
+    const confirm = (txHash) => this.http.post(path, { auctionId, collateralAmount, txHash }, CONFIRM);
+    if (isConfirmOptions(options)) return confirm(requireTxHash(options.txHash));
+    let bidder = optionalWallet(input.bidder, "bidder");
+    if (isSignOptions(options)) bidder = await walletOf(options, bidder, "bidder");
+    return this.twoLeg(options, {
+      build: () => this.http.post(path, compact({ auctionId, collateralAmount, bidder }), BUILD),
+      confirm
+    });
+  }
+  async settleExpired(marketId, input, options) {
+    const path = this.liquidationsPath(marketId, "settle-expired-auction");
+    const auctionId = Number(requirePositiveId(input?.auctionId, "auctionId"));
+    const confirm = (txHash) => this.http.post(path, { auctionId, txHash }, CONFIRM);
+    if (isConfirmOptions(options)) return confirm(requireTxHash(options.txHash));
+    let signerAddress2 = optionalWallet(input.signerAddress, "signerAddress");
+    if (isSignOptions(options) && signerAddress2 !== void 0) signerAddress2 = await walletOf(options, signerAddress2, "signerAddress");
+    return this.twoLeg(options, {
+      build: () => this.http.post(path, compact({ auctionId, signerAddress: signerAddress2 }), BUILD),
+      confirm
+    });
+  }
+};
+
+// src/modules/lending/hooks.ts
+var HOOK_TYPES = ["monitorRisk", "beforeLiquidation", "afterLiquidation"];
+var OPERATORS = [">", ">=", "<", "<=", "==", "!="];
+var FREQUENCIES = ["1m", "5m", "15m", "30m", "1h", "6h", "12h", "24h"];
+var PARAMETERS = ["healthFactor", "collateralValue", "debtValue", "collateralRatio", "interestAccrued"];
+var ACTIONS = ["buy", "inform"];
+function boundedString(value, field, min, max) {
+  if (value === void 0) return void 0;
+  if (typeof value !== "string" || value.length < min || value.length > max) {
+    throw new ValidationError(`${field} must be a string of ${min} to ${max} characters`);
+  }
+  return value;
+}
+function httpUrl(value, field) {
+  const url = boundedString(value, field, 1, 2048);
+  if (url === void 0) return void 0;
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch {
+    throw new ValidationError(`${field} must be a valid URL`);
+  }
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+    throw new ValidationError(`${field} must be a public http(s) URL`);
+  }
+  return url;
+}
+function finiteNumber(value, field) {
+  if (value === void 0) return void 0;
+  if (typeof value !== "number" || !Number.isFinite(value)) throw new ValidationError(`${field} must be a number`);
+  return value;
+}
+function hookBody(input, creating) {
+  if (!input || typeof input !== "object") throw new ValidationError("The hook definition must be an object");
+  const riskFields = input.riskFields === void 0 ? void 0 : (() => {
+    if (!Array.isArray(input.riskFields) || input.riskFields.length > 20) throw new ValidationError("riskFields takes at most 20 entries");
+    return input.riskFields.map((f, i) => compact({
+      path: boundedString(f?.path, `riskFields[${i}].path`, 1, 256) ?? (() => {
+        throw new ValidationError(`riskFields[${i}].path is required`);
+      })(),
+      operator: optionalOneOf(f?.operator, `riskFields[${i}].operator`, OPERATORS),
+      threshold: finiteNumber(f?.threshold, `riskFields[${i}].threshold`)
+    }));
+  })();
+  const parameterChecks = input.parameterChecks === void 0 ? void 0 : (() => {
+    if (!Array.isArray(input.parameterChecks) || input.parameterChecks.length > 10) throw new ValidationError("parameterChecks takes at most 10 entries");
+    return input.parameterChecks.map((c, i) => ({
+      parameter: requireOneOf(c?.parameter, `parameterChecks[${i}].parameter`, PARAMETERS),
+      operator: requireOneOf(c?.operator, `parameterChecks[${i}].operator`, OPERATORS),
+      threshold: boundedString(c?.threshold, `parameterChecks[${i}].threshold`, 0, 64) ?? (() => {
+        throw new ValidationError(`parameterChecks[${i}].threshold is required`);
+      })()
+    }));
+  })();
+  const triggerHookIds = input.triggerHookIds === void 0 ? void 0 : (() => {
+    if (!Array.isArray(input.triggerHookIds) || input.triggerHookIds.length > 10) throw new ValidationError("triggerHookIds takes at most 10 hook ids");
+    return input.triggerHookIds.map((id, i) => boundedString(id, `triggerHookIds[${i}]`, 0, 128));
+  })();
+  if (input.webhookPayload !== void 0 && (input.webhookPayload === null || typeof input.webhookPayload !== "object" || Array.isArray(input.webhookPayload))) {
+    throw new ValidationError("webhookPayload must be an object of static fields");
+  }
+  const body = compact({
+    hookType: creating ? requireOneOf(input.hookType, "hookType", HOOK_TYPES) : optionalOneOf(input.hookType, "hookType", HOOK_TYPES),
+    name: boundedString(input.name, "name", 1, 128),
+    riskUri: httpUrl(input.riskUri, "riskUri"),
+    riskFields,
+    riskThreshold: finiteNumber(input.riskThreshold, "riskThreshold"),
+    checkFrequency: optionalOneOf(input.checkFrequency, "checkFrequency", FREQUENCIES),
+    parameterChecks,
+    triggerHookIds,
+    actionType: optionalOneOf(input.actionType, "actionType", ACTIONS),
+    maxBuyPrice: boundedString(input.maxBuyPrice, "maxBuyPrice", 0, 64),
+    webhookUrl: httpUrl(input.webhookUrl, "webhookUrl"),
+    webhookPayload: input.webhookPayload
+  });
+  if (creating) {
+    if (body.hookType === "monitorRisk" && !body.riskUri) throw new ValidationError("A monitorRisk hook needs riskUri");
+    if (body.hookType === "monitorRisk" && (!riskFields || riskFields.length === 0)) throw new ValidationError("A monitorRisk hook needs at least one riskFields entry");
+    if (body.hookType === "afterLiquidation" && !body.actionType) throw new ValidationError("An afterLiquidation hook needs actionType");
+    if (body.actionType === "inform" && !body.webhookUrl) throw new ValidationError("actionType inform needs webhookUrl");
+  }
+  return body;
+}
+var LendingHooks = class extends LendingArea {
+  path(marketId, hookId, rest = "") {
+    const base = `${LENDING_BASE}/hooks/${enc(requireMarketId(marketId))}`;
+    if (hookId === void 0) return base;
+    const hook = `${base}/${enc(requireRecordId(hookId, "hookId"))}`;
+    return rest ? `${hook}/${rest}` : hook;
+  }
+  async list(marketId) {
+    return this.http.get(this.path(marketId));
+  }
+  async get(marketId, hookId) {
+    return this.http.get(this.path(marketId, hookId));
+  }
+  async create(marketId, input) {
+    return this.http.post(this.path(marketId), hookBody(input, true), BUILD);
+  }
+  async update(marketId, hookId, input) {
+    return this.http.put(this.path(marketId, hookId), hookBody(input, false), BUILD);
+  }
+  async remove(marketId, hookId) {
+    return this.http.delete(this.path(marketId, hookId), BUILD);
+  }
+  async toggle(marketId, hookId, active) {
+    return this.http.post(this.path(marketId, hookId, "toggle"), { active: requireBoolean(active, "active") }, BUILD);
+  }
+  async execute(marketId, hookId, input = {}) {
+    if (!input || typeof input !== "object" || Array.isArray(input)) {
+      throw new ValidationError("Pass {} for a monitorRisk hook, { loanData } for beforeLiquidation, or { liquidationData } for afterLiquidation");
+    }
+    return this.http.post(this.path(marketId, hookId, "execute"), input, BUILD);
+  }
+  async executions(marketId, hookId, options = {}) {
+    return this.http.get(this.path(marketId, hookId, "executions"), {
+      limit: optionalInt(options.limit, "limit", 1, 200),
+      offset: optionalInt(options.offset, "offset", 0, Number.MAX_SAFE_INTEGER)
+    });
+  }
+  async deliveries(marketId, hookId, options = {}) {
+    return this.http.get(this.path(marketId, hookId, "deliveries"), {
+      limit: optionalInt(options.limit, "limit", 1, 200),
+      offset: optionalInt(options.offset, "offset", 0, Number.MAX_SAFE_INTEGER)
+    });
+  }
+  async rotateSecret(marketId, hookId) {
+    return this.http.post(this.path(marketId, hookId, "rotate-secret"), void 0, BUILD);
+  }
+};
+
+// src/modules/lending/bots.ts
+function label(value) {
+  if (value === void 0) return void 0;
+  if (typeof value !== "string") throw new ValidationError("label must be a string");
+  if (value.length > 64) throw new ValidationError("label must be at most 64 characters");
+  return value;
+}
+var LendingBots = class extends LendingArea {
+  path(botId, rest = "") {
+    const base = `${LENDING_BASE}/liquidation-bots`;
+    if (botId === void 0) return rest ? `${base}/${rest}` : base;
+    const id = `${base}/${enc(requireRecordId(botId, "botId"))}`;
+    return rest ? `${id}/${rest}` : id;
+  }
+  confirmTx(botId, txHash) {
+    return this.http.post(this.path(botId, "confirm-tx"), { txHash }, CONFIRM);
+  }
+  async list(options = {}) {
+    return this.http.get(this.path(), { includeArchived: optionalBoolean(options.includeArchived, "includeArchived") ? "true" : void 0 });
+  }
+  async get(botId) {
+    return this.http.get(this.path(botId));
+  }
+  async transactions(botId, options = {}) {
+    return this.http.get(this.path(botId, "transactions"), { limit: optionalInt(options.limit, "limit", 1, 200) });
+  }
+  async deploy(input = {}, options) {
+    assertInputIsNotOptions(input, "deploy({}, { signer })");
+    const botLabel = label(input?.label);
+    const confirm = (txHash) => this.http.post(this.path(void 0, "confirm-deploy"), compact({ txHash, label: botLabel }), CONFIRM_ONCE);
+    if (isConfirmOptions(options)) return confirm(requireTxHash(options.txHash));
+    let signerAddress2 = optionalWallet(input?.signerAddress, "signerAddress");
+    if (isSignOptions(options)) signerAddress2 = await walletOf(options, signerAddress2, "signerAddress");
+    return this.twoLeg(options, {
+      build: () => this.http.post(this.path(), compact({ signerAddress: signerAddress2 }), BUILD),
+      confirm
+    });
+  }
+  async connect(botId, marketId, options) {
+    return this.connection(botId, marketId, true, options);
+  }
+  async disconnect(botId, marketId, options) {
+    return this.connection(botId, marketId, false, options);
+  }
+  async pause(botId, options) {
+    return this.action(botId, { action: "pause" }, options);
+  }
+  async resume(botId, options) {
+    return this.action(botId, { action: "resume" }, options);
+  }
+  async setRefundPolicy(botId, input, options) {
+    if (isConfirmOptions(options)) return this.confirmTx(requireRecordId(botId, "botId"), requireTxHash(options.txHash));
+    return this.action(botId, {
+      action: "setRefundPolicy",
+      maxRefundPerCallerPerBlockWei: requireIntegerString(input?.maxRefundPerCallerPerBlockWei, "maxRefundPerCallerPerBlockWei"),
+      maxRefundGasPriceWei: requireIntegerString(input?.maxRefundGasPriceWei, "maxRefundGasPriceWei")
+    }, options);
+  }
+  async withdraw(botId, input, options) {
+    assertInputIsNotOptions(input, "withdraw(botId, {}, { signer })");
+    if (isConfirmOptions(options)) return this.confirmTx(requireRecordId(botId, "botId"), requireTxHash(options.txHash));
+    return this.action(botId, {
+      action: "withdraw",
+      amountWei: input?.amountWei === void 0 ? void 0 : requireIntegerString(input.amountWei, "amountWei"),
+      to: optionalWallet(input?.to, "to")
+    }, options);
+  }
+  async fund(botId, amount, options) {
+    const id = requireRecordId(botId, "botId");
+    if (isConfirmOptions(options)) return this.confirmTx(id, requireTxHash(options.txHash));
+    const value = requireAmount(amount, "amount");
+    const fraction = value.split(".")[1];
+    if (fraction !== void 0 && fraction.length > 18) throw new ValidationError("amount is in the native coin and takes at most 18 decimal places");
+    return this.twoLeg(options, {
+      build: () => this.http.post(this.path(id, "fund"), { amount: value }, BUILD),
+      confirm: (txHash) => this.confirmTx(id, txHash)
+    });
+  }
+  async update(botId, input) {
+    const body = {};
+    if (input?.label !== void 0) body.label = input.label === null ? null : label(input.label);
+    if (input?.archived !== void 0) body.archived = requireBoolean(input.archived, "archived");
+    if (Object.keys(body).length === 0) throw new ValidationError("Send a label or an archived flag");
+    return this.http.patch(this.path(botId), body, BUILD);
+  }
+  async connection(botId, marketId, connect, options) {
+    const id = requireRecordId(botId, "botId");
+    if (isConfirmOptions(options)) return this.confirmTx(id, requireTxHash(options.txHash));
+    const market = requireMarketId(marketId);
+    return this.twoLeg(options, {
+      build: () => this.http.post(this.path(id, "connect"), { marketId: market, connect }, BUILD),
+      confirm: (txHash) => this.confirmTx(id, txHash),
+      check: async (prepared, signer) => {
+        const steps = "steps" in prepared && Array.isArray(prepared.steps) ? prepared.steps : [];
+        const authorities = new Set(steps.map((step) => step.authority));
+        if (authorities.has("BOT_OWNER")) {
+          const bot = await this.get(id);
+          if (!sameAddress(bot.ownerWallet, signer)) {
+            throw new ValidationError(`The bot is owned by ${bot.ownerWallet}, not by the signer ${signer}, and a step of this plan needs the owner. Prepare without a signer and sign each step from the wallet its authority names`);
+          }
+        }
+        if (authorities.has("MARKET_ADMIN")) await this.assertSignerRoles(market, signer, ["MARKET_ADMIN"]);
+      }
+    });
+  }
+  async action(botId, body, options) {
+    const id = requireRecordId(botId, "botId");
+    if (isConfirmOptions(options)) return this.confirmTx(id, requireTxHash(options.txHash));
+    if (isSignOptions(options)) {
+      const signer = await walletOf(options, void 0, "signer");
+      const bot = await this.get(id);
+      if (!sameAddress(bot.ownerWallet, signer)) {
+        throw new ValidationError(`The bot is owned by ${bot.ownerWallet}, not by the signer ${signer}, and this action is the owner's own call. Prepare without a signer and sign it from ${bot.ownerWallet}`);
+      }
+    }
+    return this.twoLeg(options, {
+      build: () => this.http.post(this.path(id, "action"), compact(body), BUILD),
+      confirm: (txHash) => this.confirmTx(id, txHash)
+    });
+  }
+};
+
+// src/modules/lending/vaults.ts
+var CURRENCY_RE = /^[A-Za-z0-9.]{2,12}$/;
+var LendingVaults = class extends LendingArea {
+  path(vaultId, rest = "") {
+    const base = `${LENDING_BASE}/vaults/${enc(requireRecordId(vaultId, "vaultId"))}`;
+    return rest ? `${base}/${rest}` : base;
+  }
+  groupPath(groupId, rest = "") {
+    const base = `${LENDING_BASE}/vaults/groups/${enc(requireRecordId(groupId, "groupId"))}`;
+    return rest ? `${base}/${rest}` : base;
+  }
+  confirmTx(vaultId, txHash, txType) {
+    return this.http.post(this.path(vaultId, "confirm-tx"), { txHash, txType }, CONFIRM);
+  }
+  async list() {
+    return this.http.get(`${LENDING_BASE}/vaults`);
+  }
+  async get(vaultId, options = {}) {
+    return this.http.get(this.path(vaultId), { address: optionalWallet(options.address, "address") });
+  }
+  async group(groupId, options = {}) {
+    return this.http.get(this.groupPath(groupId), { holderAddress: optionalWallet(options.holderAddress, "holderAddress") });
+  }
+  async transactions(vaultId, options = {}) {
+    return this.http.get(this.path(vaultId, "transactions"), {
+      limit: optionalInt(options.limit, "limit", 1, 200),
+      offset: optionalInt(options.offset, "offset", 0, Number.MAX_SAFE_INTEGER),
+      address: optionalWallet(options.address, "address")
+    });
+  }
+  async position(vaultId, holderAddress) {
+    return this.http.get(this.path(vaultId, `position/${requireWallet(holderAddress, "holderAddress")}`));
+  }
+  async earnings(vaultId) {
+    return this.http.get(this.path(vaultId, "earnings"));
+  }
+  async deposit(vaultId, input, options) {
+    const id = requireRecordId(vaultId, "vaultId");
+    if (isConfirmOptions(options)) return this.confirmTx(id, requireTxHash(options.txHash), "DEPOSIT");
+    const body = {
+      amount: requireAmount(input?.amount, "amount"),
+      holderAddress: optionalWallet(input?.holderAddress, "holderAddress")
+    };
+    if (isSignOptions(options)) body.holderAddress = await walletOf(options, body.holderAddress, "holderAddress");
+    return this.twoLeg(options, {
+      build: () => this.http.post(this.path(id, "deposit"), compact(body), BUILD),
+      confirm: (txHash) => this.confirmTx(id, txHash, "DEPOSIT")
+    });
+  }
+  async redeem(vaultId, input, options) {
+    const id = requireRecordId(vaultId, "vaultId");
+    if (isConfirmOptions(options)) return this.confirmTx(id, requireTxHash(options.txHash), "REDEEM");
+    const body = {
+      shares: requireAmount(input?.shares, "shares"),
+      holderAddress: optionalWallet(input?.holderAddress, "holderAddress")
+    };
+    if (isSignOptions(options)) body.holderAddress = await walletOf(options, body.holderAddress, "holderAddress");
+    else if (!body.holderAddress) throw new ValidationError("holderAddress is required: it is the wallet whose shares are redeemed");
+    return this.twoLeg(options, {
+      build: () => this.http.post(this.path(id, "redeem"), body, BUILD),
+      confirm: (txHash) => this.confirmTx(id, txHash, "REDEEM")
+    });
+  }
+  async depositToGroup(groupId, input, options) {
+    const path = this.groupPath(groupId, "deposit");
+    if (isConfirmOptions(options)) {
+      const pocket = requireRecordId(input?.vaultId, "vaultId");
+      return this.confirmTx(pocket, requireTxHash(options.txHash), "DEPOSIT");
+    }
+    const full = input;
+    const currency = full?.currency === void 0 ? void 0 : requireString(full.currency, "currency");
+    if (currency !== void 0 && !CURRENCY_RE.test(currency)) {
+      throw new ValidationError("currency must be a currency or asset symbol such as USDC, EURC, USD or EUR");
+    }
+    const asset = optionalWallet(full?.asset, "asset");
+    if (currency === void 0 === (asset === void 0)) {
+      throw new ValidationError("Name the pocket by exactly one of currency and asset");
+    }
+    const body = {
+      amount: requireAmount(full?.amount, "amount"),
+      currency,
+      asset,
+      holderAddress: optionalWallet(full?.holderAddress, "holderAddress")
+    };
+    if (isSignOptions(options)) body.holderAddress = await walletOf(options, body.holderAddress, "holderAddress");
+    return this.twoLeg(options, {
+      build: () => this.http.post(path, compact(body), BUILD),
+      confirm: (txHash, prepared) => {
+        if (!prepared?.vaultId) throw new ValidationError("The group deposit build named no pocket vault to confirm against");
+        return this.confirmTx(prepared.vaultId, txHash, "DEPOSIT");
+      }
+    });
+  }
+  async collectDistributorFees(vaultId, input, options) {
+    return this.distributorAction(vaultId, "distributor-fees/collect", options, async () => {
+      const body = {
+        marketAddress: requireWallet(input?.marketAddress, "marketAddress"),
+        signerAddress: optionalWallet(input?.signerAddress, "signerAddress")
+      };
+      if (isSignOptions(options)) body.signerAddress = await walletOf(options, body.signerAddress, "signerAddress");
+      return body;
+    });
+  }
+  async payDistributor(vaultId, input, options) {
+    assertInputIsNotOptions(input, "payDistributor(vaultId, {}, { signer })");
+    return this.distributorAction(vaultId, "distributor-fees/pay", options, async () => ({
+      distributor: optionalWallet(input?.distributor, "distributor")
+    }));
+  }
+  async payOperatorFees(vaultId, options) {
+    return this.distributorAction(vaultId, "operator-fees/pay", options, async () => ({}));
+  }
+  async setDistributorWallet(vaultId, input, options) {
+    return this.distributorAction(vaultId, "distributor-wallet", options, async () => {
+      const body = {
+        wallet: requireWallet(input?.wallet, "wallet"),
+        distributor: optionalWallet(input?.distributor, "distributor"),
+        signerAddress: optionalWallet(input?.signerAddress, "signerAddress")
+      };
+      if (isSignOptions(options)) body.signerAddress = await walletOf(options, body.signerAddress, "signerAddress");
+      return body;
+    });
+  }
+  async setDistributorApproval(vaultId, input, options) {
+    return this.distributorAction(vaultId, "distributor-approval", options, async () => {
+      const body = {
+        distributor: requireWallet(input?.distributor, "distributor"),
+        approved: requireBoolean(input?.approved, "approved"),
+        signerAddress: optionalWallet(input?.signerAddress, "signerAddress")
+      };
+      if (isSignOptions(options)) body.signerAddress = await walletOf(options, body.signerAddress, "signerAddress");
+      return body;
+    });
+  }
+  async distributorAction(vaultId, action, options, body) {
+    const path = this.path(vaultId, action);
+    const confirm = (txHash) => this.http.post(path, { txHash }, CONFIRM);
+    if (isConfirmOptions(options)) return confirm(requireTxHash(options.txHash));
+    const payload = compact(await body());
+    return this.twoLeg(options, {
+      build: () => this.http.post(path, payload, BUILD),
+      confirm
+    });
+  }
+};
+
+// src/modules/lending/pledges.ts
+var LendingPledges = class extends LendingArea {
+  async list(marketAddress, options = {}) {
+    const includeEnded = optionalBoolean(options.includeEnded, "includeEnded");
+    return this.http.get(`${LENDING_BASE}/pledges/${requireWallet(marketAddress, "marketAddress")}`, {
+      offset: optionalInt(options.offset, "offset", 0, Number.MAX_SAFE_INTEGER),
+      limit: optionalInt(options.limit, "limit", 1, 200),
+      includeEnded: includeEnded === void 0 ? void 0 : String(includeEnded)
+    });
+  }
+};
+
+// src/modules/lending/documents.ts
+var VISIBILITIES = ["public", "private"];
+var LOAN_ID_RE = /^\d{1,30}$/;
+var SHA256_RE = /^(0x)?[0-9a-fA-F]{64}$/;
+function loanIdOf(value) {
+  const text = value === void 0 || value === null ? "0" : String(value).trim();
+  if (!LOAN_ID_RE.test(text)) throw new ValidationError("loanId must be a whole number: 0 for the market itself, or the id of a loan the market opened");
+  return text;
+}
+function contentHashOf(value) {
+  if (typeof value !== "string" || !SHA256_RE.test(value.trim())) {
+    throw new ValidationError("contentHash must be the SHA-256 of the exact file bytes: 64 hex characters, with or without 0x");
+  }
+  return value.trim();
+}
+function documentBody(input) {
+  return compact({
+    loanId: loanIdOf(input?.loanId),
+    name: requireString(input?.name, "name"),
+    contentHash: contentHashOf(input?.contentHash),
+    visibility: requireOneOf(input?.visibility, "visibility", VISIBILITIES),
+    uri: input?.uri === void 0 ? void 0 : requireString(input.uri, "uri")
+  });
+}
+async function sha256Hex(bytes) {
+  const digest = new Uint8Array(await crypto.subtle.digest("SHA-256", Uint8Array.from(bytes)));
+  return Array.from(digest, (b) => b.toString(16).padStart(2, "0")).join("");
+}
+var LendingDocuments = class extends LendingArea {
+  path(marketId, rest) {
+    return `${LENDING_BASE}/markets/${enc(requireMarketId(marketId))}/legal-documents${rest}`;
+  }
+  async list(marketId, loanId) {
+    return this.http.get(this.path(marketId, ""), { loanId: loanId === void 0 ? void 0 : loanIdOf(loanId) });
+  }
+  async set(marketId, input, options) {
+    return this.write(marketId, this.path(marketId, ""), { action: "set", ...documentBody(input) }, options);
+  }
+  async remove(marketId, input, options) {
+    const body = { action: "remove", loanId: loanIdOf(input?.loanId), name: requireString(input?.name, "name") };
+    return this.write(marketId, this.path(marketId, ""), body, options);
+  }
+  async stage(marketId, input) {
+    return this.http.post(this.path(marketId, "/stage"), { ...documentBody(input), submittedBy: requireWallet(input?.submittedBy, "submittedBy") }, BUILD);
+  }
+  async record(marketId, stageId, options) {
+    const path = this.path(marketId, `/staged/${enc(requireRecordId(stageId, "stageId"))}/record`);
+    return this.write(marketId, path, {}, options);
+  }
+  async dismiss(marketId, stageId) {
+    return this.http.post(this.path(marketId, `/staged/${enc(requireRecordId(stageId, "stageId"))}/dismiss`), {}, BUILD);
+  }
+  async upload(file, input) {
+    if (input?.noPersonalData !== true) {
+      throw new ValidationError("A public document is pinned to IPFS for good: confirm it carries no personal data with { noPersonalData: true }");
+    }
+    let bytes;
+    if (typeof Blob !== "undefined" && file instanceof Blob) bytes = new Uint8Array(await file.arrayBuffer());
+    else if (file instanceof Uint8Array) bytes = Uint8Array.from(file);
+    else throw new ValidationError("file must be a Blob or a Uint8Array of the PDF bytes");
+    if (bytes.length === 0) throw new ValidationError("file is empty");
+    const contentHash = input.contentHash === void 0 ? await sha256Hex(bytes) : contentHashOf(input.contentHash);
+    const form = new FormData();
+    form.append("contentHash", contentHash);
+    form.append("noPersonalData", "true");
+    form.append("file", new Blob([bytes], { type: "application/pdf" }), "document.pdf");
+    return this.http.postForm(`${LENDING_BASE}/markets/legal-documents/upload`, form, void 0, { timeoutMs: DOCUMENT_TIMEOUT_MS });
+  }
+  async write(marketId, path, body, options) {
+    const confirm = (txHash) => this.http.post(this.path(marketId, "/confirm"), { txHash: requireTxHash(txHash) }, CONFIRM);
+    const signerAddress2 = isSignOptions(options) ? await walletOf(options, void 0, "signerAddress") : void 0;
+    return this.twoLeg(options, {
+      build: () => this.http.post(path, compact({ ...body, signerAddress: signerAddress2 }), BUILD),
+      confirm,
+      check: async (prepared, signer) => {
+        if (prepared.signer && !sameAddress(prepared.signer, signer)) {
+          throw new ValidationError(`This document record must be signed by the market admin ${prepared.signer}, but the signer is ${signer}. Nothing was signed`);
+        }
+      }
+    });
+  }
+};
+
+// src/modules/lending/index.ts
+var Lending = class {
+  constructor(http, context = new LendingContext(http)) {
+    this.markets = new LendingMarkets(context);
+    this.operators = new LendingOperators(context);
+    this.assetData = new LendingAssetData(context);
+    this.accessLists = new LendingAccessLists(context);
+    this.rates = new LendingRates(context);
+    this.terms = new LendingTerms(context);
+    this.oracle = new LendingOracle(context);
+    this.liquidity = new LendingLiquidity(context);
+    this.loans = new LendingLoans(context);
+    this.fees = new LendingFees(context);
+    this.insurance = new LendingInsurance(context);
+    this.liquidations = new LendingLiquidations(context);
+    this.auctions = new LendingAuctions(context);
+    this.hooks = new LendingHooks(context);
+    this.bots = new LendingBots(context);
+    this.vaults = new LendingVaults(context);
+    this.pledges = new LendingPledges(context);
+    this.documents = new LendingDocuments(context);
+  }
+};
+
+export {
+  LendingMarkets,
+  LendingOperators,
+  LendingRates,
+  LendingAssetData,
+  LendingAccessLists,
+  LendingTerms,
+  LendingOracle,
+  LendingLiquidity,
+  LendingLoans,
+  LendingFees,
+  LendingInsurance,
+  LendingLiquidations,
+  LendingAuctions,
+  LendingHooks,
+  LendingBots,
+  LendingVaults,
+  LendingPledges,
+  LendingDocuments,
+  Lending
+};