infra-sdk-typescript 0.1.0

package/dist/index.js

@@ -0,0 +1,882 @@
+import { randomUUID, createHmac, timingSafeEqual } from 'crypto';
+
+// src/core/version.ts
+var SDK_VERSION = "0.1.0";
+
+// src/core/errors.ts
+var InfraError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = new.target.name;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var InfraConnectionError = class extends InfraError {
+  constructor(message, cause) {
+    super(message);
+    this.cause = cause;
+  }
+  cause;
+};
+var InfraConnectionTimeoutError = class extends InfraConnectionError {
+  constructor(timeoutMs) {
+    super(`Request timed out after ${timeoutMs}ms`);
+  }
+};
+var InfraAPIError = class extends InfraError {
+  constructor(status, message, errors, body, headers) {
+    super(message);
+    this.status = status;
+    this.errors = errors;
+    this.body = body;
+    this.headers = headers;
+  }
+  status;
+  errors;
+  body;
+  headers;
+};
+var BadRequestError = class extends InfraAPIError {
+};
+var AuthenticationError = class extends InfraAPIError {
+};
+var PaymentRequiredError = class extends InfraAPIError {
+};
+var PermissionDeniedError = class extends InfraAPIError {
+};
+var NotFoundError = class extends InfraAPIError {
+};
+var ConflictError = class extends InfraAPIError {
+};
+var UnprocessableEntityError = class extends InfraAPIError {
+};
+var RateLimitError = class extends InfraAPIError {
+  constructor(status, message, errors, body, headers, retryAfterSeconds) {
+    super(status, message, errors, body, headers);
+    this.retryAfterSeconds = retryAfterSeconds;
+  }
+  retryAfterSeconds;
+};
+var InternalServerError = class extends InfraAPIError {
+};
+var ServiceUnavailableError = class extends InfraAPIError {
+};
+var UnknownAPIError = class extends InfraAPIError {
+};
+function errorFromResponse(status, parsedBody, headers) {
+  const body = parsedBody ?? {};
+  const message = typeof body.message === "string" ? body.message : `Request failed with status ${status}`;
+  const errors = Array.isArray(body.errors) ? body.errors.filter((e) => typeof e === "string") : void 0;
+  switch (status) {
+    case 400:
+      return new BadRequestError(status, message, errors, parsedBody, headers);
+    case 401:
+      return new AuthenticationError(status, message, errors, parsedBody, headers);
+    case 402:
+      return new PaymentRequiredError(status, message, errors, parsedBody, headers);
+    case 403:
+      return new PermissionDeniedError(status, message, errors, parsedBody, headers);
+    case 404:
+      return new NotFoundError(status, message, errors, parsedBody, headers);
+    case 409:
+      return new ConflictError(status, message, errors, parsedBody, headers);
+    case 422:
+      return new UnprocessableEntityError(status, message, errors, parsedBody, headers);
+    case 429: {
+      const bodyRetryAfter = typeof body.retryAfter === "number" ? body.retryAfter : void 0;
+      const headerRetryAfter = headers["retry-after"] !== void 0 ? Number(headers["retry-after"]) : void 0;
+      const retryAfterSeconds = bodyRetryAfter ?? (headerRetryAfter !== void 0 && Number.isFinite(headerRetryAfter) ? headerRetryAfter : void 0);
+      return new RateLimitError(status, message, errors, parsedBody, headers, retryAfterSeconds);
+    }
+    case 503:
+      return new ServiceUnavailableError(status, message, errors, parsedBody, headers);
+    default:
+      if (status >= 500) return new InternalServerError(status, message, errors, parsedBody, headers);
+      return new UnknownAPIError(status, message, errors, parsedBody, headers);
+  }
+}
+var InfraAuthTokenError = class extends InfraError {
+  constructor(status, error, errorDescription) {
+    super(errorDescription ? `${error}: ${errorDescription}` : error);
+    this.status = status;
+    this.error = error;
+    this.errorDescription = errorDescription;
+  }
+  status;
+  error;
+  errorDescription;
+};
+var WebhookSignatureVerificationError = class extends InfraError {
+};
+
+// src/core/http-client.ts
+var DEFAULT_TIMEOUT_MS = 3e4;
+var DEFAULT_MAX_RETRIES = 2;
+var HttpClient = class {
+  baseURL;
+  getAuthHeaders;
+  fetchImpl;
+  timeoutMs;
+  maxRetries;
+  defaultHeaders;
+  constructor(options) {
+    this.baseURL = options.baseURL;
+    this.getAuthHeaders = options.getAuthHeaders;
+    this.fetchImpl = options.fetch ?? globalThis.fetch.bind(globalThis);
+    this.timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    this.maxRetries = options.maxRetries ?? DEFAULT_MAX_RETRIES;
+    this.defaultHeaders = options.defaultHeaders ?? {};
+  }
+  /** Issues a request against the Infra API and returns the unwrapped `data` field of the response envelope. */
+  async request(options) {
+    const url = buildUrl(this.baseURL, options.path, options.query);
+    const timeoutMs = options.timeoutMs ?? this.timeoutMs;
+    const retryableOnConnectionError = options.method === "GET" || Boolean(options.idempotencyKey);
+    let attempt = 0;
+    let lastError;
+    while (attempt <= this.maxRetries) {
+      attempt++;
+      const authHeaders = await this.getAuthHeaders();
+      const requestHeaders = {
+        Accept: "application/json",
+        "User-Agent": `infra-sdk-typescript/${SDK_VERSION}`,
+        ...this.defaultHeaders,
+        ...authHeaders,
+        ...options.headers
+      };
+      if (options.body !== void 0) {
+        requestHeaders["Content-Type"] = "application/json";
+      }
+      if (options.idempotencyKey) {
+        requestHeaders["Idempotency-Key"] = options.idempotencyKey;
+      }
+      const controller = new AbortController();
+      const timer = setTimeout(() => controller.abort(), timeoutMs);
+      const onCallerAbort = () => controller.abort();
+      if (options.signal) {
+        if (options.signal.aborted) controller.abort();
+        else options.signal.addEventListener("abort", onCallerAbort, { once: true });
+      }
+      let response;
+      try {
+        response = await this.fetchImpl(url, {
+          method: options.method,
+          headers: requestHeaders,
+          body: options.body !== void 0 ? JSON.stringify(options.body) : void 0,
+          signal: controller.signal
+        });
+      } catch (err) {
+        clearTimeout(timer);
+        options.signal?.removeEventListener("abort", onCallerAbort);
+        if (options.signal?.aborted) {
+          throw new InfraConnectionError("Request aborted by caller", err);
+        }
+        const connectionError = isAbortError(err) ? new InfraConnectionTimeoutError(timeoutMs) : new InfraConnectionError("Could not reach the Infra API", err);
+        if (!retryableOnConnectionError || attempt > this.maxRetries) {
+          throw connectionError;
+        }
+        lastError = connectionError;
+        await sleep(backoffDelayMs(attempt));
+        continue;
+      }
+      clearTimeout(timer);
+      options.signal?.removeEventListener("abort", onCallerAbort);
+      const responseHeaders = headersToObject(response.headers);
+      const parsedBody = await parseJsonSafely(response);
+      if (response.ok) {
+        const envelope = parsedBody;
+        return envelope?.data;
+      }
+      const apiError = errorFromResponse(response.status, parsedBody, responseHeaders);
+      const isRetryableStatus = apiError instanceof RateLimitError || apiError instanceof ServiceUnavailableError || apiError instanceof InternalServerError;
+      if (!isRetryableStatus || attempt > this.maxRetries) {
+        throw apiError;
+      }
+      lastError = apiError;
+      const delayMs = apiError instanceof RateLimitError && apiError.retryAfterSeconds !== void 0 ? apiError.retryAfterSeconds * 1e3 : backoffDelayMs(attempt);
+      await sleep(delayMs);
+    }
+    throw lastError;
+  }
+};
+function buildUrl(baseURL, path, query) {
+  const base = baseURL.endsWith("/") ? baseURL : `${baseURL}/`;
+  const url = new URL(path.replace(/^\//, ""), base);
+  if (query) {
+    for (const [key, value] of Object.entries(query)) {
+      if (value === void 0 || value === null) continue;
+      url.searchParams.set(key, String(value));
+    }
+  }
+  return url.toString();
+}
+function headersToObject(headers) {
+  const obj = {};
+  headers.forEach((value, key) => {
+    obj[key.toLowerCase()] = value;
+  });
+  return obj;
+}
+async function parseJsonSafely(response) {
+  const text = await response.text();
+  if (!text) return void 0;
+  try {
+    return JSON.parse(text);
+  } catch {
+    return void 0;
+  }
+}
+function isAbortError(err) {
+  return err instanceof Error && err.name === "AbortError";
+}
+function backoffDelayMs(attempt) {
+  const base = Math.min(500 * 2 ** (attempt - 1), 8e3);
+  const jitter = Math.random() * 250;
+  return base + jitter;
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/core/auth.ts
+var TokenManager = class {
+  apiKey;
+  baseURL;
+  scope;
+  fetchImpl;
+  clockSkewSeconds;
+  maxRetries;
+  cached = null;
+  pendingRefresh = null;
+  constructor(options) {
+    this.apiKey = options.apiKey;
+    this.baseURL = options.baseURL;
+    this.scope = options.scope;
+    this.fetchImpl = options.fetch ?? globalThis.fetch.bind(globalThis);
+    this.clockSkewSeconds = options.clockSkewSeconds ?? 30;
+    this.maxRetries = options.maxRetries ?? 2;
+  }
+  /** Returns a valid bearer token, minting or refreshing one only when necessary. */
+  async getAccessToken(opts = {}) {
+    if (!opts.forceRefresh && this.cached && Date.now() < this.cached.expiresAtMs) {
+      return this.cached.accessToken;
+    }
+    if (this.pendingRefresh) {
+      return this.pendingRefresh;
+    }
+    this.pendingRefresh = this.fetchToken().finally(() => {
+      this.pendingRefresh = null;
+    });
+    return this.pendingRefresh;
+  }
+  async fetchToken() {
+    let attempt = 0;
+    for (; ; ) {
+      attempt++;
+      let response;
+      try {
+        response = await this.fetchImpl(new URL("/v1/oauth/token", this.baseURL), {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Accept: "application/json",
+            "User-Agent": `infra-sdk-typescript/${SDK_VERSION}`
+          },
+          body: JSON.stringify({
+            grant_type: "client_credentials",
+            client_secret: this.apiKey,
+            ...this.scope ? { scope: this.scope } : {}
+          })
+        });
+      } catch (err) {
+        throw new InfraConnectionError("Could not reach the Infra API to obtain an access token", err);
+      }
+      const text = await response.text();
+      const parsed = text ? JSON.parse(text) : void 0;
+      if (response.ok && parsed && "access_token" in parsed) {
+        const expiresAtMs = Date.now() + Math.max(0, parsed.expires_in - this.clockSkewSeconds) * 1e3;
+        this.cached = { accessToken: parsed.access_token, expiresAtMs };
+        return parsed.access_token;
+      }
+      const errorBody = parsed ?? { error: "server_error" };
+      const retryable = response.status === 429 || response.status === 503;
+      if (retryable && attempt <= this.maxRetries) {
+        const delayMs = typeof errorBody.retryAfter === "number" ? errorBody.retryAfter * 1e3 : Math.min(500 * 2 ** (attempt - 1), 4e3);
+        await sleep2(delayMs);
+        continue;
+      }
+      const fallbackDescription = parsed?.message;
+      throw new InfraAuthTokenError(
+        response.status,
+        errorBody.error ?? (response.status === 429 ? "rate_limited" : "server_error"),
+        errorBody.error_description ?? fallbackDescription
+      );
+    }
+  }
+  /** Drops the cached token, forcing the next call to mint a fresh one. */
+  clearCache() {
+    this.cached = null;
+  }
+};
+function sleep2(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/resources/resource.ts
+var APIResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+};
+function generateIdempotencyKey() {
+  return randomUUID();
+}
+
+// src/core/pagination.ts
+var Page = class {
+  data;
+  nextParams;
+  fetchNext;
+  constructor(opts) {
+    this.data = opts.data;
+    this.nextParams = opts.nextParams;
+    this.fetchNext = opts.fetchNext;
+  }
+  hasNextPage() {
+    return this.nextParams !== null && this.fetchNext !== null;
+  }
+  async getNextPage() {
+    if (!this.fetchNext || !this.nextParams) {
+      throw new Error("This is the last page \u2014 check hasNextPage() before calling getNextPage().");
+    }
+    return this.fetchNext(this.nextParams);
+  }
+  /** Walks every page starting with this one, yielding each `Page<T>` in turn. */
+  async *iterPages() {
+    let page = this;
+    yield page;
+    while (page.hasNextPage()) {
+      page = await page.getNextPage();
+      yield page;
+    }
+  }
+  /** Yields every item across all pages, fetching subsequent pages lazily as iteration proceeds. */
+  async *[Symbol.asyncIterator]() {
+    for await (const page of this.iterPages()) {
+      yield* page.data;
+    }
+  }
+  /** Eagerly fetches every remaining page and returns all items as a single array. Use with caution on large collections. */
+  async toArray() {
+    const items = [];
+    for await (const item of this) {
+      items.push(item);
+    }
+    return items;
+  }
+};
+function pageFromOffsetResponse(raw, fetchNext) {
+  const hasNext = raw.pagination.hasMore && raw.pagination.nextOffset !== null;
+  return new Page({
+    data: raw.items,
+    nextParams: hasNext ? { offset: raw.pagination.nextOffset, limit: raw.pagination.limit } : null,
+    fetchNext: hasNext ? fetchNext : null
+  });
+}
+function pageFromFlatResponse(raw, fetchNext) {
+  const itemsSeenSoFar = (raw.page - 1) * raw.pageSize + raw.items.length;
+  const hasNext = itemsSeenSoFar < raw.total;
+  return new Page({
+    data: raw.items,
+    nextParams: hasNext ? { page: raw.page + 1, pageSize: raw.pageSize } : null,
+    fetchNext: hasNext ? fetchNext : null
+  });
+}
+function pageFromMetaResponse(raw, fetchNext) {
+  const hasNext = raw.meta.page < raw.meta.totalPages;
+  return new Page({
+    data: raw.data,
+    nextParams: hasNext ? { page: raw.meta.page + 1, limit: raw.meta.limit } : null,
+    fetchNext: hasNext ? fetchNext : null
+  });
+}
+
+// src/resources/wallet/index.ts
+var WalletResource = class extends APIResource {
+  /** Derives one or more new addresses on the business HD tree. Requires `wallet.hd.generate`. */
+  async generateWallets(params, overrides = {}) {
+    const { idempotencyKey, ...rest } = overrides;
+    return this.client.request({
+      method: "POST",
+      path: "/v1/wallet/hd/generate",
+      body: params,
+      idempotencyKey: idempotencyKey ?? generateIdempotencyKey(),
+      ...rest
+    });
+  }
+  /**
+   * Lists derived wallets for the business. Requires `wallet.hd.read`.
+   *
+   * Note: unlike {@link getTransactionHistory}, the API does not return pagination
+   * metadata for this endpoint — it always answers with a plain array sized by `limit`.
+   */
+  async listWallets(params = {}, overrides = {}) {
+    return this.client.request({
+      method: "GET",
+      path: "/v1/wallet/hd",
+      query: params,
+      ...overrides
+    });
+  }
+  /** Returns the number of derived wallets, optionally filtered by chain. Requires `wallet.hd.read`. */
+  async getWalletCount(params = {}, overrides = {}) {
+    return this.client.request({
+      method: "GET",
+      path: "/v1/wallet/hd/count",
+      query: params,
+      ...overrides
+    });
+  }
+  /** Reports whether HD wallets are enabled for the business. Requires `wallet.hd.read`. */
+  async getHdEnabled(overrides = {}) {
+    return this.client.request({
+      method: "GET",
+      path: "/v1/wallet/hd/enabled",
+      ...overrides
+    });
+  }
+  /** Fetches a single wallet by its on-chain address. Requires `wallet.hd.read`. */
+  async getWalletByAddress(address, params = {}, overrides = {}) {
+    return this.client.request({
+      method: "GET",
+      path: `/v1/wallet/hd/address/${encodeURIComponent(address)}`,
+      query: params,
+      ...overrides
+    });
+  }
+  /** Fetches a wallet by its HD `addressIndex`. Requires `wallet.hd.read`. */
+  async getWalletByAddressIndex(addressIndex, params = {}, overrides = {}) {
+    return this.client.request({
+      method: "GET",
+      path: `/v1/wallet/hd/address-index/${encodeURIComponent(String(addressIndex))}`,
+      query: params,
+      ...overrides
+    });
+  }
+  /**
+   * Signs (and, where applicable, sponsors and submits) a transaction from a derived
+   * wallet. Requires `wallet.hd.sign`.
+   *
+   * Returns a {@link SignedTransactionResult} for local-only signing (a non-EVM chain
+   * with `addressIndex` — nothing broadcast), or a {@link WalletTransaction} for a
+   * sponsored sign (async `PENDING` by default, or the settled result with
+   * `waitForCompletion: true`).
+   */
+  async signTransaction(params, overrides = {}) {
+    const { idempotencyKey, ...rest } = overrides;
+    return this.client.request({
+      method: "POST",
+      path: "/v1/wallet/hd/sign",
+      body: params,
+      idempotencyKey: idempotencyKey ?? generateIdempotencyKey(),
+      ...rest
+    });
+  }
+  /** Deactivates a wallet so it is no longer used for new operations. Requires `wallet.hd.deactivate`. */
+  async deactivateWallet(walletId, params = {}, overrides = {}) {
+    return this.client.request({
+      method: "POST",
+      path: `/v1/wallet/hd/deactivate/${encodeURIComponent(walletId)}`,
+      query: params,
+      ...overrides
+    });
+  }
+  /** Lists the chains the platform can sign and broadcast on. */
+  async getSupportedChains(overrides = {}) {
+    return this.client.request({
+      method: "GET",
+      path: "/v1/wallet/rpc/chains",
+      ...overrides
+    });
+  }
+  /**
+   * Submits a token (or native) transfer from a derived wallet. Requires
+   * `wallet.transfer.create`.
+   *
+   * On a `422` (transfer reverted after broadcast, `waitForCompletion: true` only), the
+   * thrown {@link UnprocessableEntityError} still carries the failed transaction — read it
+   * from `error.body` (shaped like `{ data: WalletTransaction }`) if you need the details
+   * rather than just the message.
+   */
+  async initiateTransfer(params, overrides = {}) {
+    const { idempotencyKey, ...rest } = overrides;
+    return this.client.request({
+      method: "POST",
+      path: "/v1/wallet/transaction",
+      body: params,
+      idempotencyKey: idempotencyKey ?? generateIdempotencyKey(),
+      ...rest
+    });
+  }
+  /**
+   * Returns a paginated history of the business's transactions. Requires
+   * `wallet.transfer.read`.
+   *
+   * ```ts
+   * const page = await client.wallet.getTransactionHistory({ status: "COMPLETED" });
+   * for await (const tx of page) {
+   *   console.log(tx.id, tx.status);
+   * }
+   * ```
+   */
+  async getTransactionHistory(params = {}, overrides = {}) {
+    const fetchPage = (query) => this.client.request({
+      method: "GET",
+      path: "/v1/wallet/transaction/history",
+      query: { ...params, ...query },
+      ...overrides
+    }).then((raw) => pageFromOffsetResponse(raw, fetchPage));
+    return fetchPage({ limit: params.limit, offset: params.offset });
+  }
+  /**
+   * Fetches a single transaction record — the authoritative view of a transfer's outcome.
+   * Poll this after an async `202` until `status` is `COMPLETED` or `FAILED`. Requires
+   * `wallet.transfer.read`.
+   */
+  async getTransaction(id, overrides = {}) {
+    return this.client.request({
+      method: "GET",
+      path: `/v1/wallet/transaction/${encodeURIComponent(id)}`,
+      ...overrides
+    });
+  }
+  /** Returns the business's spendable USD balance, used to pay gas on mainnet transfers. Requires `wallet.balance.read`. */
+  async getBalance(overrides = {}) {
+    return this.client.request({
+      method: "GET",
+      path: "/v1/wallet/balance",
+      ...overrides
+    });
+  }
+};
+
+// src/resources/tokenization/index.ts
+var TokenizationResource = class extends APIResource {
+  /**
+   * Issues a new tokenized asset and deploys it on the target chain. Returns immediately
+   * with a `PENDING` token plus a deployment `operationRef` and `txHash` — poll
+   * {@link getToken} until `status` is `ACTIVE`. Supply `yieldParams` for a
+   * `YIELD_BEARING` token.
+   */
+  async createToken(params, overrides = {}) {
+    return this.client.request({
+      method: "POST",
+      path: "/v1/tokens",
+      body: params,
+      ...overrides
+    });
+  }
+  /**
+   * Returns a paginated list of tokens for the calling project.
+   *
+   * ```ts
+   * const page = await client.tokenization.listTokens();
+   * for await (const token of page) console.log(token.ticker, token.status);
+   * ```
+   */
+  async listTokens(params = {}, overrides = {}) {
+    const fetchPage = (query) => this.client.request({
+      method: "GET",
+      path: "/v1/tokens",
+      query: { ...params, ...query },
+      ...overrides
+    }).then((raw) => pageFromFlatResponse(raw, fetchPage));
+    return fetchPage({ page: params.page, pageSize: params.pageSize });
+  }
+  /** Fetches a single token by id, including its per-chain deployment details. */
+  async getToken(id, overrides = {}) {
+    return this.client.request({
+      method: "GET",
+      path: `/v1/tokens/${encodeURIComponent(id)}`,
+      ...overrides
+    });
+  }
+  /** Mints new units of a token to a recipient address. */
+  async mintToken(params, overrides = {}) {
+    return this.client.request({
+      method: "POST",
+      path: "/v1/tokens/mint",
+      body: params,
+      ...overrides
+    });
+  }
+  /** Burns units of a token from a holder address. */
+  async burnToken(params, overrides = {}) {
+    return this.client.request({
+      method: "POST",
+      path: "/v1/tokens/burn",
+      body: params,
+      ...overrides
+    });
+  }
+  /** Transfers token units between holder addresses. */
+  async transferToken(params, overrides = {}) {
+    return this.client.request({
+      method: "POST",
+      path: "/v1/tokens/transfer",
+      body: params,
+      ...overrides
+    });
+  }
+  /** Registers (whitelists) a wallet address so it can hold a given token. */
+  async registerWallet(params, overrides = {}) {
+    return this.client.request({
+      method: "POST",
+      path: "/v1/tokens/register-wallet",
+      body: params,
+      ...overrides
+    });
+  }
+  /** Returns the paginated list of holder wallet addresses and balances for a token on a chain. */
+  async getTokenHolders(params, overrides = {}) {
+    const fetchPage = (query) => this.client.request({
+      method: "GET",
+      path: "/v1/tokens/holders",
+      query: { ...params, ...query },
+      ...overrides
+    }).then((raw) => pageFromFlatResponse(raw, fetchPage));
+    return fetchPage({ page: params.page, pageSize: params.pageSize });
+  }
+  /** Fetches a single token transaction by its reference. */
+  async getTokenTransaction(ref, overrides = {}) {
+    return this.client.request({
+      method: "GET",
+      path: `/v1/tokens/transactions/${encodeURIComponent(ref)}`,
+      ...overrides
+    });
+  }
+  /** Returns token transactions, optionally filtered by token. */
+  async listTokenTransactions(params = {}, overrides = {}) {
+    const fetchPage = (query) => this.client.request({
+      method: "GET",
+      path: "/v1/tokens/transactions",
+      query: { ...params, ...query },
+      ...overrides
+    }).then((raw) => pageFromFlatResponse(raw, fetchPage));
+    return fetchPage({ page: params.page, pageSize: params.pageSize });
+  }
+  /** Updates the annual yield rate for a yield-bearing token. */
+  async updateYield(params, overrides = {}) {
+    return this.client.request({
+      method: "PATCH",
+      path: "/v1/tokens/yield",
+      body: params,
+      ...overrides
+    });
+  }
+  /** Funds and distributes a yield payout to holders. Unclaimed funds may be reclaimed after `reclaimAfter`. */
+  async distributeYield(params, overrides = {}) {
+    return this.client.request({
+      method: "POST",
+      path: "/v1/tokens/yield/distribute",
+      body: params,
+      ...overrides
+    });
+  }
+  /** Pays the scheduled coupon for a yield-bearing token. Set `pushYield` to push funds rather than let investors claim. */
+  async payCoupon(params, overrides = {}) {
+    return this.client.request({
+      method: "POST",
+      path: "/v1/tokens/yield/pay-coupon",
+      body: params,
+      ...overrides
+    });
+  }
+  /** Claims an investor's yield for a given distribution snapshot. */
+  async claimYield(params, overrides = {}) {
+    return this.client.request({
+      method: "POST",
+      path: "/v1/tokens/yield/claim",
+      body: params,
+      ...overrides
+    });
+  }
+  /** Redeems principal to holders at maturity. Set `pushYield` to push funds rather than let investors claim. */
+  async redeemPrincipal(params, overrides = {}) {
+    return this.client.request({
+      method: "POST",
+      path: "/v1/tokens/yield/redeem",
+      body: params,
+      ...overrides
+    });
+  }
+};
+
+// src/resources/indexer/index.ts
+var IndexerResource = class extends APIResource {
+  /**
+   * Creates a subscription that streams decoded events for a contract to your webhook.
+   * Requires the network's subscribe capability (e.g. `indexer.subscribe.evm`).
+   *
+   * The response includes `signingSecret` only on creation — store it securely, it is
+   * never shown again (see {@link rotateSigningSecret} if you lose it).
+   */
+  async createSubscription(params, overrides = {}) {
+    return this.client.request({
+      method: "POST",
+      path: "/v1/indexer/subscriptions",
+      body: params,
+      ...overrides
+    });
+  }
+  /** Lists the project's subscriptions. Requires `indexer.subscription.list`. */
+  async listSubscriptions(params = {}, overrides = {}) {
+    const fetchPage = (query) => this.client.request({
+      method: "GET",
+      path: "/v1/indexer/subscriptions",
+      query: { ...params, ...query },
+      ...overrides
+    }).then((raw) => pageFromMetaResponse(raw, fetchPage));
+    return fetchPage({ page: params.page, limit: params.limit });
+  }
+  /** Fetches one subscription. Requires `indexer.subscription.read`. */
+  async getSubscription(id, overrides = {}) {
+    return this.client.request({
+      method: "GET",
+      path: `/v1/indexer/subscriptions/${encodeURIComponent(id)}`,
+      ...overrides
+    });
+  }
+  /** Updates a subscription's webhook, events, or status. At least one field is required. Requires `indexer.subscription.update`. */
+  async updateSubscription(id, params, overrides = {}) {
+    return this.client.request({
+      method: "PATCH",
+      path: `/v1/indexer/subscriptions/${encodeURIComponent(id)}`,
+      body: params,
+      ...overrides
+    });
+  }
+  /** Soft-deletes a subscription (`status` becomes `"deleted"`; deliveries stop). Requires `indexer.subscription.delete`. */
+  async deleteSubscription(id, overrides = {}) {
+    return this.client.request({
+      method: "DELETE",
+      path: `/v1/indexer/subscriptions/${encodeURIComponent(id)}`,
+      ...overrides
+    });
+  }
+  /**
+   * Generates a new signing secret and invalidates the old one. Requires
+   * `indexer.subscription.rotate_secret`. The response includes the new `signingSecret`
+   * once — store it immediately.
+   */
+  async rotateSigningSecret(id, overrides = {}) {
+    return this.client.request({
+      method: "POST",
+      path: `/v1/indexer/subscriptions/${encodeURIComponent(id)}/rotate-secret`,
+      ...overrides
+    });
+  }
+  /** Returns the catalog of subscribable event keys. Requires `indexer.subscription.list`. */
+  async listEventCatalog(params = {}, overrides = {}) {
+    return this.client.request({
+      method: "GET",
+      path: "/v1/indexer/events",
+      query: params,
+      ...overrides
+    });
+  }
+};
+
+// src/client.ts
+var DEFAULT_BASE_URL = "https://api.withconvexity.com";
+var InfraClient = class {
+  wallet;
+  tokenization;
+  indexer;
+  http;
+  auth;
+  constructor(options) {
+    if (!options.apiKey) {
+      throw new Error(
+        "InfraClient requires an `apiKey`. Request test/live keys from infra@withconvexity.com."
+      );
+    }
+    const baseURL = options.baseURL ?? DEFAULT_BASE_URL;
+    this.auth = new TokenManager({
+      apiKey: options.apiKey,
+      baseURL,
+      scope: options.scope,
+      fetch: options.fetch
+    });
+    this.http = new HttpClient({
+      baseURL,
+      fetch: options.fetch,
+      timeoutMs: options.timeoutMs,
+      maxRetries: options.maxRetries,
+      getAuthHeaders: async () => ({ Authorization: `Bearer ${await this.auth.getAccessToken()}` })
+    });
+    this.wallet = new WalletResource(this);
+    this.tokenization = new TokenizationResource(this);
+    this.indexer = new IndexerResource(this);
+  }
+  /**
+   * Low-level escape hatch that issues a raw request against the Infra API using this
+   * client's auth, retry, and timeout configuration. The typed resource methods
+   * (`client.wallet.*`, `client.tokenization.*`, `client.indexer.*`) are built on top of
+   * this and should be preferred — reach for this only to call an endpoint this SDK
+   * version doesn't wrap yet.
+   */
+  async request(options) {
+    try {
+      return await this.http.request(options);
+    } catch (err) {
+      if (err instanceof AuthenticationError) {
+        await this.auth.getAccessToken({ forceRefresh: true });
+        return await this.http.request(options);
+      }
+      throw err;
+    }
+  }
+};
+var DEFAULT_TOLERANCE_SECONDS = 300;
+function verifyWalletWebhookSignature(options) {
+  const { payload, timestampHeader, signatureHeader, secret, toleranceSeconds = DEFAULT_TOLERANCE_SECONDS } = options;
+  const timestamp = Number(timestampHeader);
+  if (!Number.isFinite(timestamp)) {
+    throw new WebhookSignatureVerificationError("Missing or invalid x-wallet-timestamp header");
+  }
+  const ageSeconds = Math.abs(Date.now() / 1e3 - timestamp);
+  if (ageSeconds > toleranceSeconds) {
+    throw new WebhookSignatureVerificationError(
+      `Webhook timestamp is ${Math.round(ageSeconds)}s old, outside the allowed tolerance of ${toleranceSeconds}s`
+    );
+  }
+  const rawBody = typeof payload === "string" ? payload : payload.toString("utf8");
+  const expected = createHmac("sha256", secret).update(`${timestampHeader}.${rawBody}`).digest("hex");
+  if (!constantTimeEqual(expected, signatureHeader)) {
+    throw new WebhookSignatureVerificationError(
+      "Signature mismatch \u2014 the payload may have been tampered with, or the secret is incorrect"
+    );
+  }
+}
+function verifyIndexerWebhookSignature(options) {
+  const { payload, signatureHeader, secret } = options;
+  const rawBody = typeof payload === "string" ? payload : payload.toString("utf8");
+  const expected = createHmac("sha256", secret).update(rawBody).digest("hex");
+  if (!constantTimeEqual(expected, signatureHeader)) {
+    throw new WebhookSignatureVerificationError(
+      "Signature mismatch \u2014 the payload may have been tampered with, or the secret is incorrect"
+    );
+  }
+}
+function constantTimeEqual(expectedHex, actualHex) {
+  const expected = Buffer.from(expectedHex, "utf8");
+  const actual = Buffer.from(actualHex, "utf8");
+  if (expected.length !== actual.length) return false;
+  return timingSafeEqual(expected, actual);
+}
+
+export { AuthenticationError, BadRequestError, ConflictError, IndexerResource, InfraAPIError, InfraAuthTokenError, InfraClient, InfraConnectionError, InfraConnectionTimeoutError, InfraError, InternalServerError, NotFoundError, Page, PaymentRequiredError, PermissionDeniedError, RateLimitError, ServiceUnavailableError, TokenizationResource, UnknownAPIError, UnprocessableEntityError, WalletResource, WebhookSignatureVerificationError, generateIdempotencyKey, verifyIndexerWebhookSignature, verifyWalletWebhookSignature };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map