@venlyfinance/react 0.1.0

package/dist/query-options.d.ts

@@ -0,0 +1,244 @@
+import type { FundflowClient, VenlyFinanceClient } from "@venlyfinance/sdk";
+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 VirtualBankAccountsQuery = NonNullable<Parameters<VenlyFinanceClient["virtualBankAccounts"]["list"]>[1]>;
+export type TransfersQuery = NonNullable<Parameters<VenlyFinanceClient["transfers"]["list"]>[1]>;
+export type RampRequestsQuery = NonNullable<Parameters<FundflowClient["rampRequests"]["list"]>[0]>;
+export type FeeQuoteInput = Parameters<FundflowClient["fees"]["calculate"]>[0];
+/**
+ * Pure `{ queryKey, queryFn }` factories, one per read. The hooks in
+ * queries.ts are one-line wrappers over these; anything that needs the same
+ * read outside React (prefetching, route loaders, tests) uses them directly.
+ */
+export declare const venlyQueries: {
+    readonly parties: (clients: VenlyClients, query?: PartiesQuery) => {
+        queryKey: readonly ["venly", "parties", {} | null];
+        queryFn: () => Promise<import("@venlyfinance/sdk").Page<{
+            id?: string;
+            externalId?: string;
+            partyType?: import("@venlyfinance/sdk").FinanceComponents["schemas"]["PartyType"];
+            status?: import("@venlyfinance/sdk").FinanceComponents["schemas"]["PartyStatus"];
+            firstName?: string;
+            lastName?: string;
+            kycStatus?: import("@venlyfinance/sdk").FinanceComponents["schemas"]["KycStatus"];
+            name?: string;
+            vatNumber?: string;
+            kybStatus?: import("@venlyfinance/sdk").FinanceComponents["schemas"]["KybStatus"];
+            address?: import("@venlyfinance/sdk").FinanceComponents["schemas"]["Address"];
+            createdAt?: string;
+            updatedAt?: string;
+            version?: number;
+        }>>;
+    };
+    readonly party: (clients: VenlyClients, partyId: string) => {
+        queryKey: readonly ["venly", "party", string];
+        queryFn: () => Promise<{
+            id?: string;
+            externalId?: string;
+            partyType?: import("@venlyfinance/sdk").FinanceComponents["schemas"]["PartyType"];
+            status?: import("@venlyfinance/sdk").FinanceComponents["schemas"]["PartyStatus"];
+            firstName?: string;
+            lastName?: string;
+            kycStatus?: import("@venlyfinance/sdk").FinanceComponents["schemas"]["KycStatus"];
+            name?: string;
+            vatNumber?: string;
+            kybStatus?: import("@venlyfinance/sdk").FinanceComponents["schemas"]["KybStatus"];
+            address?: import("@venlyfinance/sdk").FinanceComponents["schemas"]["Address"];
+            createdAt?: string;
+            updatedAt?: string;
+            version?: number;
+        }>;
+    };
+    readonly accounts: (clients: VenlyClients, query?: AccountsQuery) => {
+        queryKey: readonly ["venly", "accounts", {} | null];
+        queryFn: () => Promise<import("@venlyfinance/sdk").Page<{
+            id?: string;
+            externalId?: string;
+            name?: string;
+            kycStatus?: import("@venlyfinance/sdk").FinanceComponents["schemas"]["KycStatus"];
+            status?: import("@venlyfinance/sdk").FinanceComponents["schemas"]["AccountStatus"];
+            createdAt?: string;
+            version?: number;
+        }>>;
+    };
+    readonly account: (clients: VenlyClients, accountId: string) => {
+        queryKey: readonly ["venly", "account", string];
+        queryFn: () => Promise<{
+            id?: string;
+            externalId?: string;
+            name?: string;
+            kycStatus?: import("@venlyfinance/sdk").FinanceComponents["schemas"]["KycStatus"];
+            status?: import("@venlyfinance/sdk").FinanceComponents["schemas"]["AccountStatus"];
+            createdAt?: string;
+            version?: number;
+        }>;
+    };
+    readonly wallets: (clients: VenlyClients, accountId: string, query?: WalletsQuery) => {
+        queryKey: readonly ["venly", "account", string, "wallets", {} | null];
+        queryFn: () => Promise<import("@venlyfinance/sdk").Page<{
+            id?: string;
+            chain?: import("@venlyfinance/sdk").FinanceComponents["schemas"]["BlockchainNetwork"];
+            type?: import("@venlyfinance/sdk").FinanceComponents["schemas"]["WalletType"];
+            address?: string;
+            balances?: import("@venlyfinance/sdk").FinanceComponents["schemas"]["TokenBalance"][];
+            amlStatus?: import("@venlyfinance/sdk").FinanceComponents["schemas"]["AmlStatus"];
+        }>>;
+    };
+    readonly virtualBankAccounts: (clients: VenlyClients, accountId: string, query?: VirtualBankAccountsQuery) => {
+        queryKey: readonly ["venly", "account", string, "virtual-bank-accounts", {} | null];
+        queryFn: () => Promise<import("@venlyfinance/sdk").Page<{
+            id?: string;
+            accountId?: string;
+            bankAccountType?: import("@venlyfinance/sdk").FinanceComponents["schemas"]["BankAccountType"];
+            name?: string;
+            status?: import("@venlyfinance/sdk").FinanceComponents["schemas"]["VirtualBankAccountStatus"];
+            currency?: import("@venlyfinance/sdk").FinanceComponents["schemas"]["FiatCurrency"];
+            targetCryptocurrency?: import("@venlyfinance/sdk").FinanceComponents["schemas"]["Cryptocurrency"];
+            iban?: string;
+            bic?: string;
+            bankName?: string;
+            beneficiaryName?: string;
+            referenceCode?: string;
+            createdAt?: string;
+            updatedAt?: string;
+        }>>;
+    };
+    readonly transfers: (clients: VenlyClients, accountId: string, query?: TransfersQuery) => {
+        queryKey: readonly ["venly", "account", string, "transfers", {} | null];
+        queryFn: () => Promise<import("@venlyfinance/sdk").Page<{
+            id?: string;
+            senderAccountId?: string;
+            receiverAccountId?: string;
+            chain?: import("@venlyfinance/sdk").FinanceComponents["schemas"]["BlockchainNetwork"];
+            asset?: string;
+            amount?: number;
+            fiatOrigin?: import("@venlyfinance/sdk").FinanceComponents["schemas"]["FiatOrigin"];
+            description?: string;
+            merchantReference?: string;
+            idempotencyKey?: string;
+            status?: import("@venlyfinance/sdk").FinanceComponents["schemas"]["TransferStatus"];
+            transactionHash?: string;
+            errorMessage?: string;
+            createdAt?: string;
+            updatedAt?: string;
+        }>>;
+    };
+    readonly transfer: (clients: VenlyClients, accountId: string, transferId: string) => {
+        queryKey: readonly ["venly", "account", string, "transfer", string];
+        queryFn: () => Promise<{
+            id?: string;
+            senderAccountId?: string;
+            receiverAccountId?: string;
+            chain?: import("@venlyfinance/sdk").FinanceComponents["schemas"]["BlockchainNetwork"];
+            asset?: string;
+            amount?: number;
+            fiatOrigin?: import("@venlyfinance/sdk").FinanceComponents["schemas"]["FiatOrigin"];
+            description?: string;
+            merchantReference?: string;
+            idempotencyKey?: string;
+            status?: import("@venlyfinance/sdk").FinanceComponents["schemas"]["TransferStatus"];
+            transactionHash?: string;
+            errorMessage?: string;
+            createdAt?: string;
+            updatedAt?: string;
+        }>;
+    };
+    readonly rampRequests: (clients: VenlyClients, query?: RampRequestsQuery) => {
+        queryKey: readonly ["venly", "ramp-requests", {} | null];
+        queryFn: () => Promise<import("@venlyfinance/sdk").Page<{
+            id?: string;
+            paymentReference?: string;
+            rampType?: "ON_RAMP" | "OFF_RAMP";
+            status?: "AWAITING_APPROVAL" | "AWAITING_FUNDS" | "PROCESSING" | "SUCCEEDED" | "FAILED" | "BLOCKED" | "DENIED" | "REJECTED" | "CANCELLED";
+            fiatAmount?: number;
+            fiatCurrency?: string;
+            cryptoAmount?: number;
+            cryptoCurrency?: string;
+            createdAt?: string;
+            createdBy?: string;
+        }>>;
+    };
+    readonly rampRequest: (clients: VenlyClients, id: string) => {
+        queryKey: readonly ["venly", "ramp-request", string];
+        queryFn: () => Promise<{
+            id?: string;
+            companyId?: string;
+            companyName?: string;
+            rampType?: "ON_RAMP" | "OFF_RAMP";
+            status?: "AWAITING_APPROVAL" | "AWAITING_FUNDS" | "PROCESSING" | "SUCCEEDED" | "FAILED" | "BLOCKED" | "DENIED" | "REJECTED" | "CANCELLED";
+            amount?: number;
+            netAmount?: number;
+            fiatAmount?: number;
+            fiatNetAmount?: number;
+            cryptoAmount?: number;
+            fiatFeeAmount?: number;
+            exchangeRate?: number;
+            feePercentage?: number;
+            paymentReference?: string;
+            paymentReceived?: boolean;
+            blockchainTransactionHash?: string;
+            createdAt?: string;
+            companyBankAccount?: import("@venlyfinance/sdk").FundflowComponents["schemas"]["EurSepaCompanyBankAccountDto"] | import("@venlyfinance/sdk").FundflowComponents["schemas"]["GbpChapsCompanyBankAccountDto"] | import("@venlyfinance/sdk").FundflowComponents["schemas"]["GbpFpsCompanyBankAccountDto"] | import("@venlyfinance/sdk").FundflowComponents["schemas"]["OtherCurrencySwiftCompanyBankAccountDto"] | import("@venlyfinance/sdk").FundflowComponents["schemas"]["UsAchCompanyBankAccountDto"] | import("@venlyfinance/sdk").FundflowComponents["schemas"]["UsSwiftCompanyBankAccountDto"] | import("@venlyfinance/sdk").FundflowComponents["schemas"]["UsWireCompanyBankAccountDto"];
+            companyWallet?: import("@venlyfinance/sdk").FundflowComponents["schemas"]["CompanyWalletDto"];
+            depositBankAccount?: import("@venlyfinance/sdk").FundflowComponents["schemas"]["EurSepaDepositBankAccountDto"] | import("@venlyfinance/sdk").FundflowComponents["schemas"]["GbpChapsDepositBankAccountDto"] | import("@venlyfinance/sdk").FundflowComponents["schemas"]["GbpFpsDepositBankAccountDto"] | import("@venlyfinance/sdk").FundflowComponents["schemas"]["OtherCurrencySwiftDepositBankAccountDto"] | import("@venlyfinance/sdk").FundflowComponents["schemas"]["UsAchDepositBankAccountDto"] | import("@venlyfinance/sdk").FundflowComponents["schemas"]["UsSwiftDepositBankAccountDto"] | import("@venlyfinance/sdk").FundflowComponents["schemas"]["UsWireDepositBankAccountDto"];
+            depositWallet?: import("@venlyfinance/sdk").FundflowComponents["schemas"]["DepositWalletDto"];
+            fiatCurrency?: import("@venlyfinance/sdk").FundflowComponents["schemas"]["FiatCurrencyDto"];
+            cryptoCurrency?: import("@venlyfinance/sdk").FundflowComponents["schemas"]["CryptoCurrencyDto"];
+            events?: import("@venlyfinance/sdk").FundflowComponents["schemas"]["RampRequestEventDto"][];
+            version?: number;
+            amountReceived?: number;
+        }>;
+    };
+    /** Chains + fiat + crypto currencies in one cacheable read. */
+    readonly referenceData: (clients: VenlyClients) => {
+        queryKey: readonly ["venly", "reference-data"];
+        queryFn: () => Promise<{
+            fiatCurrencies: {
+                id?: string;
+                currency?: string;
+                label?: string;
+                enabled?: boolean;
+                version?: number;
+            }[];
+            cryptoCurrencies: {
+                id?: string;
+                currency?: string;
+                chain?: "ETHEREUM" | "POLYGON" | "BASE" | "ARBITRUM" | "SUI";
+                label?: string;
+                enabled?: boolean;
+                version?: number;
+                coingeckoId?: string;
+            }[];
+            chains: {
+                supportedChains?: ("ETHEREUM" | "POLYGON" | "BASE" | "ARBITRUM" | "SUI")[];
+            }[];
+        }>;
+    };
+    readonly companyFees: (clients: VenlyClients) => {
+        queryKey: readonly ["venly", "company-fees"];
+        queryFn: () => Promise<{
+            id?: string;
+            companyId?: string;
+            name?: string;
+            type?: "ON_RAMP" | "OFF_RAMP";
+            minVolume?: number;
+            maxVolume?: number;
+            percentage?: number;
+            version?: number;
+        }[]>;
+    };
+    /**
+     * Fee calculation is a POST but semantically a pure function of its input,
+     * so it is modelled as a query keyed by the input: same input, cached
+     * answer; new input, new fetch.
+     */
+    readonly feeQuote: (clients: VenlyClients, input: FeeQuoteInput) => {
+        queryKey: readonly ["venly", "fee-quote", unknown];
+        queryFn: () => Promise<{
+            amount?: number;
+            percentage?: number;
+        }>;
+    };
+};

package/dist/query-options.js

@@ -0,0 +1,73 @@
+import { venlyKeys } from "./keys.js";
+/**
+ * Pure `{ queryKey, queryFn }` factories, one per read. The hooks in
+ * queries.ts are one-line wrappers over these; anything that needs the same
+ * read outside React (prefetching, route loaders, tests) uses them directly.
+ */
+export const venlyQueries = {
+    parties: (clients, query) => ({
+        queryKey: venlyKeys.parties(query),
+        queryFn: () => clients.finance.parties.list(query),
+    }),
+    party: (clients, partyId) => ({
+        queryKey: venlyKeys.party(partyId),
+        queryFn: () => clients.finance.parties.get(partyId),
+    }),
+    accounts: (clients, query) => ({
+        queryKey: venlyKeys.accounts(query),
+        queryFn: () => clients.finance.accounts.list(query),
+    }),
+    account: (clients, accountId) => ({
+        queryKey: venlyKeys.account(accountId),
+        queryFn: () => clients.finance.accounts.get(accountId),
+    }),
+    wallets: (clients, accountId, query) => ({
+        queryKey: venlyKeys.wallets(accountId, query),
+        queryFn: () => clients.finance.wallets.list(accountId, query),
+    }),
+    virtualBankAccounts: (clients, accountId, query) => ({
+        queryKey: venlyKeys.virtualBankAccounts(accountId, query),
+        queryFn: () => clients.finance.virtualBankAccounts.list(accountId, query),
+    }),
+    transfers: (clients, accountId, query) => ({
+        queryKey: venlyKeys.transfers(accountId, query),
+        queryFn: () => clients.finance.transfers.list(accountId, query),
+    }),
+    transfer: (clients, accountId, transferId) => ({
+        queryKey: venlyKeys.transfer(accountId, transferId),
+        queryFn: () => clients.finance.transfers.get(accountId, transferId),
+    }),
+    rampRequests: (clients, query) => ({
+        queryKey: venlyKeys.rampRequests(query),
+        queryFn: () => clients.fundflow.rampRequests.list(query),
+    }),
+    rampRequest: (clients, id) => ({
+        queryKey: venlyKeys.rampRequest(id),
+        queryFn: () => clients.fundflow.rampRequests.get(id),
+    }),
+    /** Chains + fiat + crypto currencies in one cacheable read. */
+    referenceData: (clients) => ({
+        queryKey: venlyKeys.referenceData(),
+        queryFn: async () => {
+            const [fiatCurrencies, cryptoCurrencies, chains] = await Promise.all([
+                clients.fundflow.referenceData.fiatCurrencies(),
+                clients.fundflow.referenceData.cryptoCurrencies(),
+                clients.fundflow.referenceData.chains(),
+            ]);
+            return { fiatCurrencies, cryptoCurrencies, chains };
+        },
+    }),
+    companyFees: (clients) => ({
+        queryKey: venlyKeys.companyFees(),
+        queryFn: () => clients.fundflow.fees.listCompanyFees(),
+    }),
+    /**
+     * Fee calculation is a POST but semantically a pure function of its input,
+     * so it is modelled as a query keyed by the input: same input, cached
+     * answer; new input, new fetch.
+     */
+    feeQuote: (clients, input) => ({
+        queryKey: venlyKeys.feeQuote(input),
+        queryFn: () => clients.fundflow.fees.calculate(input),
+    }),
+};

package/package.json

@@ -0,0 +1,65 @@
+{
+  "name": "@venlyfinance/react",
+  "version": "0.1.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",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "sideEffects": false,
+  "files": [
+    "dist",
+    "LICENSE",
+    "README.md",
+    "CHANGELOG.md",
+    "AGENTS.md"
+  ],
+  "scripts": {
+    "build": "rm -rf dist && tsc -p tsconfig.json",
+    "test": "node --import tsx --test test/*.test.ts",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "typecheck:test": "tsc -p tsconfig.test.json"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "dependencies": {
+    "@venlyfinance/sdk": "^0.2.0"
+  },
+  "peerDependencies": {
+    "@tanstack/react-query": "^5.0.0",
+    "react": "^18.0.0 || ^19.0.0"
+  },
+  "devDependencies": {
+    "@tanstack/react-query": "^5.62.0",
+    "@types/node": "^22.10.0",
+    "@types/react": "^19.0.0",
+    "@types/react-dom": "^19.2.4",
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0",
+    "tsx": "^4.19.2",
+    "typescript": "^5.7.2"
+  },
+  "keywords": [
+    "venly",
+    "react",
+    "hooks",
+    "stablecoin",
+    "settlement",
+    "payments",
+    "headless"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Venly/venly-settlement-sdk.git",
+    "directory": "react"
+  },
+  "homepage": "https://github.com/Venly/venly-settlement-sdk/tree/main/react#readme"
+}