@gauntlet-xyz/sdk 2.0.0 → 2.3.0

package/src/api/activity.ts

@@ -0,0 +1,219 @@
+import { GauntletSDKError } from '../errors';
+import type { ActivityOptions, GauntletApi, TokenRef, UserActivity } from './client';
+import { decimalToBigInt, sharesToBigInt } from './decimal';
+import { SettlementTimeoutError } from './errors';
+
+export type ActivityFlowKind = 'deposit' | 'withdraw' | 'transfer_in' | 'transfer_out';
+export type ActivityFlowStatus = 'settled' | 'pending' | 'refunded';
+
+/** A signed token amount as reported by the API, with base-unit conversion when possible. */
+export interface AssetAmount {
+  /** Human-unit decimal string exactly as the API emits it, e.g. `"1250.5"`. */
+  decimal: string;
+  /** Base-unit integer (`decimal × 10^token.decimals`); null when the token's decimals are unknown. */
+  raw: bigint | null;
+  token: TokenRef | null;
+}
+
+/**
+ * One user action against a vault, stitched from the activity log's immutable
+ * rows. Sync flows (Morpho, secondary-market transfers) come from a single
+ * row; Aera async flows pair a `*_pending` request row with its terminal
+ * settle/refund row via `request_hash`.
+ */
+export interface ActivityFlow {
+  kind: ActivityFlowKind;
+  status: ActivityFlowStatus;
+  /** CAIP-10 vault id (`"{chainId}:{address}"`). */
+  vaultId: string;
+  /** Aera async correlation hash; null for sync flows and transfers. */
+  requestHash: string | null;
+  /** When the request row landed. Null when the flow's pending row is outside the fetched window. */
+  requestedAt: Date | null;
+  /** When the terminal (settle/refund) row landed. Null while pending. */
+  settledAt: Date | null;
+  /** Magnitude of the flow's asset movement (requested amount for refunded flows). */
+  assets: AssetAmount;
+  /** Magnitude of the flow's share movement in 18-decimal base units. */
+  shares: bigint;
+  /** Transaction hashes in row order (request first, then settlement, when both are known). */
+  txHashes: string[];
+}
+
+const PENDING_TYPES = new Set(['deposit_pending', 'withdraw_pending']);
+const REFUNDED_TYPES = new Set(['deposit_refunded', 'withdraw_refunded']);
+
+function flowKind(rowType: string): ActivityFlowKind {
+  if (rowType.startsWith('deposit')) return 'deposit';
+  if (rowType.startsWith('withdraw')) return 'withdraw';
+  if (rowType === 'transfer_in' || rowType === 'transfer_out') return rowType;
+  throw new GauntletSDKError(`Unknown activity row type "${rowType}"`);
+}
+
+function abs(value: bigint): bigint {
+  return value < 0n ? -value : value;
+}
+
+/**
+ * Comparison scale for asset amounts. The API emits human-unit decimal strings
+ * with at most `token.decimals` fractional digits, so 18 digits is exact for
+ * every supported asset.
+ */
+const ASSET_SCALE = 18;
+
+function toAssetAmount(rows: UserActivity[]): AssetAmount {
+  // Per the API contract, at most one row of an async lifecycle carries the
+  // asset movement (the other legs are "0"), so the max magnitude is the
+  // flow's amount. For refunded flows this surfaces the requested amount
+  // instead of the useless net of zero.
+  let best = rows[0];
+  let bestMagnitude = abs(decimalToBigInt(best.assets_delta.native, ASSET_SCALE));
+  for (const row of rows.slice(1)) {
+    const magnitude = abs(decimalToBigInt(row.assets_delta.native, ASSET_SCALE));
+    if (magnitude > bestMagnitude) {
+      best = row;
+      bestMagnitude = magnitude;
+    }
+  }
+  const token =
+    best.assets_delta.token ?? rows.find((r) => r.assets_delta.token)?.assets_delta.token ?? null;
+  const decimal = best.assets_delta.native.replace(/^-/, '');
+  const raw = token?.decimals != null ? decimalToBigInt(decimal, token.decimals) : null;
+  return { decimal, raw, token };
+}
+
+/**
+ * Pure stitcher: folds raw activity rows into `ActivityFlow`s. Rows may be in
+ * any order and may span multiple vaults; async lifecycles are paired by
+ * `request_hash`. Flows are returned newest-first (by the flow's latest row).
+ */
+export function stitchActivityFlows(rows: UserActivity[]): ActivityFlow[] {
+  const groups = new Map<string, UserActivity[]>();
+  for (const [index, row] of rows.entries()) {
+    // Rows without a request_hash are standalone sync flows: each one is its
+    // own group, so two same-type events in one transaction (e.g. a multicall
+    // doing two deposits) stay two flows.
+    const key = row.request_hash ?? `row:${index}`;
+    const group = groups.get(key);
+    if (group) group.push(row);
+    else groups.set(key, [row]);
+  }
+
+  const flows: ActivityFlow[] = [];
+  for (const group of groups.values()) {
+    group.sort((a, b) => a.block_timestamp - b.block_timestamp);
+    const pendingRow = group.find((r) => PENDING_TYPES.has(r.type)) ?? null;
+    const terminalRow = group.find((r) => !PENDING_TYPES.has(r.type)) ?? null;
+    const isAsync = group.some((r) => r.request_hash != null);
+
+    let status: ActivityFlowStatus;
+    if (!terminalRow) status = 'pending';
+    else if (REFUNDED_TYPES.has(terminalRow.type)) status = 'refunded';
+    else status = 'settled';
+
+    let sharesMagnitude = 0n;
+    for (const row of group) {
+      const shares = abs(sharesToBigInt(row.shares_delta));
+      if (shares > sharesMagnitude) sharesMagnitude = shares;
+    }
+
+    flows.push({
+      kind: flowKind((terminalRow ?? pendingRow ?? group[0]).type),
+      status,
+      vaultId: group[0].vault_id,
+      requestHash: group[0].request_hash ?? null,
+      requestedAt: pendingRow
+        ? new Date(pendingRow.block_timestamp * 1000)
+        : isAsync
+          ? null
+          : new Date(group[0].block_timestamp * 1000),
+      settledAt: terminalRow ? new Date(terminalRow.block_timestamp * 1000) : null,
+      assets: toAssetAmount(group),
+      shares: sharesMagnitude,
+      txHashes: [...new Set(group.map((r) => r.tx_hash))],
+    });
+  }
+
+  return flows.sort((a, b) => {
+    const aAt = (a.settledAt ?? a.requestedAt)?.getTime() ?? 0;
+    const bAt = (b.settledAt ?? b.requestedAt)?.getTime() ?? 0;
+    return bAt - aAt;
+  });
+}
+
+export interface ActivityFlowsOptions extends Pick<ActivityOptions, 'vaultId' | 'limit'> {
+  /** Stop paginating once this many rows have been fetched. Defaults to 1000. */
+  maxRows?: number;
+}
+
+/**
+ * Fetches the wallet's activity log and stitches it into lifecycle-aware
+ * flows — the replacement for scanning vault event logs over RPC.
+ *
+ * ```ts
+ * const flows = await getActivityFlows(client.api, wallet);
+ * const open = flows.filter((f) => f.status === 'pending');
+ * ```
+ */
+export async function getActivityFlows(
+  api: GauntletApi,
+  walletAddress: string,
+  options: ActivityFlowsOptions = {}
+): Promise<ActivityFlow[]> {
+  const maxRows = options.maxRows ?? 1000;
+  const rows: UserActivity[] = [];
+  for await (const row of api.activityRows(walletAddress, {
+    vaultId: options.vaultId,
+    // The API caps page size at 1000; request maxRows per page so the common
+    // case is a single round trip instead of ten default-100 pages.
+    limit: options.limit ?? Math.min(maxRows, 1000),
+    order: 'desc',
+  })) {
+    rows.push(row);
+    if (rows.length >= maxRows) break;
+  }
+  const flows = stitchActivityFlows(rows);
+  if (rows.length >= maxRows) {
+    // The window cut may have split an async lifecycle, keeping a terminal
+    // row whose request leg (the one carrying the amount) fell outside the
+    // window. Drop those flows rather than reporting zeroed amounts.
+    return flows.filter((f) => f.requestHash === null || f.requestedAt !== null);
+  }
+  return flows;
+}
+
+export interface WaitForSettlementOptions {
+  /** CAIP-10 vault id — narrows polling to one vault's activity. */
+  vaultId?: string;
+  /** Polling interval. Defaults to 5s. */
+  pollIntervalMs?: number;
+  /** Overall deadline. Defaults to 10 minutes. Throws `SettlementTimeoutError` on expiry. */
+  timeoutMs?: number;
+}
+
+/**
+ * Polls the activity log until the Aera async request identified by
+ * `requestHash` reaches a terminal state, and returns the settled or refunded
+ * flow. Use after submitting a `requestDeposit` / `requestRedeem` transaction.
+ */
+export async function waitForRequestSettlement(
+  api: GauntletApi,
+  walletAddress: string,
+  requestHash: string,
+  options: WaitForSettlementOptions = {}
+): Promise<ActivityFlow> {
+  const pollIntervalMs = options.pollIntervalMs ?? 5_000;
+  const timeoutMs = options.timeoutMs ?? 600_000;
+  const deadline = Date.now() + timeoutMs;
+
+  for (;;) {
+    const flows = await getActivityFlows(api, walletAddress, { vaultId: options.vaultId });
+    const flow = flows.find((f) => f.requestHash === requestHash);
+    if (flow && flow.status !== 'pending') return flow;
+
+    if (Date.now() + pollIntervalMs > deadline) {
+      throw new SettlementTimeoutError(requestHash, timeoutMs);
+    }
+    await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
+  }
+}

package/src/api/caip.ts

@@ -0,0 +1,61 @@
+import type { GauntletClient } from '../client';
+import { VaultNotFoundError } from '../errors';
+import { resolveVault } from '../evm/vaults';
+import { InvalidCaipIdError } from './errors';
+
+/**
+ * The Gaia API identifies vaults as `"{chainId}:{address}"` with a lowercase
+ * address (a CAIP-10-style account id without the `eip155` namespace prefix).
+ */
+export interface ApiVaultId {
+  chainId: number;
+  /** Lowercase EVM address. */
+  address: string;
+}
+
+export function parseApiVaultId(id: string): ApiVaultId {
+  const match = /^(?:eip155:)?(\d+):(0x[0-9a-fA-F]{40})$/.exec(id);
+  if (!match) throw new InvalidCaipIdError(id);
+  return { chainId: Number(match[1]), address: match[2].toLowerCase() };
+}
+
+export function formatApiVaultId(chainId: number, address: string): string {
+  return `${chainId}:${address.toLowerCase()}`;
+}
+
+/**
+ * Resolves a manifest vault id (e.g. `VaultId.AeraUsdAlpha` / `'gtusda'`) to
+ * the Gaia API's CAIP-10 id for the vault's deployment on `chainId`.
+ *
+ * Deployment resolution is `resolveVault` — the same rules tx-building uses:
+ * single-deployment vaults resolve directly (a mismatched explicit `chainId`
+ * throws `ChainMismatchError`), multi-chain vaults default to Base when
+ * `chainId` is omitted.
+ */
+export async function apiVaultIdFromVaultId(
+  client: GauntletClient,
+  vaultId: string,
+  chainId?: number
+): Promise<string> {
+  const resolved = await resolveVault(client, vaultId, chainId);
+  if (!resolved) throw new VaultNotFoundError(vaultId, chainId);
+  return formatApiVaultId(resolved.vault.chainId, resolved.vault.vaultAddress);
+}
+
+/**
+ * Resolves a Gaia API CAIP-10 vault id back to the manifest vault id, or
+ * `undefined` when the vault is not in the bundled manifest (the API indexes
+ * more vaults than the manifest lists).
+ */
+export async function vaultIdFromApiVaultId(
+  client: GauntletClient,
+  apiVaultId: string
+): Promise<string | undefined> {
+  const { chainId, address } = parseApiVaultId(apiVaultId);
+  const manifest = await client.manifest;
+  return manifest.vaults.find((v) =>
+    v.deployments.some(
+      (d) => d.chain === 'evm' && d.chainId === chainId && d.vaultAddress.toLowerCase() === address
+    )
+  )?.vaultId;
+}

package/src/api/client.ts

@@ -0,0 +1,201 @@
+import type { components } from './generated';
+import { apiGet, type GauntletApiConfig, type QueryParams } from './http';
+
+type Schemas = components['schemas'];
+
+export type UserActivity = Schemas['UserActivity'];
+export type UserActivityResponse = Schemas['UserActivityResponse'];
+export type UserPosition = Schemas['UserPosition'];
+export type UserAllPositionsResponse = Schemas['UserAllPositionsResponse'];
+export type UserPositionLatestResponse = Schemas['UserPositionLatestResponse'];
+export type UserPositionsTimeseriesResponse = Schemas['UserPositionsTimeseriesResponse'];
+export type PositionTimeseriesPoint = Schemas['PositionTimeseriesPoint'];
+export type VaultDetail = Schemas['VaultDetail'];
+export type VaultDetailResponse = Schemas['VaultDetailResponse'];
+export type VaultTimeseriesResponse = Schemas['VaultTimeseriesResponse'];
+export type VaultTimeseriesPoint = Schemas['VaultTimeseriesPoint'];
+export type VaultMetrics = Schemas['VaultMetrics'];
+export type TvlResponse = Schemas['TvlResponse'];
+export type LatestPriceResponse = Schemas['LatestPriceResponse'];
+export type PriceTimeseriesResponse = Schemas['TimeseriesResponse'];
+export type TokenRef = Schemas['TokenRef'];
+export type PartialResponseError = Schemas['PartialResponseError'];
+export type AmountPair = Schemas['AmountPair'];
+export type TimeseriesMeta = Schemas['TimeseriesMeta'];
+export type HealthResponse = Schemas['HealthResponse'];
+export type ChainSyncStatus = Schemas['ChainSyncStatus'];
+
+export interface PageOptions {
+  /** Opaque cursor from a previous response's `meta.next_cursor`. */
+  next?: string;
+  limit?: number;
+  order?: 'asc' | 'desc';
+}
+
+export interface TimeWindowOptions extends PageOptions {
+  /** ISO 8601 date (`2026-01-01`) or RFC 3339 timestamp. */
+  start?: string;
+  end?: string;
+  granularity?: 'hour' | 'day' | 'week' | 'month';
+}
+
+export interface ActivityOptions extends PageOptions {
+  /** CAIP-10 vault id (`"{chainId}:{address}"`). Omit for wallet-wide activity. */
+  vaultId?: string;
+}
+
+export interface LatestPriceOptions {
+  address: string;
+  chainId: number;
+  /** Optional ISO 8601 timestamp for a point-in-time price. */
+  at?: string;
+}
+
+export interface PriceTimeseriesOptions {
+  address: string;
+  chainId: number;
+  start: string;
+  end: string;
+  granularity?: 'raw' | 'hour' | 'day' | 'week' | 'month';
+  limit?: number;
+}
+
+/**
+ * Typed client for the Gaia REST API (api.gauntlet.xyz).
+ *
+ * All response types are generated from the service's OpenAPI spec
+ * (`src/api/generated.ts`, regenerated via `yarn generate:api-types`) so they
+ * cannot drift from the server models. Values are returned exactly as the API
+ * emits them — human-unit decimal strings and CAIP-10 vault ids; use
+ * `decimalToBigInt` / `sharesToBigInt` and `apiVaultIdFromVaultId` /
+ * `vaultIdFromApiVaultId` to convert, or the higher-level `activityFlows` /
+ * `positionHistory` helpers for pre-normalized values.
+ *
+ * Available on a configured client as `client.api`, or standalone:
+ * ```ts
+ * const api = new GauntletApi({ apiKey: process.env.GAUNTLET_API_KEY });
+ * const { data } = await api.vaults();
+ * ```
+ */
+export class GauntletApi {
+  private readonly config: GauntletApiConfig;
+
+  constructor(config: GauntletApiConfig = {}) {
+    this.config = config;
+  }
+
+  private get<T>(path: string, query?: QueryParams): Promise<T> {
+    return apiGet<T>(this.config, path, query);
+  }
+
+  /** GET /health — service liveness (version + uptime). */
+  health(): Promise<HealthResponse> {
+    return this.get('/health');
+  }
+
+  /** GET /health/chains — per-chain indexer sync freshness. */
+  chainSyncStatus(): Promise<ChainSyncStatus[]> {
+    return this.get('/health/chains');
+  }
+
+  /** GET /v1/vaults — all indexed vaults with live metrics (TVL, APY, unit price). */
+  vaults(options: PageOptions = {}): Promise<{ data: VaultDetail[]; meta: TimeseriesMeta }> {
+    return this.get('/v1/vaults', { next: options.next, limit: options.limit });
+  }
+
+  /** GET /v1/vaults/{vault_id} — one vault with live metrics. `vaultId` is CAIP-10. */
+  vault(vaultId: string): Promise<VaultDetailResponse> {
+    return this.get(`/v1/vaults/${encodeURIComponent(vaultId)}`);
+  }
+
+  /** GET /v1/vaults/{vault_id}/definition — raw indexed vault definition. */
+  vaultDefinition(vaultId: string): Promise<unknown> {
+    return this.get(`/v1/vaults/${encodeURIComponent(vaultId)}/definition`);
+  }
+
+  /** GET /v1/vaults/{vault_id}/timeseries — TVL / unit-price / APY history. */
+  vaultTimeseries(
+    vaultId: string,
+    options: TimeWindowOptions = {}
+  ): Promise<VaultTimeseriesResponse> {
+    return this.get(`/v1/vaults/${encodeURIComponent(vaultId)}/timeseries`, { ...options });
+  }
+
+  /** GET /v1/users/{wallet}/positions — all of a wallet's indexed positions with PnL. */
+  positions(walletAddress: string, options: PageOptions = {}): Promise<UserAllPositionsResponse> {
+    return this.get(`/v1/users/${encodeURIComponent(walletAddress)}/positions`, {
+      next: options.next,
+      limit: options.limit,
+    });
+  }
+
+  /** GET /v1/users/{wallet}/positions/{vault_id} — one position with PnL breakdown. */
+  position(walletAddress: string, vaultId: string): Promise<UserPositionLatestResponse> {
+    return this.get(
+      `/v1/users/${encodeURIComponent(walletAddress)}/positions/${encodeURIComponent(vaultId)}`
+    );
+  }
+
+  /** GET /v1/users/{wallet}/positions/{vault_id}/timeseries — value / cost-basis / PnL / ROI history. */
+  positionTimeseries(
+    walletAddress: string,
+    vaultId: string,
+    options: TimeWindowOptions = {}
+  ): Promise<UserPositionsTimeseriesResponse> {
+    return this.get(
+      `/v1/users/${encodeURIComponent(walletAddress)}/positions/${encodeURIComponent(vaultId)}/timeseries`,
+      { ...options }
+    );
+  }
+
+  /** GET /v1/users/{wallet}/activity — one page of the wallet's immutable event log. */
+  activity(walletAddress: string, options: ActivityOptions = {}): Promise<UserActivityResponse> {
+    const { vaultId, ...page } = options;
+    return this.get(`/v1/users/${encodeURIComponent(walletAddress)}/activity`, {
+      vault_id: vaultId,
+      ...page,
+    });
+  }
+
+  /**
+   * Iterates the wallet's full activity log, following `meta.next_cursor`
+   * across pages so callers never handle cursors.
+   */
+  async *activityRows(
+    walletAddress: string,
+    options: Omit<ActivityOptions, 'next'> = {}
+  ): AsyncGenerator<UserActivity> {
+    let next: string | undefined;
+    do {
+      const page = await this.activity(walletAddress, { ...options, next });
+      yield* page.data;
+      next = page.meta.next_cursor ?? undefined;
+    } while (next);
+  }
+
+  /** GET /v1/tvl — aggregate Gauntlet TVL, optionally with per-source breakdown. */
+  tvl(options: { includeBreakdown?: boolean } = {}): Promise<TvlResponse> {
+    return this.get('/v1/tvl', { include_breakdown: options.includeBreakdown });
+  }
+
+  /** GET /v1/prices — latest USD price for a token. */
+  latestPrice(options: LatestPriceOptions): Promise<LatestPriceResponse> {
+    return this.get('/v1/prices', {
+      address: options.address,
+      chain_id: options.chainId,
+      at: options.at,
+    });
+  }
+
+  /** GET /v1/prices/timeseries — USD price history for a token. */
+  priceTimeseries(options: PriceTimeseriesOptions): Promise<PriceTimeseriesResponse> {
+    return this.get('/v1/prices/timeseries', {
+      address: options.address,
+      chain_id: options.chainId,
+      start: options.start,
+      end: options.end,
+      granularity: options.granularity,
+      limit: options.limit,
+    });
+  }
+}

package/src/api/decimal.ts

@@ -0,0 +1,49 @@
+import { formatUnits } from 'viem';
+import { DecimalPrecisionError, InvalidDecimalError } from './errors';
+
+const DECIMAL_RE = /^(-?)(\d+)(?:\.(\d+))?$/;
+
+/**
+ * Converts an API decimal string (human units, e.g. `"1250.5"`) into base-unit
+ * bigint at the given token decimals (e.g. `1250500000n` for 6 decimals).
+ *
+ * The conversion is exact: a value with more significant fractional digits
+ * than `decimals` throws `DecimalPrecisionError` rather than rounding.
+ * Hand-rolled instead of viem's `parseUnits`, which silently rounds excess
+ * precision (`parseUnits('1.0000005', 6)` → `1000001n`) — unacceptable for
+ * financial amounts.
+ */
+export function decimalToBigInt(value: string, decimals: number): bigint {
+  if (!Number.isInteger(decimals) || decimals < 0) {
+    throw new InvalidDecimalError(`decimals=${decimals}`);
+  }
+  const match = DECIMAL_RE.exec(value);
+  if (!match) throw new InvalidDecimalError(value);
+
+  const [, sign, whole, frac = ''] = match;
+  if (frac.length > decimals && !/^0*$/.test(frac.slice(decimals))) {
+    throw new DecimalPrecisionError(value, decimals);
+  }
+
+  const scaled = BigInt(whole + frac.slice(0, decimals).padEnd(decimals, '0'));
+  return sign === '-' ? -scaled : scaled;
+}
+
+/**
+ * Formats a base-unit bigint back into the API's human decimal-string
+ * representation (no trailing fractional zeros, no exponent notation).
+ */
+export function bigIntToDecimal(value: bigint, decimals: number): string {
+  if (!Number.isInteger(decimals) || decimals < 0) {
+    throw new InvalidDecimalError(`decimals=${decimals}`);
+  }
+  return formatUnits(value, decimals);
+}
+
+/** Vault shares are always reported in 18-decimal units by the Gaia API. */
+export const SHARE_DECIMALS = 18;
+
+/** Parses an API share amount (decimal string) into base-unit bigint (1e18). */
+export function sharesToBigInt(value: string): bigint {
+  return decimalToBigInt(value, SHARE_DECIMALS);
+}

package/src/api/errors.ts

@@ -0,0 +1,64 @@
+import { GauntletSDKError } from '../errors';
+
+export class GauntletApiError extends GauntletSDKError {
+  readonly status: number;
+  readonly path: string;
+  /** Machine-readable code from the API error envelope (e.g. `NOT_FOUND`), when present. */
+  readonly code?: string;
+
+  constructor(params: { status: number; path: string; message: string; code?: string }) {
+    super(
+      `Gauntlet API request to "${params.path}" failed with ${params.status}: ${params.message}`
+    );
+    this.name = 'GauntletApiError';
+    this.status = params.status;
+    this.path = params.path;
+    this.code = params.code;
+  }
+}
+
+export class InvalidDecimalError extends GauntletSDKError {
+  readonly value: string;
+
+  constructor(value: string) {
+    super(`Value "${value}" is not a valid decimal string`);
+    this.name = 'InvalidDecimalError';
+    this.value = value;
+  }
+}
+
+export class DecimalPrecisionError extends GauntletSDKError {
+  readonly value: string;
+  readonly decimals: number;
+
+  constructor(value: string, decimals: number) {
+    super(
+      `Decimal "${value}" has more fractional digits than the token's ${decimals} decimals; converting would lose precision`
+    );
+    this.name = 'DecimalPrecisionError';
+    this.value = value;
+    this.decimals = decimals;
+  }
+}
+
+export class InvalidCaipIdError extends GauntletSDKError {
+  readonly id: string;
+
+  constructor(id: string) {
+    super(`"${id}" is not a valid CAIP-10 vault id (expected "{chainId}:{address}")`);
+    this.name = 'InvalidCaipIdError';
+    this.id = id;
+  }
+}
+
+export class SettlementTimeoutError extends GauntletSDKError {
+  readonly requestHash: string;
+  readonly timeoutMs: number;
+
+  constructor(requestHash: string, timeoutMs: number) {
+    super(`Request "${requestHash}" did not settle within ${timeoutMs}ms`);
+    this.name = 'SettlementTimeoutError';
+    this.requestHash = requestHash;
+    this.timeoutMs = timeoutMs;
+  }
+}