@vayolabs/core-sdk 0.1.0

package/dist/index.js

@@ -0,0 +1,747 @@
+import { createHmac, timingSafeEqual } from 'crypto';
+
+// src/errors.ts
+var VayoApiError = class _VayoApiError extends Error {
+  constructor(statusCode, message, code = null, correlationId = null) {
+    super(message);
+    this.statusCode = statusCode;
+    this.code = code;
+    this.correlationId = correlationId;
+    Object.setPrototypeOf(this, _VayoApiError.prototype);
+  }
+  statusCode;
+  code;
+  correlationId;
+  name = "VayoApiError";
+  /**
+   * Factory used by the internal HTTP wrapper. Tolerant of malformed bodies —
+   * if the server returns HTML or empty content, we still construct a useful
+   * error from the status alone.
+   */
+  static fromBody(statusCode, statusText, body) {
+    const message = (body?.message && body.message.length > 0 ? body.message : null) ?? (statusText && statusText.length > 0 ? statusText : null) ?? `HTTP ${statusCode}`;
+    return new _VayoApiError(
+      statusCode,
+      message,
+      body?.code ?? null,
+      body?.correlationId ?? null
+    );
+  }
+};
+
+// src/http.ts
+var MUTATING_METHODS = /* @__PURE__ */ new Set(["POST", "PUT", "PATCH", "DELETE"]);
+var NO_BODY_STATUSES = /* @__PURE__ */ new Set([204, 205, 304]);
+function buildUrl(baseURL, url, params) {
+  const fullUrl = [baseURL, url].filter(Boolean).join("");
+  if (!params || typeof params !== "object") return fullUrl;
+  const searchParams = new URLSearchParams();
+  for (const [key, value] of Object.entries(
+    params
+  )) {
+    if (value === void 0 || value === null) continue;
+    if (Array.isArray(value)) {
+      searchParams.append(key, value.join(","));
+    } else {
+      searchParams.append(key, String(value));
+    }
+  }
+  const queryString = searchParams.toString();
+  return queryString ? `${fullUrl}?${queryString}` : fullUrl;
+}
+function normalizeHeaders(headers) {
+  if (!headers) return {};
+  if (Array.isArray(headers)) return Object.fromEntries(headers);
+  return { ...headers };
+}
+function defaultIdempotencyKey() {
+  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+    return crypto.randomUUID();
+  }
+  return `idem-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 12)}`;
+}
+async function client(config) {
+  const ctx = config.context;
+  if (!ctx) {
+    throw new Error(
+      "[vayo/core-sdk] internal: RequestConfig.context is missing. Generated clients must be invoked through createVayoPartnerClient()."
+    );
+  }
+  const baseURL = config.baseURL ?? ctx.baseUrl;
+  const url = buildUrl(baseURL, config.url, config.params);
+  const headers = normalizeHeaders(config.headers);
+  const method = (config.method ?? "GET").toUpperCase();
+  headers["x-api-key"] = ctx.apiKey;
+  if (MUTATING_METHODS.has(method) && !headers["Idempotency-Key"]) {
+    headers["Idempotency-Key"] = ctx.idempotencyKey ?? (ctx.generateIdempotencyKey ?? defaultIdempotencyKey)();
+  }
+  if (!headers["Content-Type"] && !(config.data instanceof FormData)) {
+    headers["Content-Type"] = "application/json";
+  }
+  let body;
+  if (config.data instanceof FormData) {
+    body = config.data;
+  } else if (config.data !== void 0) {
+    body = JSON.stringify(config.data);
+  }
+  const fetchImpl = ctx.fetch ?? fetch;
+  const response = await fetchImpl(url, {
+    method,
+    headers,
+    body,
+    signal: config.signal,
+    // Default to 'omit' (not 'include') because partners never share cookies
+    // cross-origin with Vayo. The webapp uses 'include' for first-party flows
+    // — partners use header auth.
+    credentials: config.credentials ?? "omit"
+  });
+  let data;
+  if (NO_BODY_STATUSES.has(response.status)) {
+    data = {};
+  } else {
+    data = await response.json().catch(() => ({}));
+  }
+  if (!response.ok) {
+    throw VayoApiError.fromBody(
+      response.status,
+      response.statusText,
+      data
+    );
+  }
+  return {
+    data,
+    status: response.status,
+    statusText: response.statusText,
+    headers: response.headers
+  };
+}
+var http_default = client;
+
+// src/generated/clients/getHealthModeS.ts
+function getGetHealthModeSUrl() {
+  const res = { method: "GET", url: `/health/mode-s` };
+  return res;
+}
+async function getHealthModeS(config = {}) {
+  const { client: request = http_default, ...requestConfig } = config;
+  const res = await request({ method: "GET", url: getGetHealthModeSUrl().url.toString(), ...requestConfig });
+  return res.data;
+}
+
+// src/generated/clients/getV1DashboardAllowlist.ts
+function getGetV1DashboardAllowlistUrl() {
+  const res = { method: "GET", url: `/v1/dashboard/allowlist` };
+  return res;
+}
+async function getV1DashboardAllowlist(config = {}) {
+  const { client: request = http_default, ...requestConfig } = config;
+  const res = await request({ method: "GET", url: getGetV1DashboardAllowlistUrl().url.toString(), ...requestConfig });
+  return res.data;
+}
+
+// src/generated/clients/getV1DashboardApiKeys.ts
+function getGetV1DashboardApiKeysUrl() {
+  const res = { method: "GET", url: `/v1/dashboard/api-keys` };
+  return res;
+}
+async function getV1DashboardApiKeys(config = {}) {
+  const { client: request = http_default, ...requestConfig } = config;
+  const res = await request({ method: "GET", url: getGetV1DashboardApiKeysUrl().url.toString(), ...requestConfig });
+  return res.data;
+}
+
+// src/generated/clients/getV1DashboardConsumption.ts
+function getGetV1DashboardConsumptionUrl() {
+  const res = { method: "GET", url: `/v1/dashboard/consumption` };
+  return res;
+}
+async function getV1DashboardConsumption(config = {}) {
+  const { client: request = http_default, ...requestConfig } = config;
+  const res = await request({ method: "GET", url: getGetV1DashboardConsumptionUrl().url.toString(), ...requestConfig });
+  return res.data;
+}
+
+// src/generated/clients/getV1DashboardInvestmentPerformance.ts
+function getGetV1DashboardInvestmentPerformanceUrl() {
+  const res = { method: "GET", url: `/v1/dashboard/investment-performance` };
+  return res;
+}
+async function getV1DashboardInvestmentPerformance(config = {}) {
+  const { client: request = http_default, ...requestConfig } = config;
+  const res = await request({ method: "GET", url: getGetV1DashboardInvestmentPerformanceUrl().url.toString(), ...requestConfig });
+  return res.data;
+}
+
+// src/generated/clients/getV1DashboardOverview.ts
+function getGetV1DashboardOverviewUrl() {
+  const res = { method: "GET", url: `/v1/dashboard/overview` };
+  return res;
+}
+async function getV1DashboardOverview(config = {}) {
+  const { client: request = http_default, ...requestConfig } = config;
+  const res = await request({ method: "GET", url: getGetV1DashboardOverviewUrl().url.toString(), ...requestConfig });
+  return res.data;
+}
+
+// src/generated/clients/getV1DashboardPartnerFees.ts
+function getGetV1DashboardPartnerFeesUrl() {
+  const res = { method: "GET", url: `/v1/dashboard/partner-fees` };
+  return res;
+}
+async function getV1DashboardPartnerFees(config = {}) {
+  const { client: request = http_default, ...requestConfig } = config;
+  const res = await request({ method: "GET", url: getGetV1DashboardPartnerFeesUrl().url.toString(), ...requestConfig });
+  return res.data;
+}
+
+// src/generated/clients/getV1DashboardPartnerFeesPayouts.ts
+function getGetV1DashboardPartnerFeesPayoutsUrl() {
+  const res = { method: "GET", url: `/v1/dashboard/partner-fees/payouts` };
+  return res;
+}
+async function getV1DashboardPartnerFeesPayouts(params, config = {}) {
+  const { client: request = http_default, ...requestConfig } = config;
+  const res = await request({ method: "GET", url: getGetV1DashboardPartnerFeesPayoutsUrl().url.toString(), params, ...requestConfig });
+  return res.data;
+}
+
+// src/generated/clients/getV1DashboardPerformanceFees.ts
+function getGetV1DashboardPerformanceFeesUrl() {
+  const res = { method: "GET", url: `/v1/dashboard/performance-fees` };
+  return res;
+}
+async function getV1DashboardPerformanceFees(config = {}) {
+  const { client: request = http_default, ...requestConfig } = config;
+  const res = await request({ method: "GET", url: getGetV1DashboardPerformanceFeesUrl().url.toString(), ...requestConfig });
+  return res.data;
+}
+
+// src/generated/clients/getV1DashboardTransactions.ts
+function getGetV1DashboardTransactionsUrl() {
+  const res = { method: "GET", url: `/v1/dashboard/transactions` };
+  return res;
+}
+async function getV1DashboardTransactions(params, config = {}) {
+  const { client: request = http_default, ...requestConfig } = config;
+  const res = await request({ method: "GET", url: getGetV1DashboardTransactionsUrl().url.toString(), params, ...requestConfig });
+  return res.data;
+}
+
+// src/generated/clients/getV1DashboardUsers.ts
+function getGetV1DashboardUsersUrl() {
+  const res = { method: "GET", url: `/v1/dashboard/users` };
+  return res;
+}
+async function getV1DashboardUsers(params, config = {}) {
+  const { client: request = http_default, ...requestConfig } = config;
+  const res = await request({ method: "GET", url: getGetV1DashboardUsersUrl().url.toString(), params, ...requestConfig });
+  return res.data;
+}
+
+// src/generated/clients/getV1LendingMarkets.ts
+function getGetV1LendingMarketsUrl() {
+  const res = { method: "GET", url: `/v1/lending/markets` };
+  return res;
+}
+async function getV1LendingMarkets(config = {}) {
+  const { client: request = http_default, ...requestConfig } = config;
+  const res = await request({ method: "GET", url: getGetV1LendingMarketsUrl().url.toString(), ...requestConfig });
+  return res.data;
+}
+
+// src/generated/clients/getV1LendingReserves.ts
+function getGetV1LendingReservesUrl() {
+  const res = { method: "GET", url: `/v1/lending/reserves` };
+  return res;
+}
+async function getV1LendingReserves(params, config = {}) {
+  const { client: request = http_default, ...requestConfig } = config;
+  const res = await request({ method: "GET", url: getGetV1LendingReservesUrl().url.toString(), params, ...requestConfig });
+  return res.data;
+}
+
+// src/generated/clients/postV1LendingOperationsRedeemAllocatedBuild.ts
+function getPostV1LendingOperationsRedeemAllocatedBuildUrl() {
+  const res = { method: "POST", url: `/v1/lending-operations/redeem-allocated/build` };
+  return res;
+}
+async function postV1LendingOperationsRedeemAllocatedBuild(data, params, config = {}) {
+  const { client: request = http_default, ...requestConfig } = config;
+  const requestData = data;
+  const res = await request({ method: "POST", url: getPostV1LendingOperationsRedeemAllocatedBuildUrl().url.toString(), params, data: requestData, ...requestConfig });
+  return res.data;
+}
+
+// src/generated/clients/postV1LendingOperationsRedeemAllocatedSubmit.ts
+function getPostV1LendingOperationsRedeemAllocatedSubmitUrl() {
+  const res = { method: "POST", url: `/v1/lending-operations/redeem-allocated/submit` };
+  return res;
+}
+async function postV1LendingOperationsRedeemAllocatedSubmit(data, config = {}) {
+  const { client: request = http_default, ...requestConfig } = config;
+  const requestData = data;
+  const res = await request({ method: "POST", url: getPostV1LendingOperationsRedeemAllocatedSubmitUrl().url.toString(), data: requestData, ...requestConfig });
+  return res.data;
+}
+
+// src/mode-s/verify-fee-recipients.ts
+function assertFeeRecipientsMatch(observed, expected) {
+  const observedAddresses = new Set(observed.map((r) => r.address));
+  const missing = [];
+  if (!observedAddresses.has(expected.partnerPayoutAddress)) {
+    missing.push(`partner payout (${expected.partnerPayoutAddress})`);
+  }
+  if (!observedAddresses.has(expected.vayoTreasuryAddress)) {
+    missing.push(`Vayo treasury (${expected.vayoTreasuryAddress})`);
+  }
+  if (missing.length > 0) {
+    throw new RangeError(
+      `[vayo/core-sdk] /build response is missing expected fee recipients: ${missing.join(
+        ", "
+      )}. Refusing to sign \u2014 contact partners@vayo.finance.`
+    );
+  }
+}
+
+// src/mode-s/redeem.ts
+var U64_MAX = "18446744073709551615";
+function createModeSHelper(deps) {
+  return {
+    async redeem(input) {
+      const built = await deps.buildRedeem({
+        body: {
+          privyDid: input.privyDid,
+          marketAddress: input.marketAddress,
+          tokenMint: input.tokenMint,
+          amount: input.amount ?? U64_MAX,
+          reserveAddress: input.reserveAddress
+        },
+        idempotencyKey: input.idempotencyKey,
+        signal: input.signal
+      });
+      if (input.expectedFeeRecipients) {
+        assertFeeRecipientsMatch(
+          built.expectedFeeRecipients,
+          input.expectedFeeRecipients
+        );
+      }
+      const signedTx = await input.signTransaction(built.serializedTx);
+      if (typeof signedTx !== "string" || signedTx.length === 0) {
+        throw new TypeError(
+          "[vayo/core-sdk] signTransaction must return a non-empty base64 string"
+        );
+      }
+      try {
+        const submitted = await deps.submitSignedRedeem({
+          body: {
+            pendingRedeemId: built.pendingRedeemId,
+            serializedTx: signedTx
+          },
+          idempotencyKey: input.idempotencyKey,
+          signal: input.signal
+        });
+        return {
+          signature: submitted.signature,
+          pendingRedeemId: built.pendingRedeemId,
+          expectedFeeRecipients: built.expectedFeeRecipients,
+          cosignersAttached: built.cosignersAttached,
+          viaFallbackRpc: false
+        };
+      } catch (err) {
+        if (!input.fallbackRpcUrl) throw err;
+        const signature = await broadcastViaRpc(
+          input.fallbackRpcUrl,
+          signedTx,
+          input.signal
+        );
+        return {
+          signature,
+          pendingRedeemId: built.pendingRedeemId,
+          expectedFeeRecipients: built.expectedFeeRecipients,
+          cosignersAttached: built.cosignersAttached,
+          viaFallbackRpc: true
+        };
+      }
+    }
+  };
+}
+async function broadcastViaRpc(rpcUrl, serializedTxBase64, signal) {
+  const fetchImpl = fetch;
+  const res = await fetchImpl(rpcUrl, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({
+      jsonrpc: "2.0",
+      id: 1,
+      method: "sendTransaction",
+      params: [
+        serializedTxBase64,
+        { encoding: "base64", skipPreflight: false }
+      ]
+    }),
+    signal
+  });
+  if (!res.ok) {
+    throw new Error(
+      `[vayo/core-sdk] direct RPC fallback failed: ${res.status} ${res.statusText}`
+    );
+  }
+  const body = await res.json();
+  if (body.error) {
+    throw new Error(
+      `[vayo/core-sdk] direct RPC sendTransaction error: ${body.error.message}`
+    );
+  }
+  if (!body.result) {
+    throw new Error("[vayo/core-sdk] direct RPC returned empty result");
+  }
+  return body.result;
+}
+
+// src/mode-s/supply.ts
+function createModeSSupplyHelper(deps) {
+  return {
+    async supply(input) {
+      const built = await deps.buildSupply({
+        body: {
+          privyDid: input.privyDid,
+          marketAddress: input.marketAddress,
+          tokenMint: input.tokenMint,
+          amount: input.amount,
+          reserveAddress: input.reserveAddress
+        },
+        idempotencyKey: input.idempotencyKey,
+        signal: input.signal
+      });
+      const signedTx = await input.signTransaction(built.serializedTx);
+      if (typeof signedTx !== "string" || signedTx.length === 0) {
+        throw new TypeError(
+          "[vayo/core-sdk] signTransaction must return a non-empty base64 string"
+        );
+      }
+      const submitted = await deps.submitSignedSupply({
+        body: {
+          pendingSupplyId: built.pendingSupplyId,
+          serializedTx: signedTx
+        },
+        idempotencyKey: input.idempotencyKey,
+        signal: input.signal
+      });
+      return {
+        signature: submitted.signature,
+        pendingSupplyId: built.pendingSupplyId,
+        cosignersAttached: built.cosignersAttached
+      };
+    }
+  };
+}
+
+// src/wallet/withdraw.ts
+function createWalletHelper(deps) {
+  return {
+    async withdraw(input) {
+      const prepared = await deps.prepareWithdrawal({
+        body: {
+          privyDid: input.privyDid,
+          destinationAddress: input.destinationAddress,
+          amount: input.amount,
+          exactRecipientAmount: input.exactRecipientAmount
+        },
+        idempotencyKey: input.idempotencyKey,
+        signal: input.signal
+      });
+      const signedMemoTx = await input.signTransaction(
+        prepared.serializedMemoTransaction
+      );
+      if (typeof signedMemoTx !== "string" || signedMemoTx.length === 0) {
+        throw new TypeError(
+          "[vayo/core-sdk] signTransaction must return a non-empty base64 string"
+        );
+      }
+      const submitted = await deps.submitWithdrawal({
+        body: {
+          pendingWithdrawalId: prepared.pendingWithdrawalId,
+          signedIntentTransaction: signedMemoTx
+        },
+        idempotencyKey: input.idempotencyKey,
+        signal: input.signal
+      });
+      return {
+        signature: submitted.signature,
+        transactionId: submitted.transactionId,
+        pendingWithdrawalId: prepared.pendingWithdrawalId,
+        memoChallenge: prepared.memoChallenge
+      };
+    }
+  };
+}
+
+// src/client.ts
+function buildRequestConfig(ctxBase, opts) {
+  return {
+    signal: opts.signal,
+    context: {
+      ...ctxBase,
+      idempotencyKey: opts.idempotencyKey
+    }
+  };
+}
+function createVayoPartnerClient(options) {
+  if (!options.baseUrl) {
+    throw new Error(
+      "[vayo/core-sdk] createVayoPartnerClient: baseUrl is required"
+    );
+  }
+  if (!options.apiKey) {
+    throw new Error(
+      "[vayo/core-sdk] createVayoPartnerClient: apiKey is required"
+    );
+  }
+  const baseUrl = options.baseUrl.replace(/\/+$/, "");
+  const ctxBase = {
+    baseUrl,
+    apiKey: options.apiKey,
+    fetch: options.fetch,
+    generateIdempotencyKey: options.generateIdempotencyKey
+  };
+  const cfg = (opts) => buildRequestConfig(ctxBase, opts);
+  const lending = {
+    markets: (args) => getV1LendingMarkets(cfg({ signal: args?.signal })),
+    reserves: (args) => {
+      const { mints, signal } = args ?? {};
+      const params = mints ? { mints: Array.isArray(mints) ? mints.join(",") : mints } : void 0;
+      return getV1LendingReserves(params, cfg({ signal }));
+    }
+  };
+  const buildRedeem = ({
+    body,
+    query,
+    idempotencyKey,
+    signal
+  }) => postV1LendingOperationsRedeemAllocatedBuild(
+    body,
+    query,
+    cfg({ idempotencyKey, signal })
+  );
+  const submitSignedRedeem = ({
+    body,
+    idempotencyKey,
+    signal
+  }) => postV1LendingOperationsRedeemAllocatedSubmit(
+    body,
+    cfg({ idempotencyKey, signal })
+  );
+  const modeSHelper = createModeSHelper({ buildRedeem, submitSignedRedeem });
+  const rawCall = async (method, url, opts = {}) => {
+    const res = await client({
+      method,
+      url,
+      data: opts.body,
+      signal: opts.signal,
+      context: { ...ctxBase, idempotencyKey: opts.idempotencyKey }
+    });
+    return res.data;
+  };
+  const buildSupply = ({
+    body,
+    query,
+    idempotencyKey,
+    signal
+  }) => {
+    const qs = query?.gasless ? `?gasless=${query.gasless}` : "";
+    return rawCall(
+      "POST",
+      `/v1/lending-operations/supply-allocated/build${qs}`,
+      { body, idempotencyKey, signal }
+    );
+  };
+  const submitSignedSupply = ({
+    body,
+    idempotencyKey,
+    signal
+  }) => rawCall(
+    "POST",
+    "/v1/lending-operations/supply-allocated/submit",
+    { body, idempotencyKey, signal }
+  );
+  const confirmRedeem = ({
+    body,
+    idempotencyKey,
+    signal
+  }) => rawCall(
+    "POST",
+    "/v1/lending-operations/redeem-allocated/confirm",
+    { body, idempotencyKey, signal }
+  );
+  const confirmSupply = ({
+    body,
+    idempotencyKey,
+    signal
+  }) => rawCall(
+    "POST",
+    "/v1/lending-operations/supply-allocated/confirm",
+    { body, idempotencyKey, signal }
+  );
+  const modeSSupplyHelper = createModeSSupplyHelper({
+    buildSupply,
+    submitSignedSupply
+  });
+  const modeS = {
+    buildRedeem,
+    submitSignedRedeem,
+    redeem: modeSHelper.redeem,
+    buildSupply,
+    submitSignedSupply,
+    supply: modeSSupplyHelper.supply,
+    confirmRedeem,
+    confirmSupply
+  };
+  const prepareWithdrawal = ({
+    body,
+    idempotencyKey,
+    signal
+  }) => rawCall("POST", "/v1/wallet/withdraw/prepare", {
+    body,
+    idempotencyKey,
+    signal
+  });
+  const submitWithdrawal = ({
+    body,
+    idempotencyKey,
+    signal
+  }) => rawCall("POST", "/v1/wallet/withdraw/submit", {
+    body,
+    idempotencyKey,
+    signal
+  });
+  const walletHelper = createWalletHelper({
+    prepareWithdrawal,
+    submitWithdrawal
+  });
+  const wallet = {
+    prepareWithdrawal,
+    submitWithdrawal,
+    withdraw: walletHelper.withdraw
+  };
+  const positions = {
+    read: ({ body, idempotencyKey, signal }) => rawCall("POST", "/v1/positions/read", {
+      body,
+      idempotencyKey,
+      signal
+    })
+  };
+  const webhooks = {
+    create: ({ body, idempotencyKey, signal }) => rawCall("POST", "/v1/webhooks", {
+      body,
+      idempotencyKey,
+      signal
+    }),
+    list: (args) => rawCall("GET", "/v1/webhooks", {
+      signal: args?.signal
+    }),
+    delete: ({ subscriptionId, idempotencyKey, signal }) => rawCall("DELETE", `/v1/webhooks/${subscriptionId}`, {
+      idempotencyKey,
+      signal
+    }),
+    rotateSecret: ({ subscriptionId, idempotencyKey, signal }) => rawCall(
+      "POST",
+      `/v1/webhooks/${subscriptionId}/rotate-secret`,
+      { idempotencyKey, signal }
+    ),
+    test: ({ subscriptionId, idempotencyKey, signal }) => rawCall(
+      "POST",
+      `/v1/webhooks/${subscriptionId}/test`,
+      { idempotencyKey, signal }
+    ),
+    deliveries: ({ subscriptionId, cursor, limit, status, signal }) => {
+      const params = new URLSearchParams();
+      if (cursor) params.set("cursor", cursor);
+      if (limit !== void 0) params.set("limit", String(limit));
+      if (status) params.set("status", status);
+      const qs = params.toString();
+      return rawCall(
+        "GET",
+        `/v1/webhooks/${subscriptionId}/deliveries${qs ? `?${qs}` : ""}`,
+        { signal }
+      );
+    }
+  };
+  const dashboard = {
+    overview: (args) => getV1DashboardOverview(cfg({ signal: args?.signal })),
+    users: (args) => {
+      const { signal, limit, offset, activeOnly } = args ?? {};
+      const params = limit !== void 0 || offset !== void 0 || activeOnly !== void 0 ? { limit, offset, activeOnly } : void 0;
+      return getV1DashboardUsers(params, cfg({ signal }));
+    },
+    transactions: (args) => {
+      const { signal, type, status, limit, offset } = args ?? {};
+      const params = type !== void 0 || status !== void 0 || limit !== void 0 || offset !== void 0 ? { type, status, limit, offset } : void 0;
+      return getV1DashboardTransactions(params, cfg({ signal }));
+    },
+    consumption: (args) => getV1DashboardConsumption(cfg({ signal: args?.signal })),
+    investmentPerformance: (args) => getV1DashboardInvestmentPerformance(cfg({ signal: args?.signal })),
+    performanceFees: (args) => getV1DashboardPerformanceFees(cfg({ signal: args?.signal })),
+    partnerFees: (args) => getV1DashboardPartnerFees(cfg({ signal: args?.signal })),
+    partnerFeesPayouts: (args) => {
+      const { signal, limit, offset } = args ?? {};
+      const params = limit !== void 0 || offset !== void 0 ? { limit, offset } : void 0;
+      return getV1DashboardPartnerFeesPayouts(params, cfg({ signal }));
+    },
+    allowlist: (args) => getV1DashboardAllowlist(cfg({ signal: args?.signal })),
+    apiKeys: (args) => getV1DashboardApiKeys(cfg({ signal: args?.signal }))
+  };
+  const healthGet = async (url, signal) => {
+    const res = await client({
+      method: "GET",
+      url,
+      signal,
+      context: { ...ctxBase, idempotencyKey: void 0 }
+    });
+    return res.data;
+  };
+  const health = {
+    liveness: (args) => healthGet("/health", args?.signal),
+    ready: (args) => healthGet("/health/ready", args?.signal),
+    kora: (args) => healthGet("/health/kora", args?.signal),
+    modeS: (args) => getHealthModeS(cfg({ signal: args?.signal }))
+  };
+  const agents = {
+    provision: ({ body, idempotencyKey, signal }) => rawCall("POST", "/v1/agents/provision", {
+      body,
+      idempotencyKey,
+      signal
+    })
+  };
+  return {
+    lending,
+    modeS,
+    wallet,
+    positions,
+    webhooks,
+    dashboard,
+    health,
+    agents,
+    options: Object.freeze({ ...options })
+  };
+}
+
+// src/constants.ts
+var U64_MAX2 = "18446744073709551615";
+var USDC_MINT = "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v";
+function verifyWebhookSignature(secret, body, signatureHeader) {
+  if (!signatureHeader) return false;
+  const prefix = "sha256=";
+  if (!signatureHeader.startsWith(prefix)) return false;
+  const expected = signatureHeader.slice(prefix.length);
+  const computed = createHmac("sha256", secret).update(body).digest("hex");
+  if (expected.length !== computed.length) return false;
+  try {
+    return timingSafeEqual(Buffer.from(expected), Buffer.from(computed));
+  } catch {
+    return false;
+  }
+}
+
+export { U64_MAX2 as U64_MAX, USDC_MINT, VayoApiError, assertFeeRecipientsMatch, createVayoPartnerClient, verifyWebhookSignature };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map