@trusset/sdk 0.1.0 → 0.5.0

package/dist/index.js

@@ -1,73 +1,56 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  AuthError: () => AuthError,
-  CustomerIdLinks: () => CustomerIdLinks,
-  CustomerIdentity: () => CustomerIdentity,
-  CustomerManagement: () => CustomerManagement,
-  CustomerSync: () => CustomerSync,
-  Customers: () => Customers,
-  NetworkError: () => NetworkError,
-  TrussetClient: () => TrussetClient,
-  TrussetError: () => TrussetError,
-  ValidationError: () => ValidationError
-});
-module.exports = __toCommonJS(index_exports);
-
-// 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);
-  }
-};
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+
+
+
+
+
+
+var _chunkACXAKW5Ejs = require('./chunk-ACXAKW5E.js');
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _chunk2KHUPARHjs = require('./chunk-2KHUPARH.js');
+
+
+var _chunkGWMT6UU7js = require('./chunk-GWMT6UU7.js');
+
+
+var _chunk7HFMHYRAjs = require('./chunk-7HFMHYRA.js');
+
+
+
+
+
+
+var _chunkAI4ZNJLRjs = require('./chunk-AI4ZNJLR.js');
+
+// 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() {
   },
@@ -81,28 +64,44 @@ var silentLogger = {
 var HttpClient = class {
   constructor(config) {
     this.config = {
-      baseUrl: config.baseUrl ?? "https://api.trusset.org",
+      baseUrl: _nullishCoalesce(config.baseUrl, () => ( "https://api.trusset.org")),
       apiKey: config.apiKey,
-      timeoutMs: config.timeoutMs ?? 3e4,
-      maxRetries: config.maxRetries ?? 3,
-      logger: config.logger ?? silentLogger
+      timeoutMs: _nullishCoalesce(config.timeoutMs, () => ( 3e4)),
+      maxRetries: _nullishCoalesce(config.maxRetries, () => ( 3)),
+      logger: _nullishCoalesce(config.logger, () => ( silentLogger)),
+      fetch: _nullishCoalesce(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 post(path, body) {
-    const url = this.buildUrl(path);
-    return this.request("POST", url, body);
+  async getBinary(path, params, options) {
+    return this.requestBinary(this.buildUrl(path, params), options);
   }
-  async put(path, body) {
-    const url = this.buildUrl(path);
-    return this.request("PUT", url, body);
+  async post(path, body, options) {
+    const { data } = await this.requestEnvelope("POST", this.buildUrl(path), body, options);
+    return data;
   }
-  async delete(path) {
-    const url = this.buildUrl(path);
-    return this.request("DELETE", url);
+  async put(path, body, options) {
+    const { data } = await this.requestEnvelope("PUT", this.buildUrl(path), body, options);
+    return data;
+  }
+  async patch(path, body, options) {
+    const { data } = await this.requestEnvelope("PATCH", this.buildUrl(path), body, options);
+    return data;
+  }
+  async delete(path, options) {
+    const { data } = await this.requestEnvelope("DELETE", this.buildUrl(path), void 0, options);
+    return data;
+  }
+  async postForm(path, form, params, options) {
+    const { data } = await this.requestEnvelope("POST", this.buildUrl(path, params), form, options);
+    return data;
   }
   // -----------------------------------------------------------------------
   buildUrl(path, params) {
@@ -118,468 +117,174 @@ 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 (_optionalChain([options, 'optionalAccess', _ => _.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, _nullishCoalesce(_optionalChain([options, 'optionalAccess', _2 => _2.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 (e) {
+        throw new (0, _chunkAI4ZNJLRjs.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: _nullishCoalesce(json.metadata, () => ( EMPTY_METADATA)) };
+    });
+  }
+  async requestBinary(url, options) {
+    const timeoutMs = Math.max(this.config.timeoutMs, _nullishCoalesce(_optionalChain([options, 'optionalAccess', _3 => _3.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 = _nullishCoalesce(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 (0, _chunkAI4ZNJLRjs.AuthError)(
+        _nullishCoalesce(_optionalChain([json, 'access', _4 => _4.error, 'optionalAccess', _5 => _5.message]), () => ( "Authentication failed")),
+        _optionalChain([json, 'access', _6 => _6.metadata, 'optionalAccess', _7 => _7.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 _chunkAI4ZNJLRjs.AuthError) throw err;
+        if (err instanceof _chunkAI4ZNJLRjs.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 (0, _chunkAI4ZNJLRjs.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 = _nullishCoalesce(_optionalChain([json, 'optionalAccess', _8 => _8.error]), () => ( {}));
+  const { code, message, details, ...rest } = error;
+  const metadata = _nullishCoalesce(_optionalChain([json, 'optionalAccess', _9 => _9.metadata]), () => ( {}));
+  return new (0, _chunkAI4ZNJLRjs.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");
+      throw new (0, _chunkAI4ZNJLRjs.ValidationError)("A valid apiKey is required");
+    }
+    if (!config.apiKey.startsWith("trusset_")) {
+      throw new (0, _chunkAI4ZNJLRjs.ValidationError)("apiKey must be a Trusset instance API key (they start with 'trusset_')");
     }
     this.http = new HttpClient({
       apiKey: config.apiKey,
@@ -588,19 +293,44 @@ var TrussetClient = class {
       maxRetries: config.maxRetries,
       logger: config.logger
     });
-    this.customers = new Customers(this.http);
+    const context = new (0, _chunk7HFMHYRAjs.LendingContext)(this.http);
+    this.customers = new (0, _chunkACXAKW5Ejs.Customers)(this.http, context);
+    this.lending = new (0, _chunk2KHUPARHjs.Lending)(this.http, context);
+    this.tokens = new (0, _chunkGWMT6UU7js.Tokens)(context);
   }
 };
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  AuthError,
-  CustomerIdLinks,
-  CustomerIdentity,
-  CustomerManagement,
-  CustomerSync,
-  Customers,
-  NetworkError,
-  TrussetClient,
-  TrussetError,
-  ValidationError
-});
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.AuthError = _chunkAI4ZNJLRjs.AuthError; exports.ConfirmationError = _chunkAI4ZNJLRjs.ConfirmationError; exports.CustomerIdLinks = _chunkACXAKW5Ejs.CustomerIdLinks; exports.CustomerIdentity = _chunkACXAKW5Ejs.CustomerIdentity; exports.CustomerManagement = _chunkACXAKW5Ejs.CustomerManagement; exports.CustomerSync = _chunkACXAKW5Ejs.CustomerSync; exports.CustomerVerificationProfiles = _chunkACXAKW5Ejs.CustomerVerificationProfiles; exports.Customers = _chunkACXAKW5Ejs.Customers; exports.Lending = _chunk2KHUPARHjs.Lending; exports.LendingAccessLists = _chunk2KHUPARHjs.LendingAccessLists; exports.LendingAssetData = _chunk2KHUPARHjs.LendingAssetData; exports.LendingAuctions = _chunk2KHUPARHjs.LendingAuctions; exports.LendingBots = _chunk2KHUPARHjs.LendingBots; exports.LendingDocuments = _chunk2KHUPARHjs.LendingDocuments; exports.LendingFees = _chunk2KHUPARHjs.LendingFees; exports.LendingHooks = _chunk2KHUPARHjs.LendingHooks; exports.LendingInsurance = _chunk2KHUPARHjs.LendingInsurance; exports.LendingLiquidations = _chunk2KHUPARHjs.LendingLiquidations; exports.LendingLiquidity = _chunk2KHUPARHjs.LendingLiquidity; exports.LendingLoans = _chunk2KHUPARHjs.LendingLoans; exports.LendingMarkets = _chunk2KHUPARHjs.LendingMarkets; exports.LendingOperators = _chunk2KHUPARHjs.LendingOperators; exports.LendingOracle = _chunk2KHUPARHjs.LendingOracle; exports.LendingPledges = _chunk2KHUPARHjs.LendingPledges; exports.LendingRates = _chunk2KHUPARHjs.LendingRates; exports.LendingTerms = _chunk2KHUPARHjs.LendingTerms; exports.LendingVaults = _chunk2KHUPARHjs.LendingVaults; exports.NetworkError = _chunkAI4ZNJLRjs.NetworkError; exports.Tokens = _chunkGWMT6UU7js.Tokens; exports.TrussetClient = TrussetClient; exports.TrussetError = _chunkAI4ZNJLRjs.TrussetError; exports.ValidationError = _chunkAI4ZNJLRjs.ValidationError; exports.manifestToVerifyInput = _chunkACXAKW5Ejs.manifestToVerifyInput;