@trusset/sdk 0.1.0 → 0.5.0

package/dist/index.mjs

@@ -1,38 +1,56 @@
-// src/utils/errors.ts
-var TrussetError = class _TrussetError extends Error {
-  constructor(message, code, statusCode, requestId) {
-    super(message);
-    this.name = "TrussetError";
-    this.code = code;
-    this.statusCode = statusCode;
-    this.requestId = requestId ?? null;
-    Object.setPrototypeOf(this, _TrussetError.prototype);
-  }
-};
-var AuthError = class _AuthError extends TrussetError {
-  constructor(message, requestId) {
-    super(message, "AUTH_FAILED", 401, requestId);
-    this.name = "AuthError";
-    Object.setPrototypeOf(this, _AuthError.prototype);
-  }
-};
-var ValidationError = class _ValidationError extends TrussetError {
-  constructor(message) {
-    super(message, "VALIDATION_ERROR", 400);
-    this.name = "ValidationError";
-    Object.setPrototypeOf(this, _ValidationError.prototype);
-  }
-};
-var NetworkError = class _NetworkError extends TrussetError {
-  constructor(message) {
-    super(message, "NETWORK_ERROR", 0);
-    this.name = "NetworkError";
-    Object.setPrototypeOf(this, _NetworkError.prototype);
-  }
-};
+import {
+  CustomerIdLinks,
+  CustomerIdentity,
+  CustomerManagement,
+  CustomerSync,
+  CustomerVerificationProfiles,
+  Customers,
+  manifestToVerifyInput
+} from "./chunk-OQG3PEF3.mjs";
+import {
+  Lending,
+  LendingAccessLists,
+  LendingAssetData,
+  LendingAuctions,
+  LendingBots,
+  LendingDocuments,
+  LendingFees,
+  LendingHooks,
+  LendingInsurance,
+  LendingLiquidations,
+  LendingLiquidity,
+  LendingLoans,
+  LendingMarkets,
+  LendingOperators,
+  LendingOracle,
+  LendingPledges,
+  LendingRates,
+  LendingTerms,
+  LendingVaults
+} from "./chunk-4MNJZAXE.mjs";
+import {
+  Tokens
+} from "./chunk-C7CANC53.mjs";
+import {
+  LendingContext
+} from "./chunk-DQCX2GYT.mjs";
+import {
+  AuthError,
+  ConfirmationError,
+  NetworkError,
+  TrussetError,
+  ValidationError
+} from "./chunk-3YF42MHV.mjs";
+
+// src/version.ts
+var SDK_VERSION = "0.5.0";
 
 // src/utils/http.ts
 var RETRYABLE_STATUS = /* @__PURE__ */ new Set([408, 429, 500, 502, 503, 504]);
+var CONFIRM_RETRYABLE_STATUS = /* @__PURE__ */ new Set([408, 429, 502, 503, 504]);
+var MAX_RETRY_AFTER_MS = 6e4;
+var NOT_FOUND_DELAYS_MS = [3e3, 6e3, 12e3];
+var EMPTY_METADATA = { requestId: "", timestamp: "" };
 var silentLogger = {
   debug() {
   },
@@ -50,24 +68,40 @@ var HttpClient = class {
       apiKey: config.apiKey,
       timeoutMs: config.timeoutMs ?? 3e4,
       maxRetries: config.maxRetries ?? 3,
-      logger: config.logger ?? silentLogger
+      logger: config.logger ?? silentLogger,
+      fetch: config.fetch ?? ((input, init) => fetch(input, init))
     };
   }
-  async get(path, params) {
-    const url = this.buildUrl(path, params);
-    return this.request("GET", url);
+  async get(path, params, options) {
+    const { data } = await this.requestEnvelope("GET", this.buildUrl(path, params), void 0, options);
+    return data;
+  }
+  /** GET that also returns the response metadata (used for list totals). */
+  async getWithMeta(path, params) {
+    return this.requestEnvelope("GET", this.buildUrl(path, params));
+  }
+  async getBinary(path, params, options) {
+    return this.requestBinary(this.buildUrl(path, params), options);
+  }
+  async post(path, body, options) {
+    const { data } = await this.requestEnvelope("POST", this.buildUrl(path), body, options);
+    return data;
+  }
+  async put(path, body, options) {
+    const { data } = await this.requestEnvelope("PUT", this.buildUrl(path), body, options);
+    return data;
   }
-  async post(path, body) {
-    const url = this.buildUrl(path);
-    return this.request("POST", url, body);
+  async patch(path, body, options) {
+    const { data } = await this.requestEnvelope("PATCH", this.buildUrl(path), body, options);
+    return data;
   }
-  async put(path, body) {
-    const url = this.buildUrl(path);
-    return this.request("PUT", url, body);
+  async delete(path, options) {
+    const { data } = await this.requestEnvelope("DELETE", this.buildUrl(path), void 0, options);
+    return data;
   }
-  async delete(path) {
-    const url = this.buildUrl(path);
-    return this.request("DELETE", url);
+  async postForm(path, form, params, options) {
+    const { data } = await this.requestEnvelope("POST", this.buildUrl(path, params), form, options);
+    return data;
   }
   // -----------------------------------------------------------------------
   buildUrl(path, params) {
@@ -83,469 +117,175 @@ var HttpClient = class {
     }
     return url.toString();
   }
-  async request(method, url, body) {
-    let lastError = null;
-    for (let attempt = 0; attempt <= this.config.maxRetries; attempt++) {
-      if (attempt > 0) {
-        const delay = Math.min(1e3 * Math.pow(2, attempt - 1), 1e4);
-        this.config.logger.debug(`Retry ${attempt}/${this.config.maxRetries} after ${delay}ms`, { url });
+  retryClass(method, options) {
+    if (options?.retry) return options.retry;
+    return method === "GET" ? "read" : "write";
+  }
+  // Writes are never blindly retried: identity writes are two-phase
+  // (prepare calldata, then confirm a mined transaction), and retrying a
+  // confirm after an ambiguous failure (5xx, timeout, dropped connection)
+  // could record the same transaction twice. 429 is the exception - the
+  // server rejected the request before doing any work.
+  canRetry(kind, status) {
+    if (kind === "read") return status === void 0 || RETRYABLE_STATUS.has(status);
+    if (kind === "confirm") return status === void 0 || CONFIRM_RETRYABLE_STATUS.has(status);
+    return status === 429;
+  }
+  headers(jsonBody, accept) {
+    const headers = {
+      "x-api-key": this.config.apiKey,
+      "Accept": accept,
+      "User-Agent": `@trusset/sdk/${SDK_VERSION}`
+    };
+    if (jsonBody) headers["Content-Type"] = "application/json";
+    return headers;
+  }
+  async send(method, url, body, timeoutMs, accept) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    const form = typeof FormData !== "undefined" && body instanceof FormData;
+    try {
+      return await this.config.fetch(url, {
+        method,
+        headers: this.headers(body !== void 0 && !form, accept),
+        body: body === void 0 ? void 0 : form ? body : JSON.stringify(body),
+        signal: controller.signal
+      });
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  async requestEnvelope(method, url, body, options) {
+    const kind = this.retryClass(method, options);
+    const timeoutMs = Math.max(this.config.timeoutMs, options?.timeoutMs ?? 0);
+    return this.withRetries(kind, url, timeoutMs, async () => {
+      const res = await this.send(method, url, body, timeoutMs, "application/json");
+      await this.throwIfFailed(res);
+      let json;
+      try {
+        json = await res.json();
+      } catch {
+        throw new TrussetError(
+          `Server returned a non-JSON response (status ${res.status})`,
+          "BAD_RESPONSE",
+          res.status
+        );
+      }
+      if (!json.success) {
+        throw toApiError(json, res, `Request failed with status ${res.status}`);
+      }
+      return { data: json.data, metadata: json.metadata ?? EMPTY_METADATA };
+    });
+  }
+  async requestBinary(url, options) {
+    const timeoutMs = Math.max(this.config.timeoutMs, options?.timeoutMs ?? 0);
+    return this.withRetries(this.retryClass("GET", options), url, timeoutMs, async () => {
+      const res = await this.send("GET", url, void 0, timeoutMs, "*/*");
+      await this.throwIfFailed(res);
+      const contentType = res.headers.get("content-type") ?? "application/octet-stream";
+      if (contentType.includes("application/json")) {
+        const json = await res.json().catch(() => null);
+        throw toApiError(json, res, `Expected a document but the server answered with JSON (status ${res.status})`);
+      }
+      const bytes = new Uint8Array(await res.arrayBuffer());
+      return { bytes, contentType, filename: filenameOf(res.headers.get("content-disposition")) };
+    });
+  }
+  async throwIfFailed(res) {
+    if (res.status === 401) {
+      const json = await res.json().catch(() => ({}));
+      throw new AuthError(
+        json.error?.message ?? "Authentication failed",
+        json.metadata?.requestId
+      );
+    }
+    if (res.status >= 400) {
+      const json = await res.json().catch(() => null);
+      throw toApiError(json, res, `Server returned ${res.status}`);
+    }
+  }
+  async withRetries(kind, url, timeoutMs, attempt) {
+    let retries = 0;
+    let notFoundRetries = 0;
+    let delay = 0;
+    while (true) {
+      if (delay > 0) {
+        this.config.logger.debug(`Retry after ${delay}ms`, { url });
         await sleep(delay);
       }
       try {
-        const controller = new AbortController();
-        const timer = setTimeout(() => controller.abort(), this.config.timeoutMs);
-        const headers = {
-          "x-api-key": this.config.apiKey,
-          "Accept": "application/json",
-          "User-Agent": "@trusset/sdk/0.1.0"
-        };
-        if (body !== void 0) {
-          headers["Content-Type"] = "application/json";
-        }
-        const res = await fetch(url, {
-          method,
-          headers,
-          body: body !== void 0 ? JSON.stringify(body) : void 0,
-          signal: controller.signal
-        });
-        clearTimeout(timer);
-        if (res.status === 401) {
-          const json2 = await res.json().catch(() => ({}));
-          throw new AuthError(
-            json2.error?.message ?? "Authentication failed",
-            json2.metadata?.requestId
-          );
-        }
-        if (RETRYABLE_STATUS.has(res.status)) {
-          lastError = new TrussetError(
-            `Server returned ${res.status}`,
-            "SERVER_ERROR",
-            res.status
-          );
-          continue;
-        }
-        const json = await res.json();
-        if (!json.success) {
-          throw new TrussetError(
-            json.error?.message ?? `Request failed with status ${res.status}`,
-            json.error?.code ?? "REQUEST_FAILED",
-            res.status,
-            json.metadata?.requestId
-          );
-        }
-        return json.data;
+        return await attempt();
       } catch (err) {
-        if (err instanceof TrussetError) {
-          if (!RETRYABLE_STATUS.has(err.statusCode)) throw err;
-          lastError = err;
+        if (err instanceof AuthError) throw err;
+        if (err instanceof TrussetError && err.statusCode > 0) {
+          if (kind !== "read" && err.code === "TX_NOT_FOUND") {
+            if (notFoundRetries >= NOT_FOUND_DELAYS_MS.length) throw err;
+            delay = NOT_FOUND_DELAYS_MS[notFoundRetries];
+            notFoundRetries += 1;
+            continue;
+          }
+          if (!this.canRetry(kind, err.statusCode) || retries >= this.config.maxRetries) throw err;
+          retries += 1;
+          delay = err.statusCode === 429 && err.retryAfter !== null ? Math.min(err.retryAfter * 1e3, MAX_RETRY_AFTER_MS) : backoff(retries);
           continue;
         }
         if (err instanceof TypeError || err instanceof DOMException && err.name === "AbortError") {
-          lastError = new NetworkError(
-            err instanceof DOMException ? "Request timed out" : `Network error: ${err.message}`
+          const netError = new NetworkError(
+            err instanceof DOMException ? `Request timed out after ${timeoutMs}ms` : `Network error: ${err.message}`
           );
+          if (!this.canRetry(kind) || retries >= this.config.maxRetries) throw netError;
+          retries += 1;
+          delay = backoff(retries);
           continue;
         }
         throw err;
       }
     }
-    throw lastError ?? new NetworkError("Request failed after retries");
   }
 };
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
+function toApiError(json, res, fallback) {
+  const error = json?.error ?? {};
+  const { code, message, details, ...rest } = error;
+  const metadata = json?.metadata ?? {};
+  return new TrussetError(
+    typeof message === "string" ? message : fallback,
+    typeof code === "string" ? code : res.status >= 500 ? "SERVER_ERROR" : "REQUEST_FAILED",
+    res.status,
+    typeof metadata.requestId === "string" ? metadata.requestId : void 0,
+    {
+      details,
+      data: Object.keys(rest).length ? rest : null,
+      retryAfter: res.status === 429 ? retryAfterOf(res, metadata) : null
+    }
+  );
 }
-
-// src/utils/validation.ts
-var ETH_ADDRESS_RE = /^0x[0-9a-fA-F]{40}$/;
-function requireString(value, field) {
-  if (typeof value !== "string" || value.trim().length === 0) {
-    throw new ValidationError(`${field} is required and must be a non-empty string`);
-  }
-  return value.trim();
+function retryAfterOf(res, metadata) {
+  const header = res.headers.get("retry-after");
+  if (header !== null && /^\d+$/.test(header.trim())) return Number(header.trim());
+  if (typeof metadata.retryAfter === "number" && Number.isFinite(metadata.retryAfter)) return Math.max(0, metadata.retryAfter);
+  return null;
 }
-function requireAddress(value, field) {
-  const s = requireString(value, field);
-  if (!ETH_ADDRESS_RE.test(s)) {
-    throw new ValidationError(`${field} must be a valid Ethereum address`);
-  }
-  return s;
+function filenameOf(disposition) {
+  if (!disposition) return null;
+  const match = /filename="?([^";]+)"?/i.exec(disposition);
+  return match ? match[1] : null;
 }
-function optionalAddress(value, field) {
-  if (value === void 0 || value === null || value === "") return void 0;
-  return requireAddress(value, field);
+function backoff(attempt) {
+  return Math.min(1e3 * Math.pow(2, attempt - 1), 1e4);
 }
-function requireCountry(value, field) {
-  const s = requireString(value, field);
-  if (s.length < 2 || s.length > 3) {
-    throw new ValidationError(`${field} must be a 2-3 letter country code`);
-  }
-  return s.toUpperCase();
-}
-function clampInt(value, min, max, fallback) {
-  if (value === void 0 || value === null) return fallback;
-  const n = Math.floor(value);
-  if (isNaN(n)) return fallback;
-  return Math.max(min, Math.min(max, n));
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
-// src/modules/customers/management.ts
-var CustomerManagement = class {
-  constructor(http) {
-    this.http = http;
-  }
-  /**
-   * List customers for the current instance.
-   */
-  async list(options = {}) {
-    const params = {
-      limit: clampInt(options.limit, 1, 200, 100),
-      offset: clampInt(options.offset, 0, Number.MAX_SAFE_INTEGER, 0),
-      includeArchived: options.includeArchived ? "true" : void 0,
-      search: options.search || void 0
-    };
-    return this.http.get("/customers/api/manage", params);
-  }
-  /**
-   * Get a customer by wallet address, ID, externalId, or referenceKey.
-   */
-  async get(identifier) {
-    requireString(identifier, "identifier");
-    return this.http.get(`/customers/api/manage/${encodeURIComponent(identifier)}`);
-  }
-  /**
-   * Create a new customer record.
-   */
-  async create(input) {
-    if (input.walletAddress) optionalAddress(input.walletAddress, "walletAddress");
-    return this.http.post("/customers/api/manage", input);
-  }
-  /**
-   * Update an existing customer.
-   */
-  async update(customerId, input) {
-    requireString(customerId, "customerId");
-    return this.http.put(`/customers/api/manage/${encodeURIComponent(customerId)}`, input);
-  }
-  /**
-   * Archive (soft-delete) a customer.
-   */
-  async archive(customerId) {
-    requireString(customerId, "customerId");
-    return this.http.delete(`/customers/api/manage/${encodeURIComponent(customerId)}`);
-  }
-  /**
-   * Link a wallet address to a customer created via referenceKey.
-   */
-  async linkWallet(input) {
-    requireString(input.referenceKey, "referenceKey");
-    requireAddress(input.walletAddress, "walletAddress");
-    return this.http.post("/customers/api/manage/link-wallet", input);
-  }
-  /**
-   * Batch-fetch country codes for a list of wallet addresses.
-   */
-  async batchGetCountries(addresses) {
-    if (!Array.isArray(addresses) || addresses.length === 0) {
-      return {};
-    }
-    return this.http.post("/customers/api/manage/countries/batch", { addresses });
-  }
-  // -----------------------------------------------------------------------
-  // Convenience search helpers
-  // -----------------------------------------------------------------------
-  /**
-   * Search customers by name substring.
-   */
-  async searchByName(name, options) {
-    return this.list({ ...options, search: name });
-  }
-  /**
-   * Find a customer by wallet address.
-   */
-  async searchByWallet(walletAddress) {
-    requireAddress(walletAddress, "walletAddress");
-    return this.get(walletAddress);
-  }
-  /**
-   * Find a customer by external ID (your system's unique identifier).
-   */
-  async searchByExternalId(externalId) {
-    requireString(externalId, "externalId");
-    return this.get(externalId);
-  }
-  /**
-   * Find a customer by reference key (for pre-wallet customers).
-   */
-  async searchByReference(referenceKey) {
-    requireString(referenceKey, "referenceKey");
-    return this.get(referenceKey);
-  }
-};
-
-// src/modules/customers/identity.ts
-var CustomerIdentity = class {
-  constructor(http) {
-    this.http = http;
-  }
-  /**
-   * Verify a customer's identity on-chain via the IdentityRegistry contract.
-   * Requires a configured relayer on the instance.
-   */
-  async verify(input) {
-    requireAddress(input.walletAddress, "walletAddress");
-    requireCountry(input.country, "country");
-    return this.http.post("/customers/api/identity/verify", input);
-  }
-  /**
-   * Batch-verify up to 500 identities in a single transaction.
-   * Requires a configured relayer.
-   */
-  async batchVerify(entries) {
-    if (!Array.isArray(entries) || entries.length === 0 || entries.length > 500) {
-      throw new ValidationError("Provide 1-500 entries for batch verification");
-    }
-    for (const e of entries) {
-      requireAddress(e.walletAddress, "walletAddress");
-      requireCountry(e.country, "country");
-    }
-    return this.http.post("/customers/api/identity/batch-verify", { entries });
-  }
-  /**
-   * Revoke an identity on-chain. Requires a configured relayer.
-   */
-  async revoke(walletAddress) {
-    requireAddress(walletAddress, "walletAddress");
-    return this.http.post("/customers/api/identity/revoke", { walletAddress });
-  }
-  /**
-   * Get combined on-chain and off-chain identity status.
-   */
-  async getStatus(walletAddress) {
-    requireAddress(walletAddress, "walletAddress");
-    return this.http.get(`/customers/api/identity/status/${walletAddress}`);
-  }
-  /**
-   * Check whether a token transfer between two addresses is compliant.
-   * Runs identity checks + all registered compliance modules.
-   */
-  async canTransfer(input) {
-    requireAddress(input.from, "from");
-    requireAddress(input.to, "to");
-    return this.http.post("/customers/api/identity/can-transfer", input);
-  }
-};
-
-// src/modules/customers/id-links.ts
-var CustomerIdLinks = class {
-  constructor(http) {
-    this.http = http;
-  }
-  /**
-   * Create a KYC verification link to send to an investor.
-   */
-  async create(input) {
-    if (!input.recipientEmail && !input.recipientWallet && !input.recipientPhone) {
-      throw new ValidationError("At least one of recipientEmail, recipientWallet, or recipientPhone is required");
-    }
-    return this.http.post("/customers/api/id-links", input);
-  }
-  /**
-   * List all verification links for the current instance.
-   */
-  async list(options = {}) {
-    const params = {
-      limit: clampInt(options.limit, 1, 200, 50),
-      offset: clampInt(options.offset, 0, Number.MAX_SAFE_INTEGER, 0),
-      status: options.status
-    };
-    return this.http.get("/customers/api/id-links", params);
-  }
-  /**
-   * Revoke (expire) a verification link so it can no longer be used.
-   */
-  async revoke(linkId) {
-    requireString(linkId, "linkId");
-    await this.http.put(`/customers/api/id-links/${encodeURIComponent(linkId)}/revoke`);
-  }
-  /**
-   * Resend a verification link via the specified channels.
-   */
-  async resend(linkId, channels) {
-    requireString(linkId, "linkId");
-    if (!Array.isArray(channels) || channels.length === 0) {
-      throw new ValidationError("channels array is required (email and/or sms)");
-    }
-    return this.http.post(`/customers/api/id-links/${encodeURIComponent(linkId)}/resend`, { channels });
-  }
-};
-
-// src/modules/customers/sync.ts
-var DEFAULT_BATCH_SIZE = 50;
-var MAX_BATCH_SIZE = 200;
-var MAX_VERIFY_BATCH = 500;
-var CustomerSync = class {
-  constructor(http) {
-    this.http = http;
-  }
-  /**
-   * Import customer records from an external system.
-   *
-   * Each record is mapped by `externalId`. If a customer with that externalId
-   * already exists, the `onConflict` strategy determines whether to skip or
-   * update.
-   *
-   * When `verifyOnChain` is true, records that include a `walletAddress` and
-   * `country` will be batch-verified on-chain after the database import.
-   */
-  async importRecords(records, options = {}) {
-    if (!Array.isArray(records) || records.length === 0) {
-      throw new ValidationError("records must be a non-empty array");
-    }
-    const batchSize = clampInt(options.batchSize, 1, MAX_BATCH_SIZE, DEFAULT_BATCH_SIZE);
-    const onConflict = options.onConflict ?? "update";
-    const result = { total: records.length, created: 0, updated: 0, skipped: 0, errors: [] };
-    const verifyQueue = [];
-    for (let i = 0; i < records.length; i += batchSize) {
-      const batch = records.slice(i, i + batchSize);
-      const batchResults = await Promise.allSettled(
-        batch.map((record) => this.processRecord(record, onConflict))
-      );
-      for (let j = 0; j < batchResults.length; j++) {
-        const settled = batchResults[j];
-        const record = batch[j];
-        if (settled.status === "fulfilled") {
-          const outcome = settled.value;
-          if (outcome.action === "created") result.created++;
-          else if (outcome.action === "updated") result.updated++;
-          else result.skipped++;
-          if (options.verifyOnChain && record.walletAddress && record.country && outcome.action !== "skipped") {
-            verifyQueue.push({
-              walletAddress: record.walletAddress,
-              country: record.country,
-              investorType: record.investorType,
-              softExpiryDays: options.verificationDefaults?.softExpiryDays,
-              hardExpiryDays: options.verificationDefaults?.hardExpiryDays
-            });
-          }
-        } else {
-          const err = settled.reason;
-          result.errors.push({
-            externalId: record.externalId,
-            code: err?.code ?? "UNKNOWN",
-            message: err?.message ?? "Unknown error"
-          });
-        }
-      }
-      options.onProgress?.(Math.min(i + batchSize, records.length), records.length);
-    }
-    if (verifyQueue.length > 0) {
-      await this.runBatchVerification(verifyQueue, result);
-    }
-    return result;
-  }
-  /**
-   * Export all customers from Trusset as flat records.
-   * Useful for syncing data back into your system.
-   */
-  async exportRecords(options = {}) {
-    const allRecords = [];
-    let offset = 0;
-    const limit = 200;
-    while (true) {
-      const page = await this.http.get("/customers/api/manage", {
-        limit,
-        offset,
-        includeArchived: options.includeArchived ? "true" : void 0
-      });
-      if (!page.customers || page.customers.length === 0) break;
-      for (const c of page.customers) {
-        allRecords.push({
-          externalId: c.externalId ?? c.id,
-          walletAddress: c.walletAddress ?? void 0,
-          name: c.name ?? void 0,
-          country: c.country ?? void 0,
-          investorType: c.investorType ?? void 0,
-          metadata: c.metadata ?? void 0
-        });
-      }
-      offset += page.customers.length;
-      if (offset >= page.total) break;
-    }
-    return allRecords;
-  }
-  // -----------------------------------------------------------------------
-  // Internal
-  // -----------------------------------------------------------------------
-  async processRecord(record, onConflict) {
-    requireString(record.externalId, "externalId");
-    let existing = null;
-    try {
-      existing = await this.http.get(
-        `/customers/api/manage/${encodeURIComponent(record.externalId)}`
-      );
-    } catch (err) {
-      const code = err?.code;
-      const statusCode = err?.statusCode;
-      if (statusCode !== 404 && code !== "NOT_FOUND") throw err;
-    }
-    if (existing) {
-      if (onConflict === "skip") {
-        return { action: "skipped" };
-      }
-      await this.http.put(`/customers/api/manage/${encodeURIComponent(existing.id)}`, {
-        name: record.name,
-        country: record.country,
-        investorType: record.investorType,
-        walletAddress: record.walletAddress,
-        metadata: record.metadata
-      });
-      return { action: "updated" };
-    }
-    await this.http.post("/customers/api/manage", {
-      externalId: record.externalId,
-      walletAddress: record.walletAddress,
-      name: record.name,
-      country: record.country,
-      investorType: record.investorType,
-      metadata: record.metadata
-    });
-    return { action: "created" };
-  }
-  async runBatchVerification(queue, result) {
-    for (let i = 0; i < queue.length; i += MAX_VERIFY_BATCH) {
-      const batch = queue.slice(i, i + MAX_VERIFY_BATCH);
-      try {
-        await this.http.post("/customers/api/identity/batch-verify", { entries: batch });
-      } catch (err) {
-        for (const entry of batch) {
-          result.errors.push({
-            externalId: entry.walletAddress,
-            code: "VERIFY_FAILED",
-            message: err?.message ?? "On-chain batch verification failed"
-          });
-        }
-      }
-    }
-  }
-};
-
-// src/modules/customers/index.ts
-var Customers = class {
-  constructor(http) {
-    this.manage = new CustomerManagement(http);
-    this.identity = new CustomerIdentity(http);
-    this.idLinks = new CustomerIdLinks(http);
-    this.sync = new CustomerSync(http);
-  }
-};
-
 // src/client.ts
 var TrussetClient = class {
   constructor(config) {
     if (!config.apiKey || typeof config.apiKey !== "string" || config.apiKey.length < 20) {
       throw new ValidationError("A valid apiKey is required");
     }
+    if (!config.apiKey.startsWith("trusset_")) {
+      throw new ValidationError("apiKey must be a Trusset instance API key (they start with 'trusset_')");
+    }
     this.http = new HttpClient({
       apiKey: config.apiKey,
       baseUrl: config.baseUrl,
@@ -553,18 +293,44 @@ var TrussetClient = class {
       maxRetries: config.maxRetries,
       logger: config.logger
     });
-    this.customers = new Customers(this.http);
+    const context = new LendingContext(this.http);
+    this.customers = new Customers(this.http, context);
+    this.lending = new Lending(this.http, context);
+    this.tokens = new Tokens(context);
   }
 };
 export {
   AuthError,
+  ConfirmationError,
   CustomerIdLinks,
   CustomerIdentity,
   CustomerManagement,
   CustomerSync,
+  CustomerVerificationProfiles,
   Customers,
+  Lending,
+  LendingAccessLists,
+  LendingAssetData,
+  LendingAuctions,
+  LendingBots,
+  LendingDocuments,
+  LendingFees,
+  LendingHooks,
+  LendingInsurance,
+  LendingLiquidations,
+  LendingLiquidity,
+  LendingLoans,
+  LendingMarkets,
+  LendingOperators,
+  LendingOracle,
+  LendingPledges,
+  LendingRates,
+  LendingTerms,
+  LendingVaults,
   NetworkError,
+  Tokens,
   TrussetClient,
   TrussetError,
-  ValidationError
+  ValidationError,
+  manifestToVerifyInput
 };