@vayolabs/core-sdk 0.1.0

package/dist/client-BdGPlaqU.d.cts

@@ -0,0 +1,588 @@
+import { b as GetV1DashboardUsersQueryParams, a as GetV1DashboardTransactionsQueryParams, G as GetV1DashboardPartnerFeesPayoutsQueryParams, P as PostV1LendingOperationsRedeemAllocatedBuildMutationRequest, c as PostV1LendingOperationsRedeemAllocatedBuildQueryParams, d as PostV1LendingOperationsRedeemAllocatedSubmitMutationRequest } from './PostV1LendingOperationsRedeemAllocatedSubmit-znL3KL6k.cjs';
+
+/**
+ * Defense-3 mirror — local verification of the fee recipients embedded in
+ * the partially-signed transaction returned by `/build`.
+ *
+ * Catches the (unlikely) case where Vayo's fee math drifted vs. what the
+ * partner is expecting in their dashboard, before the partner wastes a
+ * Privy/HSM signing call. The cryptographic safety net (witness signature
+ * binding the message hash) is still the load-bearing check — this is just
+ * a fast-fail surface that gives partners a clear error message.
+ */
+interface ExpectedFeeRecipients {
+    /** Partner's payout wallet (USDC ATA owner). */
+    partnerPayoutAddress: string;
+    /** Vayo's treasury wallet. */
+    vayoTreasuryAddress: string;
+}
+interface ObservedFeeRecipient {
+    address: string;
+    amount: string;
+}
+/**
+ * Asserts that both the partner payout address AND Vayo treasury address
+ * appear among the fee transfers Vayo embedded. Throws a `RangeError` with
+ * a clear message listing the missing addresses if either is absent.
+ */
+declare function assertFeeRecipientsMatch(observed: readonly ObservedFeeRecipient[], expected: ExpectedFeeRecipients): void;
+
+/**
+ * Layer 2 — `client.modeS.redeem()` — opinionated Mode S orchestrator.
+ *
+ * Runs the full build → verify → sign → submit flow that every Mode S
+ * partner needs. Built so the only piece partners must implement themselves
+ * is the `signTransaction` callback (typically backed by `@privy-io/node`,
+ * Squads, an HSM, or any other Solana signer).
+ *
+ * Sequence:
+ *   1. POST /v1/lending-operations/redeem-allocated/build
+ *   2. (Optional) Verify embedded fee recipients match the partner's expectation
+ *   3. Invoke `signTransaction` with the partially-signed wire bytes (base64)
+ *   4. POST /v1/lending-operations/redeem-allocated/submit
+ *   5. (Optional) On /submit failure, fall back to broadcasting via the
+ *      partner's own RPC URL — the witness signature is still load-bearing
+ *      so the cryptographic guarantee holds either way.
+ *
+ * The orchestrator is intentionally callback-driven (not coupled to a
+ * specific signer) so the same code path works for Privy users, Squads
+ * users, partners with custom HSMs, and future signers.
+ */
+
+/**
+ * The signing callback partners provide. Receives the base64-encoded
+ * partially-signed transaction (with Vayo's witness signature already
+ * attached) and must return the base64-encoded fully-signed transaction
+ * with the user-wallet authority signature added.
+ *
+ * Implementations typically:
+ *   1. Decode the base64 → wire bytes
+ *   2. Hand to a signer SDK (Privy, Squads, etc.)
+ *   3. Re-encode the resulting fully-signed transaction → base64
+ *
+ * For Privy users, see `@vayolabs/core-sdk/mode-s/privy` which exports a
+ * pre-built `createPrivySigner()` adapter.
+ */
+type SignTransactionCallback = (serializedTxBase64: string) => Promise<string>;
+interface RedeemModeSInput {
+    /** Privy DID of the user (in the partner's Privy app). */
+    privyDid: string;
+    /** Single market — multi-market not supported in MVP because each redeem is its own tx. */
+    marketAddress: string;
+    /** Token mint (e.g. USDC). */
+    tokenMint: string;
+    /**
+     * Token base units. Pass `U64_MAX` (from `@vayolabs/core-sdk`) for a full
+     * redeem. Defaults to `U64_MAX` if omitted.
+     */
+    amount?: string;
+    /** Optional reserve override (for markets with multiple reserves of the same mint). */
+    reserveAddress?: string;
+    /** Partner-supplied signer. See `SignTransactionCallback` for the contract. */
+    signTransaction: SignTransactionCallback;
+    /**
+     * Optional Defense-3 mirror. When provided, the orchestrator verifies the
+     * embedded fee transfers match these addresses BEFORE invoking
+     * `signTransaction`. Strongly recommended.
+     */
+    expectedFeeRecipients?: ExpectedFeeRecipients;
+    /**
+     * Optional fallback. When `/submit` fails (e.g. Vayo transient error), the
+     * orchestrator broadcasts the signed tx directly to this RPC URL via
+     * `sendTransaction`. The reconciliation CRON later picks up the on-chain
+     * signature and writes the partner_fee_payouts row.
+     */
+    fallbackRpcUrl?: string;
+    /** Caller-provided idempotency key. Reused across both /build and /submit. */
+    idempotencyKey?: string;
+    /** AbortSignal — propagated to both /build and /submit. */
+    signal?: AbortSignal;
+}
+interface RedeemModeSResult {
+    /** Confirmed (or freshly-submitted) transaction signature. */
+    signature: string;
+    /** The cached pendingRedeemId from /build (useful for log correlation). */
+    pendingRedeemId: string;
+    /** The fee recipients that were embedded by Vayo and signed off-chain. */
+    expectedFeeRecipients: ReadonlyArray<{
+        address: string;
+        amount: string;
+    }>;
+    /** Cosigners that were attached at build time. */
+    cosignersAttached: ReadonlyArray<"witness" | "kora">;
+    /** True when the result came from the direct-RPC fallback path. */
+    viaFallbackRpc: boolean;
+}
+interface ModeSHelper {
+    /** Run the full Mode S redeem flow. See `RedeemModeSInput` for options. */
+    redeem(input: RedeemModeSInput, opts?: CallOptions): Promise<RedeemModeSResult>;
+}
+
+/**
+ * Layer 2 — `client.modeS.supply()` — Mode S supply orchestrator.
+ *
+ * Mirrors the Mode S redeem flow for supplies:
+ *   1. POST /v1/lending-operations/supply-allocated/build
+ *   2. Invoke partner's `signTransaction` with the partially-signed tx
+ *   3. POST /v1/lending-operations/supply-allocated/submit
+ */
+
+interface BuildSupplyResponse {
+    serializedTx: string;
+    pendingSupplyId: string;
+    cosignersAttached: Array<"witness" | "kora">;
+    expiresAt: string;
+}
+interface SubmitSignedSupplyResponse {
+    signature: string;
+    confirmed: boolean;
+}
+interface SupplyModeSInput {
+    privyDid: string;
+    marketAddress: string;
+    tokenMint: string;
+    amount: string;
+    reserveAddress?: string;
+    signTransaction: SignTransactionCallback;
+    idempotencyKey?: string;
+    signal?: AbortSignal;
+}
+interface SupplyModeSResult {
+    signature: string;
+    pendingSupplyId: string;
+    cosignersAttached: ReadonlyArray<"witness" | "kora">;
+}
+interface ModeSSupplyHelper {
+    supply(input: SupplyModeSInput, opts?: CallOptions): Promise<SupplyModeSResult>;
+}
+
+/**
+ * Response shapes for `client.positions.read()`. Hand-rolled to mirror
+ * `apps/api/src/core/domain/entities/lending-reserve.ts` because Elysia's
+ * exported swagger types responses as `any`.
+ */
+interface PositionRewardEntry {
+    rewardMint: string;
+    rewardSymbol?: string;
+    amount: string;
+    usdValue: number;
+}
+interface UserPosition {
+    marketAddress: string;
+    marketName: string;
+    reserveAddress?: string;
+    reserveName: string;
+    mint?: string;
+    decimals: number;
+    exchangeRate: number;
+    price: number;
+    supplyAPY: number;
+    suppliedFormatted: string;
+    suppliedUsd: number;
+    rewards: PositionRewardEntry[];
+    /** Net USD deposited into this specific reserve. */
+    netDepositedUsd?: number;
+    /** Real accumulated yield: `suppliedUsd - netDepositedUsd`. */
+    accumulatedYieldUsd?: number;
+}
+interface ReadPositionsResponse {
+    positions: UserPosition[];
+    totalSuppliedUsd: number;
+    netDepositedUsd: number;
+    accumulatedYieldUsd: number;
+    timestamp: string;
+    investedSince: string | null;
+}
+
+/**
+ * Layer 2 — `client.wallet.withdraw()` — async memo-challenge orchestrator.
+ *
+ * Withdrawals are gated by the user's embedded-wallet 2FA memo. The
+ * orchestrator runs:
+ *   1. POST /v1/wallet/withdraw/prepare
+ *   2. Invoke partner's `signTransaction` with the unsigned memo skeleton
+ *   3. POST /v1/wallet/withdraw/submit
+ *
+ * Vayo never broadcasts the signed memo — it's a proof-of-possession only.
+ * The actual USDC transfer is broadcast by Vayo after verifying the memo.
+ */
+
+interface PrepareWithdrawalResponse {
+    pendingWithdrawalId: string;
+    memoChallenge: string;
+    serializedMemoTransaction: string;
+    userWalletAddress: string;
+    expiresAt: string;
+}
+interface SubmitWithdrawalResponse {
+    signature: string;
+    transactionId: string;
+}
+interface WithdrawInput {
+    privyDid: string;
+    destinationAddress: string;
+    amount: string;
+    exactRecipientAmount?: boolean;
+    signTransaction: SignTransactionCallback;
+    idempotencyKey?: string;
+    signal?: AbortSignal;
+}
+interface WithdrawResult {
+    signature: string;
+    transactionId: string;
+    pendingWithdrawalId: string;
+    memoChallenge: string;
+}
+interface WalletHelper {
+    withdraw(input: WithdrawInput, opts?: CallOptions): Promise<WithdrawResult>;
+}
+
+interface WebhookSubscription {
+    id: string;
+    partnerId: string;
+    url: string;
+    events: string[];
+    description: string | null;
+    isActive: boolean;
+    createdAt: string;
+    updatedAt: string;
+}
+interface CreateWebhookSubscriptionResponse extends WebhookSubscription {
+    secret: string;
+}
+interface RotateWebhookSecretResponse {
+    id: string;
+    secret: string;
+    rotatedAt: string;
+}
+interface DispatchWebhookEventResponse {
+    eventId: string;
+    deliveriesEnqueued: number;
+}
+interface WebhookDelivery {
+    id: string;
+    eventId: string;
+    eventType: string;
+    status: "pending" | "delivered" | "retrying" | "permanently_failed";
+    attempts: number;
+    nextRetryAt: string | null;
+    lastAttemptAt: string | null;
+    responseStatus: number | null;
+    createdAt: string;
+}
+interface ListWebhookDeliveriesResponse {
+    items: WebhookDelivery[];
+    nextCursor: string | null;
+}
+/**
+ * Verify a webhook delivery's HMAC signature.
+ *
+ * @param secret  The signing secret returned at subscription creation (or rotation)
+ * @param body    The raw request body bytes you received (DO NOT re-stringify)
+ * @param signatureHeader  Value of the `X-Vayo-Signature` header (e.g. `sha256=abc...`)
+ * @returns true when the signature matches; false otherwise
+ */
+declare function verifyWebhookSignature(secret: string, body: string, signatureHeader: string | null | undefined): boolean;
+
+/**
+ * Layer 1 — `createVayoPartnerClient()` — the ergonomic typed client.
+ *
+ * Wraps the kubb-generated raw client functions in a tag-grouped object so
+ * partners get autocomplete that mirrors the OpenAPI tags
+ * (`client.lending.markets()`, `client.modeS.buildRedeem()`, etc.). Auth,
+ * idempotency-key generation, and structured errors are handled inside the
+ * shared `http.ts` wrapper — this file is just plumbing.
+ *
+ * All partner endpoints authenticate with the `x-api-key` header alone; there
+ * are no JWT-guarded routes in the current surface.
+ *
+ * Per-call options:
+ *   - `idempotencyKey`  — caller-provided idempotency key. Required for safe
+ *                         retries on mutating routes; auto-generated if absent.
+ *   - `signal`          — AbortSignal to cancel in-flight requests.
+ */
+
+interface VayoPartnerClientOptions {
+    /** Vayo API base URL — e.g. `https://api.vayo.finance`. No trailing slash. */
+    baseUrl: string;
+    /** Partner API key issued via `POST /admin/partners/:id/api-keys`. */
+    apiKey: string;
+    /** Optional fetch override (Node 18-, edge runtimes, instrumentation). */
+    fetch?: typeof fetch;
+    /** Optional idempotency-key generator override (default: `crypto.randomUUID`). */
+    generateIdempotencyKey?: () => string;
+}
+/** Common per-call options threaded through every method. */
+interface CallOptions {
+    /** AbortSignal to cancel the request. */
+    signal?: AbortSignal;
+    /** Caller-provided idempotency key (mutating routes). Auto-generated if absent. */
+    idempotencyKey?: string;
+}
+/** `client.lending.*` — read-only market/reserve data. */
+interface LendingMethods {
+    /** List markets allowed by the partner's allowlist. @see GET /v1/lending/markets */
+    markets(args?: CallOptions): Promise<unknown>;
+    /** Flat reserves across markets, optionally filtered by mints. @see GET /v1/lending/reserves */
+    reserves(args?: {
+        mints?: string[] | string;
+    } & CallOptions): Promise<unknown>;
+}
+/** `client.modeS.*` — build/submit + opinionated `redeem()` and `supply()` orchestrators. */
+interface ModeSMethods extends ModeSHelper, ModeSSupplyHelper {
+    /**
+     * Build a partially-signed redeem tx with the witness cosignature.
+     * @see POST /v1/lending-operations/redeem-allocated/build
+     */
+    buildRedeem(args: {
+        body: PostV1LendingOperationsRedeemAllocatedBuildMutationRequest;
+        query?: PostV1LendingOperationsRedeemAllocatedBuildQueryParams;
+    } & CallOptions): Promise<BuildRedeemResponse>;
+    /**
+     * Submit a fully-signed redeem tx (Vayo re-verifies cosigners + relays).
+     * @see POST /v1/lending-operations/redeem-allocated/submit
+     */
+    submitSignedRedeem(args: {
+        body: PostV1LendingOperationsRedeemAllocatedSubmitMutationRequest;
+    } & CallOptions): Promise<SubmitSignedRedeemResponse>;
+    /**
+     * Build a partially-signed supply tx with the witness cosignature.
+     * @see POST /v1/lending-operations/supply-allocated/build
+     */
+    buildSupply(args: {
+        body: {
+            privyDid: string;
+            marketAddress: string;
+            tokenMint: string;
+            amount: string;
+            reserveAddress?: string;
+        };
+        query?: {
+            gasless?: "true" | "false";
+        };
+    } & CallOptions): Promise<BuildSupplyResponse>;
+    /**
+     * Submit a fully-signed supply tx (Vayo re-verifies cosigners + relays).
+     * @see POST /v1/lending-operations/supply-allocated/submit
+     */
+    submitSignedSupply(args: {
+        body: {
+            pendingSupplyId: string;
+            serializedTx: string;
+        };
+    } & CallOptions): Promise<SubmitSignedSupplyResponse>;
+    /**
+     * Confirm a redeem the partner submitted on-chain via their own RPC/signer.
+     * Vayo fetches the tx by signature, verifies the witness memo
+     * `vayo-witness:<pendingRedeemId>` is present, and marks the pending row
+     * confirmed.
+     * @see POST /v1/lending-operations/redeem-allocated/confirm
+     */
+    confirmRedeem(args: {
+        body: {
+            pendingRedeemId: string;
+            signature: string;
+            marketAddress: string;
+            status?: "confirmed" | "failed";
+            errorMessage?: string;
+        };
+    } & CallOptions): Promise<ConfirmModeSResponse>;
+    /**
+     * Confirm a supply the partner submitted on-chain via their own RPC/signer.
+     * @see POST /v1/lending-operations/supply-allocated/confirm
+     */
+    confirmSupply(args: {
+        body: {
+            pendingSupplyId: string;
+            signature: string;
+            marketAddress: string;
+            status?: "confirmed" | "failed";
+            errorMessage?: string;
+        };
+    } & CallOptions): Promise<ConfirmModeSResponse>;
+}
+interface ConfirmModeSResponse {
+    accepted: boolean;
+    idempotent?: boolean;
+    recorded?: "confirmed" | "failed";
+    signature?: string;
+    reason?: string;
+}
+/** `client.positions.*` — read live Kamino positions for a partner-user. */
+interface PositionsMethods {
+    /**
+     * Read a user's live Kamino positions (supplied amounts, accumulated yield,
+     * per-market breakdown). The user must sign a memo intent of the form
+     * `vayo:read-positions:<walletAddress>:<partnerSlug>:<unixSeconds>` with
+     * their wallet — the signed transaction is never broadcast on-chain. The
+     * memo is partner-bound so a signature authorized for partner A cannot be
+     * replayed by partner B.
+     *
+     * @see POST /v1/positions/read
+     */
+    read(args: {
+        body: {
+            /** Solana wallet address (base58) whose positions to read. */
+            walletAddress: string;
+            /**
+             * Base64 V0 transaction with a single Memo instruction signed by
+             * the wallet owner.
+             */
+            signedIntentTransaction: string;
+        };
+    } & CallOptions): Promise<ReadPositionsResponse>;
+}
+/** `client.wallet.*` — async memo-challenge withdrawal. */
+interface WalletMethods extends WalletHelper {
+    /** @see POST /v1/wallet/withdraw/prepare */
+    prepareWithdrawal(args: {
+        body: {
+            privyDid: string;
+            destinationAddress: string;
+            amount: string;
+            exactRecipientAmount?: boolean;
+        };
+    } & CallOptions): Promise<PrepareWithdrawalResponse>;
+    /** @see POST /v1/wallet/withdraw/submit */
+    submitWithdrawal(args: {
+        body: {
+            pendingWithdrawalId: string;
+            signedIntentTransaction: string;
+        };
+    } & CallOptions): Promise<SubmitWithdrawalResponse>;
+}
+/** `client.webhooks.*` — outbound event subscriptions. */
+interface WebhooksMethods {
+    /** @see POST /v1/webhooks */
+    create(args: {
+        body: {
+            url: string;
+            events: string[];
+            description?: string;
+        };
+    } & CallOptions): Promise<CreateWebhookSubscriptionResponse>;
+    /** @see GET /v1/webhooks */
+    list(args?: CallOptions): Promise<WebhookSubscription[]>;
+    /** @see DELETE /v1/webhooks/:subscriptionId */
+    delete(args: {
+        subscriptionId: string;
+    } & CallOptions): Promise<{
+        deleted: true;
+    }>;
+    /** @see POST /v1/webhooks/:subscriptionId/rotate-secret */
+    rotateSecret(args: {
+        subscriptionId: string;
+    } & CallOptions): Promise<RotateWebhookSecretResponse>;
+    /** @see POST /v1/webhooks/:subscriptionId/test */
+    test(args: {
+        subscriptionId: string;
+    } & CallOptions): Promise<DispatchWebhookEventResponse>;
+    /** @see GET /v1/webhooks/:subscriptionId/deliveries */
+    deliveries(args: {
+        subscriptionId: string;
+        cursor?: string;
+        limit?: number;
+        status?: "pending" | "delivered" | "retrying" | "permanently_failed";
+    } & CallOptions): Promise<ListWebhookDeliveriesResponse>;
+}
+/** `client.dashboard.*` — partner self-service analytics. */
+interface DashboardMethods {
+    /** @see GET /v1/dashboard/overview */
+    overview(args?: CallOptions): Promise<unknown>;
+    /** @see GET /v1/dashboard/users */
+    users(args?: GetV1DashboardUsersQueryParams & CallOptions): Promise<unknown>;
+    /** @see GET /v1/dashboard/transactions */
+    transactions(args?: GetV1DashboardTransactionsQueryParams & CallOptions): Promise<unknown>;
+    /** @see GET /v1/dashboard/consumption */
+    consumption(args?: CallOptions): Promise<unknown>;
+    /** @see GET /v1/dashboard/investment-performance */
+    investmentPerformance(args?: CallOptions): Promise<unknown>;
+    /** @deprecated Legacy alias of `partnerFees`. @see GET /v1/dashboard/performance-fees */
+    performanceFees(args?: CallOptions): Promise<unknown>;
+    /** @see GET /v1/dashboard/partner-fees */
+    partnerFees(args?: CallOptions): Promise<unknown>;
+    /** @see GET /v1/dashboard/partner-fees/payouts */
+    partnerFeesPayouts(args?: GetV1DashboardPartnerFeesPayoutsQueryParams & CallOptions): Promise<unknown>;
+    /** @see GET /v1/dashboard/allowlist */
+    allowlist(args?: CallOptions): Promise<unknown>;
+    /** @see GET /v1/dashboard/api-keys */
+    apiKeys(args?: CallOptions): Promise<unknown>;
+}
+/** `client.health.*` — service + signing subsystem health. */
+interface HealthMethods {
+    /** Basic liveness probe. @see GET /health */
+    liveness(args?: CallOptions): Promise<unknown>;
+    /** Readiness probe. @see GET /health/ready */
+    ready(args?: CallOptions): Promise<unknown>;
+    /** Kora gasless relayer health. @see GET /health/kora */
+    kora(args?: CallOptions): Promise<unknown>;
+    /** Mode S witness/cosigner health. @see GET /health/mode-s */
+    modeS(args?: CallOptions): Promise<unknown>;
+}
+/**
+ * Response shape of `POST /v1/lending-operations/redeem-allocated/build`.
+ *
+ * The OpenAPI spec types this as `any` because Elysia auto-generates schemas
+ * from request validators only — response shapes aren't captured in the
+ * exported swagger. We type it here so partners get autocomplete on the
+ * redeem helper. Source of truth:
+ * `apps/api/src/core/use-cases/build-redeem-transaction.ts:58`.
+ */
+interface BuildRedeemResponse {
+    /** Base64-encoded wire transaction with the witness signature attached. */
+    serializedTx: string;
+    /** Lookup key for `/submit`. Cached for 5 minutes. */
+    pendingRedeemId: string;
+    /** Embedded fee transfers — verify before user-signing. */
+    expectedFeeRecipients: Array<{
+        address: string;
+        amount: string;
+    }>;
+    /** Cosigners attached at build time. Always includes 'witness'. */
+    cosignersAttached: Array<"witness" | "kora">;
+    expiresAt: string;
+}
+/**
+ * Response shape of `POST /v1/lending-operations/redeem-allocated/submit`.
+ * Same caveat as `BuildRedeemResponse` — typed by hand because the OpenAPI
+ * spec returns `any`. Source: `apps/api/src/core/use-cases/submit-signed-redeem.ts:19`.
+ */
+interface SubmitSignedRedeemResponse {
+    signature: string;
+    confirmed: boolean;
+}
+/** `client.agents.*` — self-provisioning for BYOW agents (no Privy). */
+interface AgentsMethods {
+    /**
+     * Mint a Vayo identity (`user` + `agent_wallet`) for a wallet the agent
+     * controls itself. Idempotent. Returns `{ privyDid, userId, walletAddress,
+     * created }` — pass the `privyDid` to subsequent Mode-S calls.
+     * @see POST /v1/agents/provision
+     */
+    provision(args: {
+        body: {
+            walletAddress: string;
+        };
+    } & CallOptions): Promise<ProvisionAgentResponse>;
+}
+interface ProvisionAgentResponse {
+    privyDid: string;
+    userId: string;
+    walletAddress: string;
+    created: boolean;
+}
+interface VayoPartnerClient {
+    lending: LendingMethods;
+    modeS: ModeSMethods;
+    wallet: WalletMethods;
+    positions: PositionsMethods;
+    webhooks: WebhooksMethods;
+    dashboard: DashboardMethods;
+    health: HealthMethods;
+    agents: AgentsMethods;
+    /** Read-only view of the SDK options the client was constructed with. */
+    readonly options: Readonly<VayoPartnerClientOptions>;
+}
+declare function createVayoPartnerClient(options: VayoPartnerClientOptions): VayoPartnerClient;
+
+export { type BuildRedeemResponse as B, type CallOptions as C, type DashboardMethods as D, type ExpectedFeeRecipients as E, type HealthMethods as H, type LendingMethods as L, type ModeSHelper as M, type ObservedFeeRecipient as O, type PositionRewardEntry as P, type ReadPositionsResponse as R, type SignTransactionCallback as S, type UserPosition as U, type VayoPartnerClient as V, type WalletHelper as W, type BuildSupplyResponse as a, type CreateWebhookSubscriptionResponse as b, type DispatchWebhookEventResponse as c, type ListWebhookDeliveriesResponse as d, type ModeSMethods as e, type ModeSSupplyHelper as f, type PositionsMethods as g, type PrepareWithdrawalResponse as h, type RedeemModeSInput as i, type RedeemModeSResult as j, type RotateWebhookSecretResponse as k, type SubmitSignedRedeemResponse as l, type SubmitSignedSupplyResponse as m, type SubmitWithdrawalResponse as n, type SupplyModeSInput as o, type SupplyModeSResult as p, type VayoPartnerClientOptions as q, type WalletMethods as r, type WebhookDelivery as s, type WebhookSubscription as t, type WebhooksMethods as u, type WithdrawInput as v, type WithdrawResult as w, assertFeeRecipientsMatch as x, createVayoPartnerClient as y, verifyWebhookSignature as z };