@venlyfinance/react 0.5.0 → 0.6.0

package/CHANGELOG.md

@@ -48,3 +48,42 @@ Initial release.
   matching `venlyQueries` factories; the account-scoped key shares the
   `["venly", "account", id]` prefix so account invalidations reach it.
 - Requires `@venlyfinance/sdk` ^0.5.0 (the `supportedAssets` resource).
+
+## 0.5.0 – 2026-08-21
+
+*(Entry backfilled 2026-08-21 – this release shipped without a changelog note.)*
+
+- `useTransfersForPeriod(accountId, period)`: every transfer whose `createdAt`
+  falls in the period, plus the account's full ledger after paging to
+  completion (the list contract has no date filter), so opening/closing
+  balances can be walked from the current wallet total. Backed by the exported
+  `collectTransfersForPeriod` helper and the `venlyKeys.transfersForPeriod`
+  key.
+- New exported types: `TransferPeriod`, `TransfersForPeriodPage`.
+
+## 0.6.0 – 2026-08-21
+
+- `usePartyIvVerification(partyId)`: the party's identity-verification state,
+  read off the contract operation (`getPartyIvVerification`, sdk 0.7.0).
+  `NOT_LINKED` resolves like any other state.
+- Payout read hooks over client methods that already existed but had no hook:
+  `usePayouts(accountId, query?)`, `usePayout(accountId, payoutId)`,
+  `usePayoutRoutes(accountId, query?)`, `usePayoutBankAccounts(partyId, query?)`.
+- Matching `venlyKeys` / `venlyQueries` factories; the party-scoped keys share
+  the `["venly", "party", id]` prefix and the account-scoped keys the
+  `["venly", "account", id]` prefix, so existing invalidations reach the new
+  reads.
+- New exported types: `PartyIvVerification`, `PayoutsQuery`,
+  `PayoutRoutesQuery`, `PayoutBankAccountsQuery`.
+- Write hooks for the send surface: `useCreateFiatTransfer` and
+  `useCreateCryptoTransfer` (typed entries into the staged-transfer machine –
+  the idempotency key is minted once per staged draft, so a retry replays the
+  same record), `useRequestPayout`, `useRegisterPayoutBankAccount`,
+  `useCreatePayoutRoute`, `usePreparePayoutOwnershipProof`,
+  `useCompletePayoutOwnershipProof`, `useAddPartyRole`; plus the
+  `usePartyRoles(accountId, query?)` read with its `venlyKeys` /
+  `venlyQueries` factory. New exported types: `PartyRolesQuery`,
+  `FiatTransferDraft`, `CryptoTransferDraft`.
+- Requires `@venlyfinance/sdk` ^0.7.0 (the `parties.ivVerification` method).
+  The manifest range moves with the publish, alongside the lockfile
+  regeneration, per this repo's publish sequencing.

package/dist/flows/staged-transfer.d.ts

@@ -111,4 +111,32 @@ export declare function useStagedTransfer(options?: StagedTransferOptions): {
     confirm: () => Promise<void>;
     reset: () => void;
 };
+export type FiatTransferDraft = Omit<Extract<TransferDraft, {
+    kind: "fiat";
+}>, "kind">;
+export type CryptoTransferDraft = Omit<Extract<TransferDraft, {
+    kind: "crypto";
+}>, "kind">;
+/**
+ * Create a fiat transfer, wired through the staged-transfer flow: stage()
+ * freezes the exact request and pins ONE idempotency key per staged draft;
+ * confirm() executes once and polls to a terminal status. However often
+ * confirm() is retried on the same staged draft, the API replays the same
+ * record instead of moving money twice.
+ */
+export declare function useCreateFiatTransfer(options?: StagedTransferOptions): {
+    stage: (draft: FiatTransferDraft) => boolean;
+    state: StagedTransferState;
+    edit: () => void;
+    confirm: () => Promise<void>;
+    reset: () => void;
+};
+/** The crypto twin of {@link useCreateFiatTransfer}: same machine, same key rule. */
+export declare function useCreateCryptoTransfer(options?: StagedTransferOptions): {
+    stage: (draft: CryptoTransferDraft) => boolean;
+    state: StagedTransferState;
+    edit: () => void;
+    confirm: () => Promise<void>;
+    reset: () => void;
+};
 export {};

package/dist/flows/staged-transfer.js

@@ -186,3 +186,25 @@ export function useStagedTransfer(options) {
         reset: () => controller.reset(),
     };
 }
+/**
+ * Create a fiat transfer, wired through the staged-transfer flow: stage()
+ * freezes the exact request and pins ONE idempotency key per staged draft;
+ * confirm() executes once and polls to a terminal status. However often
+ * confirm() is retried on the same staged draft, the API replays the same
+ * record instead of moving money twice.
+ */
+export function useCreateFiatTransfer(options) {
+    const flow = useStagedTransfer(options);
+    return {
+        ...flow,
+        stage: (draft) => flow.stage({ kind: "fiat", ...draft }),
+    };
+}
+/** The crypto twin of {@link useCreateFiatTransfer}: same machine, same key rule. */
+export function useCreateCryptoTransfer(options) {
+    const flow = useStagedTransfer(options);
+    return {
+        ...flow,
+        stage: (draft) => flow.stage({ kind: "crypto", ...draft }),
+    };
+}

package/dist/index.d.ts

@@ -1,11 +1,11 @@
 export { VenlyProvider, useVenly, useVenlyMock, type VenlyClients, type VenlyProviderProps, type VenlyReactEnvironment, } from "./provider.js";
 export { venlyKeys } from "./keys.js";
-export { venlyQueries, type AccountsQuery, type FeeQuoteInput, type PartiesQuery, type RampRequestsQuery, type TransfersQuery, type VirtualBankAccountsQuery, type WalletsQuery, } from "./query-options.js";
-export { useAccount, useAccounts, useCompanyFees, useFeeQuote, useParties, useParty, useRampRequest, useRampRequests, useReferenceData, useTransfer, useTransfers, useTransfersForPeriod, collectTransfersForPeriod, type TransferPeriod, type TransfersForPeriodPage, useVirtualBankAccounts, useWallets, useCompanyBankAccount, useCompanyBankAccounts, useCompanyWallets, useBankAccountConfig, useDepositWallets, useRampPairs, useSupportedAssets, useAccountSupportedAssets, } from "./queries.js";
-export { useCreateAccount, useCreateParty, useCreatePaymentSession, useCreateRampRequest, useCreateVirtualBankAccount, useCreateCompanyBankAccount, useCreateCompanyWallet, useSetRampAmount, useInitiateRamp, } from "./mutations.js";
-export { StagedTransferController, useStagedTransfer, validateDraft, type StagedRequest, type StagedTransferOptions, type StagedTransferState, type TransferDraft, } from "./flows/staged-transfer.js";
+export { venlyQueries, type AccountsQuery, type FeeQuoteInput, type PartiesQuery, type PartyRolesQuery, type PayoutBankAccountsQuery, type PayoutRoutesQuery, type PayoutsQuery, type RampRequestsQuery, type TransfersQuery, type VirtualBankAccountsQuery, type WalletsQuery, } from "./query-options.js";
+export { useAccount, useAccounts, useCompanyFees, useFeeQuote, useParties, useParty, usePartyIvVerification, usePartyRoles, usePayout, usePayoutBankAccounts, usePayoutRoutes, usePayouts, useRampRequest, useRampRequests, useReferenceData, useTransfer, useTransfers, useTransfersForPeriod, collectTransfersForPeriod, type TransferPeriod, type TransfersForPeriodPage, useVirtualBankAccounts, useWallets, useCompanyBankAccount, useCompanyBankAccounts, useCompanyWallets, useBankAccountConfig, useDepositWallets, useRampPairs, useSupportedAssets, useAccountSupportedAssets, useWebhooks, useWebhook, } from "./queries.js";
+export { useCreateAccount, useCreateParty, useCreatePaymentSession, useCreateRampRequest, useCreateVirtualBankAccount, useCreateCompanyBankAccount, useCreateCompanyWallet, useSetRampAmount, useInitiateRamp, useCreateWebhook, useUpdateWebhook, useDeleteWebhook, usePingWebhook, useAddPartyRole, useRegisterPayoutBankAccount, useCreatePayoutRoute, usePreparePayoutOwnershipProof, useCompletePayoutOwnershipProof, useRequestPayout, } from "./mutations.js";
+export { StagedTransferController, useStagedTransfer, useCreateFiatTransfer, useCreateCryptoTransfer, validateDraft, type CryptoTransferDraft, type FiatTransferDraft, type StagedRequest, type StagedTransferOptions, type StagedTransferState, type TransferDraft, } from "./flows/staged-transfer.js";
 export { approvalCapabilities, interpretApprovalError, useFourEyesApproval, type ApprovalCapability, type ApprovalFailureKind, type FourEyesState, } from "./flows/four-eyes.js";
 export { describeRampStatus, useRampLifecycle, type RampLifecycleOptions, type RampStatus, type RampStatusDescriptor, } from "./flows/ramp-lifecycle.js";
 export { proxyClientOptions, VENLY_PROXY_SECRET_SENTINEL, type ProxyClientOptions, } from "./proxy.js";
 export { FundflowClient, VenlyApiError, VenlyAuthError, VenlyFinanceClient, } from "@venlyfinance/sdk";
-export type { Account, Party, RampRequest, Transfer, VirtualBankAccount, WalletBalance, Payout, PayoutRoute, PayoutBankAccount, } from "@venlyfinance/sdk";
+export type { Account, Party, PartyIvVerification, RampRequest, Transfer, VirtualBankAccount, WalletBalance, Payout, PayoutRoute, PayoutBankAccount, Webhook, CreateWebhookRequest, UpdateWebhookRequest, WebhookAuthenticationMethod, MockWebhookDelivery, MockTenantConfig, } from "@venlyfinance/sdk";

package/dist/index.js

@@ -4,11 +4,11 @@ export { VenlyProvider, useVenly, useVenlyMock, } from "./provider.js";
 export { venlyKeys } from "./keys.js";
 export { venlyQueries, } from "./query-options.js";
 // Read hooks
-export { useAccount, useAccounts, useCompanyFees, useFeeQuote, useParties, useParty, useRampRequest, useRampRequests, useReferenceData, useTransfer, useTransfers, useTransfersForPeriod, collectTransfersForPeriod, useVirtualBankAccounts, useWallets, useCompanyBankAccount, useCompanyBankAccounts, useCompanyWallets, useBankAccountConfig, useDepositWallets, useRampPairs, useSupportedAssets, useAccountSupportedAssets, } from "./queries.js";
+export { useAccount, useAccounts, useCompanyFees, useFeeQuote, useParties, useParty, usePartyIvVerification, usePartyRoles, usePayout, usePayoutBankAccounts, usePayoutRoutes, usePayouts, useRampRequest, useRampRequests, useReferenceData, useTransfer, useTransfers, useTransfersForPeriod, collectTransfersForPeriod, useVirtualBankAccounts, useWallets, useCompanyBankAccount, useCompanyBankAccounts, useCompanyWallets, useBankAccountConfig, useDepositWallets, useRampPairs, useSupportedAssets, useAccountSupportedAssets, useWebhooks, useWebhook, } from "./queries.js";
 // Write hooks
-export { useCreateAccount, useCreateParty, useCreatePaymentSession, useCreateRampRequest, useCreateVirtualBankAccount, useCreateCompanyBankAccount, useCreateCompanyWallet, useSetRampAmount, useInitiateRamp, } from "./mutations.js";
+export { useCreateAccount, useCreateParty, useCreatePaymentSession, useCreateRampRequest, useCreateVirtualBankAccount, useCreateCompanyBankAccount, useCreateCompanyWallet, useSetRampAmount, useInitiateRamp, useCreateWebhook, useUpdateWebhook, useDeleteWebhook, usePingWebhook, useAddPartyRole, useRegisterPayoutBankAccount, useCreatePayoutRoute, usePreparePayoutOwnershipProof, useCompletePayoutOwnershipProof, useRequestPayout, } from "./mutations.js";
 // Flow machines: the regulated-money lifecycles
-export { StagedTransferController, useStagedTransfer, validateDraft, } from "./flows/staged-transfer.js";
+export { StagedTransferController, useStagedTransfer, useCreateFiatTransfer, useCreateCryptoTransfer, validateDraft, } from "./flows/staged-transfer.js";
 export { approvalCapabilities, interpretApprovalError, useFourEyesApproval, } from "./flows/four-eyes.js";
 export { describeRampStatus, useRampLifecycle, } from "./flows/ramp-lifecycle.js";
 // Browser-safe deployment shape

package/dist/keys.d.ts

@@ -6,13 +6,19 @@ export declare const venlyKeys: {
     readonly all: readonly ["venly"];
     readonly parties: (query?: unknown) => readonly ["venly", "parties", {} | null];
     readonly party: (partyId: string) => readonly ["venly", "party", string];
+    readonly partyIvVerification: (partyId: string) => readonly ["venly", "party", string, "iv-verification"];
+    readonly payoutBankAccounts: (partyId: string, query?: unknown) => readonly ["venly", "party", string, "payout-bank-accounts", {} | null];
     readonly accounts: (query?: unknown) => readonly ["venly", "accounts", {} | null];
     readonly account: (accountId: string) => readonly ["venly", "account", string];
+    readonly partyRoles: (accountId: string, query?: unknown) => readonly ["venly", "account", string, "party-roles", {} | null];
     readonly wallets: (accountId: string, query?: unknown) => readonly ["venly", "account", string, "wallets", {} | null];
     readonly supportedAssets: () => readonly ["venly", "supported-assets"];
     readonly accountSupportedAssets: (accountId: string) => readonly ["venly", "account", string, "supported-assets"];
     readonly virtualBankAccounts: (accountId: string, query?: unknown) => readonly ["venly", "account", string, "virtual-bank-accounts", {} | null];
     readonly transfers: (accountId: string, query?: unknown) => readonly ["venly", "account", string, "transfers", {} | null];
+    readonly payouts: (accountId: string, query?: unknown) => readonly ["venly", "account", string, "payouts", {} | null];
+    readonly payout: (accountId: string, payoutId: string) => readonly ["venly", "account", string, "payout", string];
+    readonly payoutRoutes: (accountId: string, query?: unknown) => readonly ["venly", "account", string, "payout-routes", {} | null];
     readonly transfersForPeriod: (accountId: string, period: {
         start: string;
         end: string;
@@ -20,6 +26,8 @@ export declare const venlyKeys: {
     readonly transfer: (accountId: string, transferId: string) => readonly ["venly", "account", string, "transfer", string];
     readonly rampRequests: (query?: unknown) => readonly ["venly", "ramp-requests", {} | null];
     readonly rampRequest: (id: string) => readonly ["venly", "ramp-request", string];
+    readonly webhooks: () => readonly ["venly", "webhooks"];
+    readonly webhook: (webhookId: string) => readonly ["venly", "webhook", string];
     readonly referenceData: () => readonly ["venly", "reference-data"];
     readonly companyBankAccounts: (query?: unknown) => readonly ["venly", "company-bank-accounts", {} | null];
     readonly companyBankAccount: (id: string) => readonly ["venly", "company-bank-account", string];

package/dist/keys.js

@@ -6,17 +6,26 @@ export const venlyKeys = {
     all: ["venly"],
     parties: (query) => ["venly", "parties", query ?? null],
     party: (partyId) => ["venly", "party", partyId],
+    // Shares the ["venly","party",id] prefix so a party invalidation reaches it.
+    partyIvVerification: (partyId) => ["venly", "party", partyId, "iv-verification"],
+    payoutBankAccounts: (partyId, query) => ["venly", "party", partyId, "payout-bank-accounts", query ?? null],
     accounts: (query) => ["venly", "accounts", query ?? null],
     account: (accountId) => ["venly", "account", accountId],
+    partyRoles: (accountId, query) => ["venly", "account", accountId, "party-roles", query ?? null],
     wallets: (accountId, query) => ["venly", "account", accountId, "wallets", query ?? null],
     supportedAssets: () => ["venly", "supported-assets"],
     accountSupportedAssets: (accountId) => ["venly", "account", accountId, "supported-assets"],
     virtualBankAccounts: (accountId, query) => ["venly", "account", accountId, "virtual-bank-accounts", query ?? null],
     transfers: (accountId, query) => ["venly", "account", accountId, "transfers", query ?? null],
+    payouts: (accountId, query) => ["venly", "account", accountId, "payouts", query ?? null],
+    payout: (accountId, payoutId) => ["venly", "account", accountId, "payout", payoutId],
+    payoutRoutes: (accountId, query) => ["venly", "account", accountId, "payout-routes", query ?? null],
     transfersForPeriod: (accountId, period) => ["venly", "account", accountId, "transfers-for-period", period.start, period.end],
     transfer: (accountId, transferId) => ["venly", "account", accountId, "transfer", transferId],
     rampRequests: (query) => ["venly", "ramp-requests", query ?? null],
     rampRequest: (id) => ["venly", "ramp-request", id],
+    webhooks: () => ["venly", "webhooks"],
+    webhook: (webhookId) => ["venly", "webhook", webhookId],
     referenceData: () => ["venly", "reference-data"],
     companyBankAccounts: (query) => ["venly", "company-bank-accounts", query ?? null],
     companyBankAccount: (id) => ["venly", "company-bank-account", id],

package/dist/mutations.d.ts

@@ -125,6 +125,115 @@ export declare function useCreateRampRequest(): import("@tanstack/react-query").
     fiatCurrencyId: string;
     cryptoCurrencyId: string;
 }, unknown>;
+type AddPartyRoleBody = Parameters<VenlyFinanceClient["accounts"]["addPartyRole"]>[1];
+type RegisterPayoutBankAccountBody = Parameters<VenlyFinanceClient["payoutBankAccounts"]["register"]>[1];
+type CreatePayoutRouteBody = Parameters<VenlyFinanceClient["payoutRoutes"]["create"]>[1];
+type CompleteOwnershipProofBody = Parameters<VenlyFinanceClient["payoutRoutes"]["completeOwnershipProof"]>[2];
+type RequestPayoutBody = Parameters<VenlyFinanceClient["payouts"]["request"]>[1];
+/**
+ * Attach a party to an account with a role (PAYOUT_RECIPIENT for saved
+ * third-party recipients), then refresh the account's role list.
+ */
+export declare function useAddPartyRole(): import("@tanstack/react-query").UseMutationResult<{
+    partyId?: string;
+    roleType?: "ACCOUNT_HOLDER" | "PAYOUT_RECIPIENT";
+    status?: "ACTIVE" | "INACTIVE";
+    createdAt?: string;
+    updatedAt?: string;
+}, Error, {
+    accountId: string;
+    body: AddPartyRoleBody;
+}, unknown>;
+/**
+ * Register a beneficiary bank account on a party. The response's details
+ * come back masked server-side (last4, BIC) - render those, never re-ask.
+ * A new account starts PENDING until reviewed.
+ */
+export declare function useRegisterPayoutBankAccount(): import("@tanstack/react-query").UseMutationResult<{
+    id?: string;
+    partyId?: string;
+    rail?: "US_ACH" | "SEPA";
+    fiatCurrency?: string;
+    label?: string;
+    accountHolderName?: string;
+    details?: import("@venlyfinance/sdk").FinanceComponents["schemas"]["MaskedRailDetailsDto"];
+    bankName?: string;
+    beneficiaryEmail?: string;
+    beneficiaryPhoneNumber?: string;
+    bankAddress?: import("@venlyfinance/sdk").FinanceComponents["schemas"]["BankAddressDto"];
+    status?: "PENDING" | "ACTIVE" | "DISABLED";
+    createdAt?: string;
+    updatedAt?: string;
+}, Error, {
+    partyId: string;
+    body: RegisterPayoutBankAccountBody;
+}, unknown>;
+/**
+ * Bind a beneficiary bank account to an account and a deposit asset. The
+ * route activates only after wallet-ownership proof completes.
+ */
+export declare function useCreatePayoutRoute(): import("@tanstack/react-query").UseMutationResult<{
+    id?: string;
+    status?: "PENDING" | "REGISTERING" | "AWAITING_OWNERSHIP_PROOF" | "ACTIVE" | "REJECTED";
+    depositAsset?: import("@venlyfinance/sdk").FinanceComponents["schemas"]["DepositAssetDto"];
+    fiatCurrency?: string;
+    depositAddress?: string;
+    createdAt?: string;
+    updatedAt?: string;
+}, Error, {
+    accountId: string;
+    body: CreatePayoutRouteBody;
+}, unknown>;
+/**
+ * Fetch the message the route's funding wallet must sign. The server derives
+ * wallet and chain from the route; there is no request body.
+ */
+export declare function usePreparePayoutOwnershipProof(): import("@tanstack/react-query").UseMutationResult<{
+    walletAddress?: string;
+    blockchain?: string;
+    message?: string;
+    signedOnUtc?: string;
+}, Error, {
+    accountId: string;
+    routeId: string;
+}, unknown>;
+/** Submit the signed message; on success the route becomes ACTIVE. */
+export declare function useCompletePayoutOwnershipProof(): import("@tanstack/react-query").UseMutationResult<{
+    id?: string;
+    status?: "PENDING" | "REGISTERING" | "AWAITING_OWNERSHIP_PROOF" | "ACTIVE" | "REJECTED";
+    depositAsset?: import("@venlyfinance/sdk").FinanceComponents["schemas"]["DepositAssetDto"];
+    fiatCurrency?: string;
+    depositAddress?: string;
+    createdAt?: string;
+    updatedAt?: string;
+}, Error, {
+    accountId: string;
+    routeId: string;
+    body: CompleteOwnershipProofBody;
+}, unknown>;
+/**
+ * Request a third-party payout over an ACTIVE route. The body's
+ * idempotencyKey is the replay guard: mint it ONCE per staged draft and
+ * reuse it on every retry of the same draft - the API then executes the
+ * movement at most once and a replay returns the original record.
+ */
+export declare function useRequestPayout(): import("@tanstack/react-query").UseMutationResult<{
+    id?: string;
+    accountId?: string;
+    payoutRoute?: import("@venlyfinance/sdk").FinanceComponents["schemas"]["PayoutRouteInfoDto"];
+    rail?: "US_ACH" | "SEPA";
+    cryptoAmount?: number;
+    settledFiatAmount?: number;
+    fundingMode?: "PULL" | "PUSH";
+    status?: "REQUESTED" | "SENDING" | "PROVIDER_PROCESSING" | "COMPLETED" | "REJECTED" | "FAILED" | "RETURNED";
+    sendTxHash?: string;
+    requestedAt?: string;
+    completedAt?: string;
+    failureReason?: string;
+}, Error, {
+    accountId: string;
+    body: RequestPayoutBody;
+}, unknown>;
 type SetRampAmountBody = Parameters<FundflowClient["rampRequests"]["setAmount"]>[1];
 type InitiateRampBody = Parameters<FundflowClient["rampRequests"]["initiate"]>[1];
 /** Whitelist a company bank account (created PENDING, verified out-of-band). */
@@ -210,4 +319,42 @@ export declare function useInitiateRamp(): import("@tanstack/react-query").UseMu
     id: string;
     body: InitiateRampBody;
 }, unknown>;
+type UpdateWebhookBody = Parameters<VenlyFinanceClient["webhooks"]["update"]>[1];
+/** Register a webhook endpoint, then refresh the webhook list. */
+export declare function useCreateWebhook(): import("@tanstack/react-query").UseMutationResult<{
+    id?: string;
+    url?: string;
+    name?: string;
+    authenticationMethod?: import("@venlyfinance/sdk").FinanceComponents["schemas"]["ApiKeyAuthenticationMethod"] | import("@venlyfinance/sdk").FinanceComponents["schemas"]["BasicAuthenticationMethod"];
+    status?: "ACTIVE";
+}, Error, {
+    url: string;
+    name?: string;
+    authenticationMethod: import("@venlyfinance/sdk").FinanceComponents["schemas"]["ApiKeyAuthenticationMethod"] | import("@venlyfinance/sdk").FinanceComponents["schemas"]["BasicAuthenticationMethod"];
+}, unknown>;
+/** Replace a webhook's url/name/authentication (PUT semantics). */
+export declare function useUpdateWebhook(): import("@tanstack/react-query").UseMutationResult<{
+    id?: string;
+    url?: string;
+    name?: string;
+    authenticationMethod?: import("@venlyfinance/sdk").FinanceComponents["schemas"]["ApiKeyAuthenticationMethod"] | import("@venlyfinance/sdk").FinanceComponents["schemas"]["BasicAuthenticationMethod"];
+    status?: "ACTIVE";
+}, Error, {
+    webhookId: string;
+    body: UpdateWebhookBody;
+}, unknown>;
+/** Delete a webhook registration; deliveries to it stop. */
+export declare function useDeleteWebhook(): import("@tanstack/react-query").UseMutationResult<void, Error, string, unknown>;
+/**
+ * Fire a test delivery at the endpoint. Resolves the contract's void
+ * envelope so a surface can render the outcome verbatim; invalidates
+ * nothing - a ping changes no resource.
+ */
+export declare function usePingWebhook(): import("@tanstack/react-query").UseMutationResult<{
+    pagination?: import("@venlyfinance/sdk").FinanceComponents["schemas"]["Pagination"];
+    sort?: import("@venlyfinance/sdk").FinanceComponents["schemas"]["Sort"];
+    success?: boolean;
+    result?: unknown;
+    errors?: import("@venlyfinance/sdk").FinanceComponents["schemas"]["ErrorBody"][];
+}, Error, string, unknown>;
 export {};

package/dist/mutations.js

@@ -56,6 +56,103 @@ export function useCreateRampRequest() {
         },
     });
 }
+/**
+ * Attach a party to an account with a role (PAYOUT_RECIPIENT for saved
+ * third-party recipients), then refresh the account's role list.
+ */
+export function useAddPartyRole() {
+    const { finance } = useVenly();
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: (input) => finance.accounts.addPartyRole(input.accountId, input.body),
+        onSuccess: (_role, input) => {
+            void queryClient.invalidateQueries({
+                queryKey: ["venly", "account", input.accountId, "party-roles"],
+            });
+        },
+    });
+}
+/**
+ * Register a beneficiary bank account on a party. The response's details
+ * come back masked server-side (last4, BIC) - render those, never re-ask.
+ * A new account starts PENDING until reviewed.
+ */
+export function useRegisterPayoutBankAccount() {
+    const { finance } = useVenly();
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: (input) => finance.payoutBankAccounts.register(input.partyId, input.body),
+        onSuccess: (_account, input) => {
+            void queryClient.invalidateQueries({
+                queryKey: ["venly", "party", input.partyId, "payout-bank-accounts"],
+            });
+        },
+    });
+}
+/**
+ * Bind a beneficiary bank account to an account and a deposit asset. The
+ * route activates only after wallet-ownership proof completes.
+ */
+export function useCreatePayoutRoute() {
+    const { finance } = useVenly();
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: (input) => finance.payoutRoutes.create(input.accountId, input.body),
+        onSuccess: (_route, input) => {
+            void queryClient.invalidateQueries({
+                queryKey: ["venly", "account", input.accountId, "payout-routes"],
+            });
+        },
+    });
+}
+/**
+ * Fetch the message the route's funding wallet must sign. The server derives
+ * wallet and chain from the route; there is no request body.
+ */
+export function usePreparePayoutOwnershipProof() {
+    const { finance } = useVenly();
+    return useMutation({
+        mutationFn: (input) => finance.payoutRoutes.prepareOwnershipProof(input.accountId, input.routeId),
+    });
+}
+/** Submit the signed message; on success the route becomes ACTIVE. */
+export function useCompletePayoutOwnershipProof() {
+    const { finance } = useVenly();
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: (input) => finance.payoutRoutes.completeOwnershipProof(input.accountId, input.routeId, input.body),
+        onSuccess: (_route, input) => {
+            void queryClient.invalidateQueries({
+                queryKey: ["venly", "account", input.accountId, "payout-routes"],
+            });
+        },
+    });
+}
+/**
+ * Request a third-party payout over an ACTIVE route. The body's
+ * idempotencyKey is the replay guard: mint it ONCE per staged draft and
+ * reuse it on every retry of the same draft - the API then executes the
+ * movement at most once and a replay returns the original record.
+ */
+export function useRequestPayout() {
+    const { finance } = useVenly();
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: (input) => finance.payouts.request(input.accountId, input.body),
+        onSuccess: (payout, input) => {
+            if (payout.id) {
+                queryClient.setQueryData(venlyKeys.payout(input.accountId, payout.id), payout);
+            }
+            void queryClient.invalidateQueries({
+                queryKey: ["venly", "account", input.accountId, "payouts"],
+            });
+            // The request reserves funds, so the wallet rows moved too.
+            void queryClient.invalidateQueries({
+                queryKey: ["venly", "account", input.accountId, "wallets"],
+            });
+        },
+    });
+}
 /** Whitelist a company bank account (created PENDING, verified out-of-band). */
 export function useCreateCompanyBankAccount() {
     const { fundflow } = useVenly();
@@ -104,3 +201,51 @@ export function useInitiateRamp() {
         },
     });
 }
+/** Register a webhook endpoint, then refresh the webhook list. */
+export function useCreateWebhook() {
+    const { finance } = useVenly();
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: (body) => finance.webhooks.create(body),
+        onSuccess: (webhook) => {
+            if (webhook.id)
+                queryClient.setQueryData(venlyKeys.webhook(webhook.id), webhook);
+            void queryClient.invalidateQueries({ queryKey: venlyKeys.webhooks() });
+        },
+    });
+}
+/** Replace a webhook's url/name/authentication (PUT semantics). */
+export function useUpdateWebhook() {
+    const { finance } = useVenly();
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: (input) => finance.webhooks.update(input.webhookId, input.body),
+        onSuccess: (webhook, input) => {
+            queryClient.setQueryData(venlyKeys.webhook(input.webhookId), webhook);
+            void queryClient.invalidateQueries({ queryKey: venlyKeys.webhooks() });
+        },
+    });
+}
+/** Delete a webhook registration; deliveries to it stop. */
+export function useDeleteWebhook() {
+    const { finance } = useVenly();
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: (webhookId) => finance.webhooks.delete(webhookId),
+        onSuccess: (_void, webhookId) => {
+            queryClient.removeQueries({ queryKey: venlyKeys.webhook(webhookId) });
+            void queryClient.invalidateQueries({ queryKey: venlyKeys.webhooks() });
+        },
+    });
+}
+/**
+ * Fire a test delivery at the endpoint. Resolves the contract's void
+ * envelope so a surface can render the outcome verbatim; invalidates
+ * nothing - a ping changes no resource.
+ */
+export function usePingWebhook() {
+    const { finance } = useVenly();
+    return useMutation({
+        mutationFn: (webhookId) => finance.webhooks.ping(webhookId),
+    });
+}

package/dist/queries.d.ts

@@ -1,6 +1,6 @@
 import { type UseQueryOptions } from "@tanstack/react-query";
 import { type Page, type Transfer as TransferRow } from "@venlyfinance/sdk";
-import { venlyQueries, type AccountsQuery, type FeeQuoteInput, type PartiesQuery, type RampRequestsQuery, type TransfersQuery, type VirtualBankAccountsQuery, type WalletsQuery, type CompanyBankAccountsQuery, type CompanyWalletsQuery, type DepositWalletsQuery } from "./query-options.js";
+import { venlyQueries, type AccountsQuery, type FeeQuoteInput, type PartiesQuery, type PartyRolesQuery, type PayoutBankAccountsQuery, type PayoutRoutesQuery, type PayoutsQuery, type RampRequestsQuery, type TransfersQuery, type VirtualBankAccountsQuery, type WalletsQuery, type CompanyBankAccountsQuery, type CompanyWalletsQuery, type DepositWalletsQuery } from "./query-options.js";
 type Tune<T> = Omit<UseQueryOptions<T, Error>, "queryKey" | "queryFn">;
 export declare function useParties(query?: PartiesQuery, options?: Tune<PartiesPage>): import("@tanstack/react-query").UseQueryResult<NoInfer<Page<{
     id?: string;
@@ -36,6 +36,18 @@ export declare function useParty(partyId: string | undefined, options?: Tune<Par
     version?: number;
 }>, Error>;
 type Party = Awaited<ReturnType<ReturnType<typeof venlyQueries.party>["queryFn"]>>;
+/**
+ * The party's identity-verification state, from the contract operation
+ * (`getPartyIvVerification`). `NOT_LINKED` resolves like any other state -
+ * identity verification is a state every party has, not a resource some lack.
+ */
+export declare function usePartyIvVerification(partyId: string | undefined, options?: Tune<PartyIvVerification>): import("@tanstack/react-query").UseQueryResult<NoInfer<{
+    partyId?: string;
+    ivCaseReference?: string;
+    status?: "NOT_LINKED" | "SUBMITTED" | "FORWARDED" | "ACCEPTED" | "COMPLETED" | "FAILED";
+    linkedAt?: string;
+}>, Error>;
+type PartyIvVerification = Awaited<ReturnType<ReturnType<typeof venlyQueries.partyIvVerification>["queryFn"]>>;
 export declare function useAccounts(query?: AccountsQuery, options?: Tune<AccountsPage>): import("@tanstack/react-query").UseQueryResult<NoInfer<Page<{
     id?: string;
     externalId?: string;
@@ -56,6 +68,18 @@ export declare function useAccount(accountId: string | undefined, options?: Tune
     version?: number;
 }>, Error>;
 type Account = Awaited<ReturnType<ReturnType<typeof venlyQueries.account>["queryFn"]>>;
+/**
+ * The parties attached to an account with their role type and status.
+ * Saved payout recipients are the PAYOUT_RECIPIENT rows of this read.
+ */
+export declare function usePartyRoles(accountId: string | undefined, query?: PartyRolesQuery, options?: Tune<PartyRolesPage>): import("@tanstack/react-query").UseQueryResult<NoInfer<Page<{
+    partyId?: string;
+    roleType?: "ACCOUNT_HOLDER" | "PAYOUT_RECIPIENT";
+    status?: "ACTIVE" | "INACTIVE";
+    createdAt?: string;
+    updatedAt?: string;
+}>>, Error>;
+type PartyRolesPage = Awaited<ReturnType<ReturnType<typeof venlyQueries.partyRoles>["queryFn"]>>;
 export declare function useWallets(accountId: string | undefined, query?: WalletsQuery, options?: Tune<WalletsPage>): import("@tanstack/react-query").UseQueryResult<NoInfer<Page<{
     asset?: string;
     contractAddress?: string;
@@ -162,6 +186,63 @@ export declare function useTransfer(accountId: string | undefined, transferId: s
     updatedAt?: string;
 }>, Error>;
 type Transfer = Awaited<ReturnType<ReturnType<typeof venlyQueries.transfer>["queryFn"]>>;
+export declare function usePayouts(accountId: string | undefined, query?: PayoutsQuery, options?: Tune<PayoutsPage>): import("@tanstack/react-query").UseQueryResult<NoInfer<Page<{
+    id?: string;
+    accountId?: string;
+    payoutRoute?: import("@venlyfinance/sdk").FinanceComponents["schemas"]["PayoutRouteInfoDto"];
+    rail?: "US_ACH" | "SEPA";
+    cryptoAmount?: number;
+    settledFiatAmount?: number;
+    fundingMode?: "PULL" | "PUSH";
+    status?: "REQUESTED" | "SENDING" | "PROVIDER_PROCESSING" | "COMPLETED" | "REJECTED" | "FAILED" | "RETURNED";
+    sendTxHash?: string;
+    requestedAt?: string;
+    completedAt?: string;
+    failureReason?: string;
+}>>, Error>;
+type PayoutsPage = Awaited<ReturnType<ReturnType<typeof venlyQueries.payouts>["queryFn"]>>;
+export declare function usePayout(accountId: string | undefined, payoutId: string | undefined, options?: Tune<PayoutDetail>): import("@tanstack/react-query").UseQueryResult<NoInfer<{
+    id?: string;
+    accountId?: string;
+    payoutRoute?: import("@venlyfinance/sdk").FinanceComponents["schemas"]["PayoutRouteInfoDto"];
+    rail?: "US_ACH" | "SEPA";
+    cryptoAmount?: number;
+    settledFiatAmount?: number;
+    fundingMode?: "PULL" | "PUSH";
+    status?: "REQUESTED" | "SENDING" | "PROVIDER_PROCESSING" | "COMPLETED" | "REJECTED" | "FAILED" | "RETURNED";
+    sendTxHash?: string;
+    requestedAt?: string;
+    completedAt?: string;
+    failureReason?: string;
+}>, Error>;
+type PayoutDetail = Awaited<ReturnType<ReturnType<typeof venlyQueries.payout>["queryFn"]>>;
+export declare function usePayoutRoutes(accountId: string | undefined, query?: PayoutRoutesQuery, options?: Tune<PayoutRoutesList>): import("@tanstack/react-query").UseQueryResult<NoInfer<{
+    id?: string;
+    status?: "PENDING" | "REGISTERING" | "AWAITING_OWNERSHIP_PROOF" | "ACTIVE" | "REJECTED";
+    depositAsset?: import("@venlyfinance/sdk").FinanceComponents["schemas"]["DepositAssetDto"];
+    fiatCurrency?: string;
+    depositAddress?: string;
+    createdAt?: string;
+    updatedAt?: string;
+}[]>, Error>;
+type PayoutRoutesList = Awaited<ReturnType<ReturnType<typeof venlyQueries.payoutRoutes>["queryFn"]>>;
+export declare function usePayoutBankAccounts(partyId: string | undefined, query?: PayoutBankAccountsQuery, options?: Tune<PayoutBankAccountsPage>): import("@tanstack/react-query").UseQueryResult<NoInfer<Page<{
+    id?: string;
+    partyId?: string;
+    rail?: "US_ACH" | "SEPA";
+    fiatCurrency?: string;
+    label?: string;
+    accountHolderName?: string;
+    details?: import("@venlyfinance/sdk").FinanceComponents["schemas"]["MaskedRailDetailsDto"];
+    bankName?: string;
+    beneficiaryEmail?: string;
+    beneficiaryPhoneNumber?: string;
+    bankAddress?: import("@venlyfinance/sdk").FinanceComponents["schemas"]["BankAddressDto"];
+    status?: "PENDING" | "ACTIVE" | "DISABLED";
+    createdAt?: string;
+    updatedAt?: string;
+}>>, Error>;
+type PayoutBankAccountsPage = Awaited<ReturnType<ReturnType<typeof venlyQueries.payoutBankAccounts>["queryFn"]>>;
 export declare function useRampRequests(query?: RampRequestsQuery, options?: Tune<RampPage>): import("@tanstack/react-query").UseQueryResult<NoInfer<Page<{
     id?: string;
     paymentReference?: string;
@@ -226,6 +307,23 @@ export declare function useReferenceData(options?: Tune<ReferenceData>): import(
     }[];
 }>, Error>;
 type ReferenceData = Awaited<ReturnType<ReturnType<typeof venlyQueries.referenceData>["queryFn"]>>;
+/** The tenant's registered webhook endpoints. */
+export declare function useWebhooks(options?: Tune<WebhooksPage>): import("@tanstack/react-query").UseQueryResult<NoInfer<Page<{
+    id?: string;
+    url?: string;
+    name?: string;
+    authenticationMethod?: import("@venlyfinance/sdk").FinanceComponents["schemas"]["ApiKeyAuthenticationMethod"] | import("@venlyfinance/sdk").FinanceComponents["schemas"]["BasicAuthenticationMethod"];
+    status?: "ACTIVE";
+}>>, Error>;
+type WebhooksPage = Awaited<ReturnType<ReturnType<typeof venlyQueries.webhooks>["queryFn"]>>;
+export declare function useWebhook(webhookId: string | undefined, options?: Tune<WebhookItem>): import("@tanstack/react-query").UseQueryResult<NoInfer<{
+    id?: string;
+    url?: string;
+    name?: string;
+    authenticationMethod?: import("@venlyfinance/sdk").FinanceComponents["schemas"]["ApiKeyAuthenticationMethod"] | import("@venlyfinance/sdk").FinanceComponents["schemas"]["BasicAuthenticationMethod"];
+    status?: "ACTIVE";
+}>, Error>;
+type WebhookItem = Awaited<ReturnType<ReturnType<typeof venlyQueries.webhook>["queryFn"]>>;
 export declare function useCompanyFees(options?: Tune<CompanyFees>): import("@tanstack/react-query").UseQueryResult<NoInfer<{
     id?: string;
     companyId?: string;

package/dist/queries.js

@@ -15,6 +15,19 @@ export function useParty(partyId, options) {
         ...options,
     });
 }
+/**
+ * The party's identity-verification state, from the contract operation
+ * (`getPartyIvVerification`). `NOT_LINKED` resolves like any other state -
+ * identity verification is a state every party has, not a resource some lack.
+ */
+export function usePartyIvVerification(partyId, options) {
+    const clients = useVenly();
+    return useQuery({
+        ...venlyQueries.partyIvVerification(clients, partyId ?? ""),
+        enabled: Boolean(partyId) && (options?.enabled ?? true),
+        ...options,
+    });
+}
 export function useAccounts(query, options) {
     const clients = useVenly();
     return useQuery({ ...venlyQueries.accounts(clients, query), ...options });
@@ -27,6 +40,18 @@ export function useAccount(accountId, options) {
         ...options,
     });
 }
+/**
+ * The parties attached to an account with their role type and status.
+ * Saved payout recipients are the PAYOUT_RECIPIENT rows of this read.
+ */
+export function usePartyRoles(accountId, query, options) {
+    const clients = useVenly();
+    return useQuery({
+        ...venlyQueries.partyRoles(clients, accountId ?? "", query),
+        enabled: Boolean(accountId) && (options?.enabled ?? true),
+        ...options,
+    });
+}
 export function useWallets(accountId, query, options) {
     const clients = useVenly();
     return useQuery({
@@ -111,6 +136,38 @@ export function useTransfer(accountId, transferId, options) {
         ...options,
     });
 }
+export function usePayouts(accountId, query, options) {
+    const clients = useVenly();
+    return useQuery({
+        ...venlyQueries.payouts(clients, accountId ?? "", query),
+        enabled: Boolean(accountId) && (options?.enabled ?? true),
+        ...options,
+    });
+}
+export function usePayout(accountId, payoutId, options) {
+    const clients = useVenly();
+    return useQuery({
+        ...venlyQueries.payout(clients, accountId ?? "", payoutId ?? ""),
+        enabled: Boolean(accountId && payoutId) && (options?.enabled ?? true),
+        ...options,
+    });
+}
+export function usePayoutRoutes(accountId, query, options) {
+    const clients = useVenly();
+    return useQuery({
+        ...venlyQueries.payoutRoutes(clients, accountId ?? "", query),
+        enabled: Boolean(accountId) && (options?.enabled ?? true),
+        ...options,
+    });
+}
+export function usePayoutBankAccounts(partyId, query, options) {
+    const clients = useVenly();
+    return useQuery({
+        ...venlyQueries.payoutBankAccounts(clients, partyId ?? "", query),
+        enabled: Boolean(partyId) && (options?.enabled ?? true),
+        ...options,
+    });
+}
 export function useRampRequests(query, options) {
     const clients = useVenly();
     return useQuery({ ...venlyQueries.rampRequests(clients, query), ...options });
@@ -131,6 +188,19 @@ export function useReferenceData(options) {
         ...options,
     });
 }
+/** The tenant's registered webhook endpoints. */
+export function useWebhooks(options) {
+    const clients = useVenly();
+    return useQuery({ ...venlyQueries.webhooks(clients), ...options });
+}
+export function useWebhook(webhookId, options) {
+    const clients = useVenly();
+    return useQuery({
+        ...venlyQueries.webhook(clients, webhookId ?? ""),
+        enabled: Boolean(webhookId) && (options?.enabled ?? true),
+        ...options,
+    });
+}
 export function useCompanyFees(options) {
     const clients = useVenly();
     return useQuery({ ...venlyQueries.companyFees(clients), ...options });

package/dist/query-options.d.ts

@@ -3,8 +3,12 @@ import type { VenlyClients } from "./provider.js";
 export type PartiesQuery = NonNullable<Parameters<VenlyFinanceClient["parties"]["list"]>[0]>;
 export type AccountsQuery = NonNullable<Parameters<VenlyFinanceClient["accounts"]["list"]>[0]>;
 export type WalletsQuery = NonNullable<Parameters<VenlyFinanceClient["wallets"]["list"]>[1]>;
+export type PartyRolesQuery = NonNullable<Parameters<VenlyFinanceClient["accounts"]["listPartyRoles"]>[1]>;
 export type VirtualBankAccountsQuery = NonNullable<Parameters<VenlyFinanceClient["virtualBankAccounts"]["list"]>[1]>;
 export type TransfersQuery = NonNullable<Parameters<VenlyFinanceClient["transfers"]["list"]>[1]>;
+export type PayoutsQuery = NonNullable<Parameters<VenlyFinanceClient["payouts"]["list"]>[1]>;
+export type PayoutRoutesQuery = NonNullable<Parameters<VenlyFinanceClient["payoutRoutes"]["list"]>[1]>;
+export type PayoutBankAccountsQuery = NonNullable<Parameters<VenlyFinanceClient["payoutBankAccounts"]["list"]>[1]>;
 export type RampRequestsQuery = NonNullable<Parameters<FundflowClient["rampRequests"]["list"]>[0]>;
 export type FeeQuoteInput = Parameters<FundflowClient["fees"]["calculate"]>[0];
 export type CompanyBankAccountsQuery = NonNullable<Parameters<FundflowClient["bankAccounts"]["list"]>[0]>;
@@ -54,6 +58,21 @@ export declare const venlyQueries: {
             version?: number;
         }>;
     };
+    /**
+     * The party's identity-verification state, read off the contract operation
+     * (`getPartyIvVerification`) - never off the mock's internals, so the same
+     * read works against every environment. `NOT_LINKED` is a state, not an
+     * error: an unlinked party resolves rather than rejecting.
+     */
+    readonly partyIvVerification: (clients: VenlyClients, partyId: string) => {
+        queryKey: readonly ["venly", "party", string, "iv-verification"];
+        queryFn: () => Promise<{
+            partyId?: string;
+            ivCaseReference?: string;
+            status?: "NOT_LINKED" | "SUBMITTED" | "FORWARDED" | "ACCEPTED" | "COMPLETED" | "FAILED";
+            linkedAt?: string;
+        }>;
+    };
     readonly accounts: (clients: VenlyClients, query?: AccountsQuery) => {
         queryKey: readonly ["venly", "accounts", {} | null];
         queryFn: () => Promise<import("@venlyfinance/sdk").Page<{
@@ -78,6 +97,21 @@ export declare const venlyQueries: {
             version?: number;
         }>;
     };
+    /**
+     * The parties attached to an account, each with a role type
+     * (ACCOUNT_HOLDER | PAYOUT_RECIPIENT) and a status. The payout-recipient
+     * rows are the account's saved third-party recipients.
+     */
+    readonly partyRoles: (clients: VenlyClients, accountId: string, query?: PartyRolesQuery) => {
+        queryKey: readonly ["venly", "account", string, "party-roles", {} | null];
+        queryFn: () => Promise<import("@venlyfinance/sdk").Page<{
+            partyId?: string;
+            roleType?: "ACCOUNT_HOLDER" | "PAYOUT_RECIPIENT";
+            status?: "ACTIVE" | "INACTIVE";
+            createdAt?: string;
+            updatedAt?: string;
+        }>>;
+    };
     readonly wallets: (clients: VenlyClients, accountId: string, query?: WalletsQuery) => {
         queryKey: readonly ["venly", "account", string, "wallets", {} | null];
         queryFn: () => Promise<import("@venlyfinance/sdk").Page<{
@@ -169,6 +203,92 @@ export declare const venlyQueries: {
             updatedAt?: string;
         }>;
     };
+    readonly payouts: (clients: VenlyClients, accountId: string, query?: PayoutsQuery) => {
+        queryKey: readonly ["venly", "account", string, "payouts", {} | null];
+        queryFn: () => Promise<import("@venlyfinance/sdk").Page<{
+            id?: string;
+            accountId?: string;
+            payoutRoute?: import("@venlyfinance/sdk").FinanceComponents["schemas"]["PayoutRouteInfoDto"];
+            rail?: "US_ACH" | "SEPA";
+            cryptoAmount?: number;
+            settledFiatAmount?: number;
+            fundingMode?: "PULL" | "PUSH";
+            status?: "REQUESTED" | "SENDING" | "PROVIDER_PROCESSING" | "COMPLETED" | "REJECTED" | "FAILED" | "RETURNED";
+            sendTxHash?: string;
+            requestedAt?: string;
+            completedAt?: string;
+            failureReason?: string;
+        }>>;
+    };
+    readonly payout: (clients: VenlyClients, accountId: string, payoutId: string) => {
+        queryKey: readonly ["venly", "account", string, "payout", string];
+        queryFn: () => Promise<{
+            id?: string;
+            accountId?: string;
+            payoutRoute?: import("@venlyfinance/sdk").FinanceComponents["schemas"]["PayoutRouteInfoDto"];
+            rail?: "US_ACH" | "SEPA";
+            cryptoAmount?: number;
+            settledFiatAmount?: number;
+            fundingMode?: "PULL" | "PUSH";
+            status?: "REQUESTED" | "SENDING" | "PROVIDER_PROCESSING" | "COMPLETED" | "REJECTED" | "FAILED" | "RETURNED";
+            sendTxHash?: string;
+            requestedAt?: string;
+            completedAt?: string;
+            failureReason?: string;
+        }>;
+    };
+    readonly payoutRoutes: (clients: VenlyClients, accountId: string, query?: PayoutRoutesQuery) => {
+        queryKey: readonly ["venly", "account", string, "payout-routes", {} | null];
+        queryFn: () => Promise<{
+            id?: string;
+            status?: "PENDING" | "REGISTERING" | "AWAITING_OWNERSHIP_PROOF" | "ACTIVE" | "REJECTED";
+            depositAsset?: import("@venlyfinance/sdk").FinanceComponents["schemas"]["DepositAssetDto"];
+            fiatCurrency?: string;
+            depositAddress?: string;
+            createdAt?: string;
+            updatedAt?: string;
+        }[]>;
+    };
+    readonly payoutBankAccounts: (clients: VenlyClients, partyId: string, query?: PayoutBankAccountsQuery) => {
+        queryKey: readonly ["venly", "party", string, "payout-bank-accounts", {} | null];
+        queryFn: () => Promise<import("@venlyfinance/sdk").Page<{
+            id?: string;
+            partyId?: string;
+            rail?: "US_ACH" | "SEPA";
+            fiatCurrency?: string;
+            label?: string;
+            accountHolderName?: string;
+            details?: import("@venlyfinance/sdk").FinanceComponents["schemas"]["MaskedRailDetailsDto"];
+            bankName?: string;
+            beneficiaryEmail?: string;
+            beneficiaryPhoneNumber?: string;
+            bankAddress?: import("@venlyfinance/sdk").FinanceComponents["schemas"]["BankAddressDto"];
+            status?: "PENDING" | "ACTIVE" | "DISABLED";
+            createdAt?: string;
+            updatedAt?: string;
+        }>>;
+    };
+    /** Registered webhook endpoints (bare array on the wire; Page for resultPresent). */
+    readonly webhooks: (clients: VenlyClients) => {
+        queryKey: readonly ["venly", "webhooks"];
+        queryFn: () => Promise<import("@venlyfinance/sdk").Page<{
+            id?: string;
+            url?: string;
+            name?: string;
+            authenticationMethod?: import("@venlyfinance/sdk").FinanceComponents["schemas"]["ApiKeyAuthenticationMethod"] | import("@venlyfinance/sdk").FinanceComponents["schemas"]["BasicAuthenticationMethod"];
+            status?: "ACTIVE";
+        }>>;
+    };
+    readonly webhook: (clients: VenlyClients, webhookId: string) => {
+        queryKey: readonly ["venly", "webhook", string];
+        queryFn: () => Promise<{
+            id?: string;
+            url?: string;
+            name?: string;
+            authenticationMethod?: import("@venlyfinance/sdk").FinanceComponents["schemas"]["ApiKeyAuthenticationMethod"] | import("@venlyfinance/sdk").FinanceComponents["schemas"]["BasicAuthenticationMethod"];
+            status?: "ACTIVE";
+        }>;
+    };
     readonly rampRequests: (clients: VenlyClients, query?: RampRequestsQuery) => {
         queryKey: readonly ["venly", "ramp-requests", {} | null];
         queryFn: () => Promise<import("@venlyfinance/sdk").Page<{

package/dist/query-options.js

@@ -13,6 +13,16 @@ export const venlyQueries = {
         queryKey: venlyKeys.party(partyId),
         queryFn: () => clients.finance.parties.get(partyId),
     }),
+    /**
+     * The party's identity-verification state, read off the contract operation
+     * (`getPartyIvVerification`) - never off the mock's internals, so the same
+     * read works against every environment. `NOT_LINKED` is a state, not an
+     * error: an unlinked party resolves rather than rejecting.
+     */
+    partyIvVerification: (clients, partyId) => ({
+        queryKey: venlyKeys.partyIvVerification(partyId),
+        queryFn: () => clients.finance.parties.ivVerification(partyId),
+    }),
     accounts: (clients, query) => ({
         queryKey: venlyKeys.accounts(query),
         queryFn: () => clients.finance.accounts.list(query),
@@ -21,6 +31,15 @@ export const venlyQueries = {
         queryKey: venlyKeys.account(accountId),
         queryFn: () => clients.finance.accounts.get(accountId),
     }),
+    /**
+     * The parties attached to an account, each with a role type
+     * (ACCOUNT_HOLDER | PAYOUT_RECIPIENT) and a status. The payout-recipient
+     * rows are the account's saved third-party recipients.
+     */
+    partyRoles: (clients, accountId, query) => ({
+        queryKey: venlyKeys.partyRoles(accountId, query),
+        queryFn: () => clients.finance.accounts.listPartyRoles(accountId, query),
+    }),
     wallets: (clients, accountId, query) => ({
         queryKey: venlyKeys.wallets(accountId, query),
         queryFn: () => clients.finance.wallets.list(accountId, query),
@@ -47,6 +66,31 @@ export const venlyQueries = {
         queryKey: venlyKeys.transfer(accountId, transferId),
         queryFn: () => clients.finance.transfers.get(accountId, transferId),
     }),
+    payouts: (clients, accountId, query) => ({
+        queryKey: venlyKeys.payouts(accountId, query),
+        queryFn: () => clients.finance.payouts.list(accountId, query),
+    }),
+    payout: (clients, accountId, payoutId) => ({
+        queryKey: venlyKeys.payout(accountId, payoutId),
+        queryFn: () => clients.finance.payouts.get(accountId, payoutId),
+    }),
+    payoutRoutes: (clients, accountId, query) => ({
+        queryKey: venlyKeys.payoutRoutes(accountId, query),
+        queryFn: () => clients.finance.payoutRoutes.list(accountId, query),
+    }),
+    payoutBankAccounts: (clients, partyId, query) => ({
+        queryKey: venlyKeys.payoutBankAccounts(partyId, query),
+        queryFn: () => clients.finance.payoutBankAccounts.list(partyId, query),
+    }),
+    /** Registered webhook endpoints (bare array on the wire; Page for resultPresent). */
+    webhooks: (clients) => ({
+        queryKey: venlyKeys.webhooks(),
+        queryFn: () => clients.finance.webhooks.list(),
+    }),
+    webhook: (clients, webhookId) => ({
+        queryKey: venlyKeys.webhook(webhookId),
+        queryFn: () => clients.finance.webhooks.get(webhookId),
+    }),
     rampRequests: (clients, query) => ({
         queryKey: venlyKeys.rampRequests(query),
         queryFn: () => clients.fundflow.rampRequests.list(query),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@venlyfinance/react",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "description": "Headless React layer for the Venly Finance and Fundflow APIs: provider, TanStack Query hooks, and flow state machines for regulated money movement. Runs with zero credentials in mock mode.",
   "type": "module",
   "main": "./dist/index.js",
@@ -30,7 +30,7 @@
     "node": ">=20"
   },
   "dependencies": {
-    "@venlyfinance/sdk": "^0.5.0"
+    "@venlyfinance/sdk": "^0.7.0"
   },
   "peerDependencies": {
     "@tanstack/react-query": "^5.0.0",