@zkp2p/pay-shared 6.0.0 → 7.0.0

package/README.md

@@ -9,7 +9,7 @@ Shared TypeScript types, enums, and chain utilities used by ZKP2P Pay API, SDK,
 ## Install
 
 ```bash
-npm install @zkp2p/pay-shared@6.0.0
+npm install @zkp2p/pay-shared@7.0.0
 ```
 
 ## Published artifacts
@@ -85,10 +85,10 @@ Core type exports:
 - `CheckoutAggregate`
 - `CheckoutQuotes`
 - `MerchantProfile`
-- `CashoutView`
-- `CashoutRailType`
+- `PayoutView`
+- `PayoutRailType`
 - `WebhookPayload`
-- `CashoutWebhookPayload`
+- `PayoutWebhookPayload`
 
 Core constants:
 
@@ -100,15 +100,15 @@ Core constants:
 - `ProofAttemptStatus`
 - `OrderErrorCode`
 - `MerchantEnvironment`
-- `CashoutStatus`
-- `CashoutRail`
-- `CashoutCryptoRail`
-- `CashoutPayoutProvider`
+- `PayoutStatus`
+- `PayoutRail`
+- `PayoutCryptoRail`
+- `PayoutProvider`
 - `PAY_CRYPTO_TOKEN_SYMBOLS`
 
 Webhook helpers:
 
-- `isCashoutWebhook(...)` — narrows `WebhookPayload` to `CashoutWebhookPayload`
+- `isPayoutWebhook(...)` — narrows `WebhookPayload` to `PayoutWebhookPayload`
 
 Chain constants and helpers:
 

package/dist/cashoutCurrencies.d.ts

@@ -0,0 +1,109 @@
+import { type PayoutFiatRailType } from './types.js';
+/** Currency metadata in selector order. Names follow the SDK's currencyInfo. */
+export declare const PAYOUT_CURRENCY_INFO: {
+    readonly USD: {
+        readonly name: "United States Dollar";
+        readonly prefix: "$";
+        readonly minorUnits: 2;
+    };
+    readonly EUR: {
+        readonly name: "Euro";
+        readonly prefix: "€";
+        readonly minorUnits: 2;
+    };
+    readonly GBP: {
+        readonly name: "British Pound";
+        readonly prefix: "£";
+        readonly minorUnits: 2;
+    };
+    readonly AUD: {
+        readonly name: "Australian Dollar";
+        readonly prefix: "A$";
+        readonly minorUnits: 2;
+    };
+    readonly CAD: {
+        readonly name: "Canadian Dollar";
+        readonly prefix: "C$";
+        readonly minorUnits: 2;
+    };
+    readonly CHF: {
+        readonly name: "Swiss Franc";
+        readonly prefix: "CHF ";
+        readonly minorUnits: 2;
+    };
+    readonly CNY: {
+        readonly name: "Chinese Yuan";
+        readonly prefix: "CN¥";
+        readonly minorUnits: 2;
+    };
+    readonly MXN: {
+        readonly name: "Mexican Peso";
+        readonly prefix: "MX$";
+        readonly minorUnits: 2;
+    };
+    readonly NZD: {
+        readonly name: "New Zealand Dollar";
+        readonly prefix: "NZ$";
+        readonly minorUnits: 2;
+    };
+    readonly SGD: {
+        readonly name: "Singapore Dollar";
+        readonly prefix: "S$";
+        readonly minorUnits: 2;
+    };
+    readonly TRY: {
+        readonly name: "Turkish Lira";
+        readonly prefix: "₺";
+        readonly minorUnits: 2;
+    };
+    readonly ZAR: {
+        readonly name: "South African Rand";
+        readonly prefix: "R";
+        readonly minorUnits: 2;
+    };
+};
+export type PayoutCurrencyType = keyof typeof PAYOUT_CURRENCY_INFO;
+/** Every currency but USD: priced by the protocol oracle at zero spread, bound when a buyer signals. */
+export type PayoutOracleCurrencyType = Exclude<PayoutCurrencyType, 'USD'>;
+export declare const PayoutCurrency: { readonly [K in PayoutCurrencyType]: K; };
+/** Oracle currencies in catalog order; payoutCurrencies follows it. */
+export declare const PAYOUT_ORACLE_CURRENCIES: PayoutOracleCurrencyType[];
+/** Each rail's supported currencies, USD first then selector order. The API validates every pair against the SDK at boot. */
+export declare const PAYOUT_RAIL_CURRENCIES: {
+    readonly venmo: readonly ["USD"];
+    readonly cashapp: readonly ["USD"];
+    readonly paypal: readonly ["USD", "EUR", "GBP", "AUD", "CAD", "NZD", "SGD"];
+    readonly zelle: readonly ["USD"];
+    readonly revolut: readonly ["USD", "EUR", "GBP", "AUD", "CAD", "CHF", "CNY", "MXN", "NZD", "SGD", "TRY", "ZAR"];
+    readonly chime: readonly ["USD"];
+};
+export declare const PAYOUT_CURRENCY_NAMES: Readonly<Record<"USD" | "EUR" | "GBP" | "AUD" | "CAD" | "CHF" | "CNY" | "MXN" | "NZD" | "SGD" | "TRY" | "ZAR", string>>;
+export declare const PAYOUT_CURRENCY_SYMBOLS: Readonly<Record<"USD" | "EUR" | "GBP" | "AUD" | "CAD" | "CHF" | "CNY" | "MXN" | "NZD" | "SGD" | "TRY" | "ZAR", string>>;
+/** A USD listing's rate: exactly 1.00 USD per USDC in 18-decimal units; USD never uses an oracle. */
+export declare const CASHOUT_FIXED_USD_RATE: bigint;
+/** An oracle listing's fixed floor; below any market rate, so the escrow's effective rate is the oracle's (cash's ORACLE_MIN_CONVERSION_RATE_SENTINEL). */
+export declare const CASHOUT_ORACLE_MIN_RATE_SENTINEL = 1n;
+/** A fiat amount: `amount` is a decimal string with exactly 2 decimals. */
+export interface PayoutFiatValue {
+    currency: PayoutCurrencyType;
+    amount: string;
+}
+export declare function isPayoutCurrency(value: string): value is PayoutCurrencyType;
+export declare function isCashoutOracleCurrency(value: string): value is PayoutOracleCurrencyType;
+export declare function payoutRailPaysCurrency(rail: PayoutFiatRailType, currency: PayoutCurrencyType): boolean;
+/** A rail whose payout-method request carries `currency`: its catalog has more than one. */
+export declare function isPayoutMultiCurrencyRail(rail: PayoutFiatRailType): boolean;
+/**
+ * Fiat cents for `units` USDC base units at `rate` (fiat per USDC, 18 decimals), rounded up: Curator's buyer quote rule.
+ * While a USDC unit is worth less than a cent (rate below 10,000), it recovers exactly the cents a buyer paid from the
+ * attestation's floored release amount.
+ */
+export declare function payoutFiatCents(units: bigint, rate: bigint): bigint;
+export declare function formatPayoutFiatCents(cents: bigint): string;
+/** Fiat per USDC with 6 decimals, rounded half up: "0.892698". Display only. */
+export declare function formatPayoutRate(rate: bigint): string;
+/** A stored 18-decimal rate; null unless it is a positive integer string without leading zeros. */
+export declare function parseCashoutRate(value: string | null): bigint | null;
+export declare function cashoutFiatValue(currency: PayoutCurrencyType, units: bigint, rate: bigint): PayoutFiatValue;
+/** Group a non-negative fiat amount with exactly two decimals; reject malformed amounts and preserve cents beyond Number's safe range. */
+export declare function formatPayoutFiatValue(value: PayoutFiatValue): string;

package/dist/cashoutCurrencies.js

@@ -0,0 +1,94 @@
+import { PayoutFiatRail } from './types.js';
+/** Currency metadata in selector order. Names follow the SDK's currencyInfo. */
+export const PAYOUT_CURRENCY_INFO = {
+    USD: { name: 'United States Dollar', prefix: '$', minorUnits: 2 },
+    EUR: { name: 'Euro', prefix: '€', minorUnits: 2 },
+    GBP: { name: 'British Pound', prefix: '£', minorUnits: 2 },
+    AUD: { name: 'Australian Dollar', prefix: 'A$', minorUnits: 2 },
+    CAD: { name: 'Canadian Dollar', prefix: 'C$', minorUnits: 2 },
+    CHF: { name: 'Swiss Franc', prefix: 'CHF ', minorUnits: 2 },
+    CNY: { name: 'Chinese Yuan', prefix: 'CN¥', minorUnits: 2 },
+    MXN: { name: 'Mexican Peso', prefix: 'MX$', minorUnits: 2 },
+    NZD: { name: 'New Zealand Dollar', prefix: 'NZ$', minorUnits: 2 },
+    SGD: { name: 'Singapore Dollar', prefix: 'S$', minorUnits: 2 },
+    TRY: { name: 'Turkish Lira', prefix: '₺', minorUnits: 2 },
+    ZAR: { name: 'South African Rand', prefix: 'R', minorUnits: 2 },
+};
+// The keys of this local, closed catalog are exactly PayoutCurrencyType.
+const CURRENCY_CODES = Object.keys(PAYOUT_CURRENCY_INFO);
+// Every catalog key maps to itself; Object.fromEntries otherwise loses that key/value relationship.
+export const PayoutCurrency = Object.fromEntries(CURRENCY_CODES.map(code => [code, code]));
+/** Oracle currencies in catalog order; payoutCurrencies follows it. */
+export const PAYOUT_ORACLE_CURRENCIES = CURRENCY_CODES.filter((code) => code !== 'USD');
+/** Each rail's supported currencies, USD first then selector order. The API validates every pair against the SDK at boot. */
+export const PAYOUT_RAIL_CURRENCIES = {
+    [PayoutFiatRail.VENMO]: ['USD'],
+    [PayoutFiatRail.CASHAPP]: ['USD'],
+    [PayoutFiatRail.PAYPAL]: ['USD', 'EUR', 'GBP', 'AUD', 'CAD', 'NZD', 'SGD'],
+    [PayoutFiatRail.ZELLE]: ['USD'],
+    [PayoutFiatRail.REVOLUT]: ['USD', 'EUR', 'GBP', 'AUD', 'CAD', 'CHF', 'CNY', 'MXN', 'NZD', 'SGD', 'TRY', 'ZAR'],
+    [PayoutFiatRail.CHIME]: ['USD'],
+};
+function currencyLabels(field) {
+    // The mapping visits every catalog key once, preserving a complete record.
+    return Object.fromEntries(CURRENCY_CODES.map(code => [code, PAYOUT_CURRENCY_INFO[code][field]]));
+}
+export const PAYOUT_CURRENCY_NAMES = currencyLabels('name');
+export const PAYOUT_CURRENCY_SYMBOLS = currencyLabels('prefix');
+/** A USD listing's rate: exactly 1.00 USD per USDC in 18-decimal units; USD never uses an oracle. */
+export const CASHOUT_FIXED_USD_RATE = 10n ** 18n;
+/** An oracle listing's fixed floor; below any market rate, so the escrow's effective rate is the oracle's (cash's ORACLE_MIN_CONVERSION_RATE_SENTINEL). */
+export const CASHOUT_ORACLE_MIN_RATE_SENTINEL = 1n;
+const CURRENCY_SET = new Set(Object.values(PayoutCurrency));
+export function isPayoutCurrency(value) {
+    return CURRENCY_SET.has(value);
+}
+export function isCashoutOracleCurrency(value) {
+    return isPayoutCurrency(value) && value !== PayoutCurrency.USD;
+}
+export function payoutRailPaysCurrency(rail, currency) {
+    const currencies = PAYOUT_RAIL_CURRENCIES[rail];
+    return currencies.includes(currency);
+}
+/** A rail whose payout-method request carries `currency`: its catalog has more than one. */
+export function isPayoutMultiCurrencyRail(rail) {
+    return PAYOUT_RAIL_CURRENCIES[rail].length > 1;
+}
+/** 1e6 USDC units × 1e18 rate units ÷ 100 cents. */
+const CENTS_DENOMINATOR = 10n ** 22n;
+/**
+ * Fiat cents for `units` USDC base units at `rate` (fiat per USDC, 18 decimals), rounded up: Curator's buyer quote rule.
+ * While a USDC unit is worth less than a cent (rate below 10,000), it recovers exactly the cents a buyer paid from the
+ * attestation's floored release amount.
+ */
+export function payoutFiatCents(units, rate) {
+    if (units < 0n)
+        throw new Error('USDC units must not be negative');
+    if (rate <= 0n)
+        throw new Error('Rate must be positive');
+    return (units * rate + CENTS_DENOMINATOR - 1n) / CENTS_DENOMINATOR;
+}
+export function formatPayoutFiatCents(cents) {
+    return `${cents / 100n}.${(cents % 100n).toString().padStart(2, '0')}`;
+}
+/** Fiat per USDC with 6 decimals, rounded half up: "0.892698". Display only. */
+export function formatPayoutRate(rate) {
+    const micro = (rate + 500000000000n) / 1000000000000n;
+    return `${micro / 1000000n}.${(micro % 1000000n).toString().padStart(6, '0')}`;
+}
+/** A stored 18-decimal rate; null unless it is a positive integer string without leading zeros. */
+export function parseCashoutRate(value) {
+    if (value === null || !/^[1-9][0-9]{0,77}$/u.test(value))
+        return null;
+    return BigInt(value);
+}
+export function cashoutFiatValue(currency, units, rate) {
+    return { currency, amount: formatPayoutFiatCents(payoutFiatCents(units, rate)) };
+}
+/** Group a non-negative fiat amount with exactly two decimals; reject malformed amounts and preserve cents beyond Number's safe range. */
+export function formatPayoutFiatValue(value) {
+    if (!/^[0-9]+\.[0-9]{2}$/u.test(value.amount))
+        throw new Error('Fiat amount must have exactly two decimals');
+    const [whole, fraction] = value.amount.split('.');
+    return `${PAYOUT_CURRENCY_SYMBOLS[value.currency]}${whole.replace(/\B(?=(\d{3})+(?!\d))/gu, ',')}.${fraction}`;
+}

package/dist/cashoutRails.d.ts

@@ -1,22 +1,22 @@
-import { type CashoutBuyerProofRailType, type CashoutCryptoRailType, type CashoutFiatRailType, type CashoutSarRailType } from './types.js';
+import { type CashoutBuyerProofRailType, type PayoutCryptoRailType, type PayoutFiatRailType, type PayoutSarRailType } from './types.js';
 /**
  * The cashout rails SAR_SUPPORTED_FIAT_RAILS lists, in rail order: Venmo, Cash App and PayPal. Wise is SAR but not a
  * cashout rail yet.
  */
-export declare const CASHOUT_SAR_RAILS: ReadonlyArray<CashoutSarRailType>;
-/** A rail in CASHOUT_SAR_RAILS. Exact rails only; a variant such as "venmo-x" is not a cashout rail. */
-export declare function isCashoutSarRail(rail: string): rail is CashoutSarRailType;
+export declare const CASHOUT_SAR_RAILS: ReadonlyArray<PayoutSarRailType>;
+/** A rail in CASHOUT_SAR_RAILS. Exact rails only; a variant such as "venmo-x" is not a payout rail. */
+export declare function isPayoutSarRail(rail: string): rail is PayoutSarRailType;
 /** A cashout fiat rail with no connect step: Zelle, Revolut and Chime. */
 export declare function isCashoutBuyerProofRail(rail: string): rail is CashoutBuyerProofRailType;
 /** Every crypto payout network's rail, in rail order (checkout's relay rail order). */
-export declare const CASHOUT_CRYPTO_RAILS: ReadonlyArray<CashoutCryptoRailType>;
+export declare const PAYOUT_CRYPTO_RAILS: ReadonlyArray<PayoutCryptoRailType>;
 /** An exact crypto payout rail; replaces every comparison with the retired `crypto` rail. */
-export declare function isCashoutCryptoRail(rail: string): rail is CashoutCryptoRailType;
-export declare function cashoutCryptoRailChainId(rail: CashoutCryptoRailType): number;
-export declare function cashoutCryptoRailForChain(chainId: number): CashoutCryptoRailType | null;
+export declare function isPayoutCryptoRail(rail: string): rail is PayoutCryptoRailType;
+export declare function payoutCryptoRailChainId(rail: PayoutCryptoRailType): number;
+export declare function cashoutCryptoRailForChain(chainId: number): PayoutCryptoRailType | null;
 /** The payout chains a rail list offers, in rail order; the checkout's pickers and the server's checks read it. */
 export declare function cashoutRailsChainIds(rails: ReadonlyArray<string>): number[];
-export declare function hasCashoutCryptoRail(rails: ReadonlyArray<string>): boolean;
+export declare function hasPayoutCryptoRail(rails: ReadonlyArray<string>): boolean;
 /**
  * Venmo and PayPal listings get the Peer Pay merchant group. The set is @zkp2p/core's
  * DISPUTE_PROTECTION_STAKE_PLATFORMS, which @zkp2p/sdk keeps private, and
@@ -31,4 +31,4 @@ export declare function isCashoutPeerPayGroupRail(rail: string): rail is Cashout
  * A payout account as its rail writes it: "@alice" (Venmo, Revolut), "$alice1" (Cash App), "paypal.me/bob" (PayPal),
  * the email (Zelle) and "$chimesign" (Chime, whose stored handle already carries its "$").
  */
-export declare function cashoutAccountLabel(rail: CashoutFiatRailType, handle: string): string;
+export declare function payoutAccountLabel(rail: PayoutFiatRailType, handle: string): string;

package/dist/cashoutRails.js

@@ -1,15 +1,15 @@
 import { SAR_SUPPORTED_FIAT_RAILS, parseCryptoRailChainId } from './rails.js';
-import { CashoutCryptoRail, CashoutFiatRail, CashoutRail, } from './types.js';
-const CASHOUT_FIAT_RAIL_SET = new Set(Object.values(CashoutFiatRail));
+import { PayoutCryptoRail, PayoutFiatRail, PayoutRail, } from './types.js';
+const CASHOUT_FIAT_RAIL_SET = new Set(Object.values(PayoutFiatRail));
 const SAR_SUPPORTED_FIAT_RAIL_SET = new Set(SAR_SUPPORTED_FIAT_RAILS);
 /**
  * The cashout rails SAR_SUPPORTED_FIAT_RAILS lists, in rail order: Venmo, Cash App and PayPal. Wise is SAR but not a
  * cashout rail yet.
  */
-export const CASHOUT_SAR_RAILS = Object.values(CashoutFiatRail).filter((rail) => SAR_SUPPORTED_FIAT_RAIL_SET.has(rail));
+export const CASHOUT_SAR_RAILS = Object.values(PayoutFiatRail).filter((rail) => SAR_SUPPORTED_FIAT_RAIL_SET.has(rail));
 const CASHOUT_SAR_RAIL_SET = new Set(CASHOUT_SAR_RAILS);
-/** A rail in CASHOUT_SAR_RAILS. Exact rails only; a variant such as "venmo-x" is not a cashout rail. */
-export function isCashoutSarRail(rail) {
+/** A rail in CASHOUT_SAR_RAILS. Exact rails only; a variant such as "venmo-x" is not a payout rail. */
+export function isPayoutSarRail(rail) {
     return CASHOUT_SAR_RAIL_SET.has(rail);
 }
 /** A cashout fiat rail with no connect step: Zelle, Revolut and Chime. */
@@ -17,35 +17,35 @@ export function isCashoutBuyerProofRail(rail) {
     return CASHOUT_FIAT_RAIL_SET.has(rail) && !CASHOUT_SAR_RAIL_SET.has(rail);
 }
 /** Every crypto payout network's rail, in rail order (checkout's relay rail order). */
-export const CASHOUT_CRYPTO_RAILS = Object.values(CashoutCryptoRail);
-const CASHOUT_CRYPTO_RAIL_SET = new Set(CASHOUT_CRYPTO_RAILS);
+export const PAYOUT_CRYPTO_RAILS = Object.values(PayoutCryptoRail);
+const CASHOUT_CRYPTO_RAIL_SET = new Set(PAYOUT_CRYPTO_RAILS);
 /** An exact crypto payout rail; replaces every comparison with the retired `crypto` rail. */
-export function isCashoutCryptoRail(rail) {
+export function isPayoutCryptoRail(rail) {
     return CASHOUT_CRYPTO_RAIL_SET.has(rail);
 }
-export function cashoutCryptoRailChainId(rail) {
+export function payoutCryptoRailChainId(rail) {
     const chainId = parseCryptoRailChainId(rail);
     if (chainId === null)
         throw new Error(`Cashout crypto rail ${rail} names no chain`);
     return chainId;
 }
-const CASHOUT_CRYPTO_RAIL_BY_CHAIN = new Map(CASHOUT_CRYPTO_RAILS.map((rail) => [cashoutCryptoRailChainId(rail), rail]));
+const CASHOUT_CRYPTO_RAIL_BY_CHAIN = new Map(PAYOUT_CRYPTO_RAILS.map((rail) => [payoutCryptoRailChainId(rail), rail]));
 export function cashoutCryptoRailForChain(chainId) {
     return CASHOUT_CRYPTO_RAIL_BY_CHAIN.get(chainId) ?? null;
 }
 /** The payout chains a rail list offers, in rail order; the checkout's pickers and the server's checks read it. */
 export function cashoutRailsChainIds(rails) {
-    return CASHOUT_CRYPTO_RAILS.filter((rail) => rails.includes(rail)).map(cashoutCryptoRailChainId);
+    return PAYOUT_CRYPTO_RAILS.filter((rail) => rails.includes(rail)).map(payoutCryptoRailChainId);
 }
-export function hasCashoutCryptoRail(rails) {
-    return rails.some(isCashoutCryptoRail);
+export function hasPayoutCryptoRail(rails) {
+    return rails.some(isPayoutCryptoRail);
 }
 /**
  * Venmo and PayPal listings get the Peer Pay merchant group. The set is @zkp2p/core's
  * DISPUTE_PROTECTION_STAKE_PLATFORMS, which @zkp2p/sdk keeps private, and
  * zkp2p-mobile's CHARGEBACK_PRONE_SELL_PLATFORMS. Cash App left that set on 2026-08-28.
  */
-export const CASHOUT_PEER_PAY_GROUP_RAILS = [CashoutRail.VENMO, CashoutRail.PAYPAL];
+export const CASHOUT_PEER_PAY_GROUP_RAILS = [PayoutRail.VENMO, PayoutRail.PAYPAL];
 const CASHOUT_PEER_PAY_GROUP_RAIL_SET = new Set(CASHOUT_PEER_PAY_GROUP_RAILS);
 /** A rail in CASHOUT_PEER_PAY_GROUP_RAILS. */
 export function isCashoutPeerPayGroupRail(rail) {
@@ -55,17 +55,17 @@ export function isCashoutPeerPayGroupRail(rail) {
  * A payout account as its rail writes it: "@alice" (Venmo, Revolut), "$alice1" (Cash App), "paypal.me/bob" (PayPal),
  * the email (Zelle) and "$chimesign" (Chime, whose stored handle already carries its "$").
  */
-export function cashoutAccountLabel(rail, handle) {
+export function payoutAccountLabel(rail, handle) {
     switch (rail) {
-        case CashoutRail.VENMO:
-        case CashoutRail.REVOLUT:
+        case PayoutRail.VENMO:
+        case PayoutRail.REVOLUT:
             return `@${handle.replace(/^@/u, '')}`;
-        case CashoutRail.CASHAPP:
+        case PayoutRail.CASHAPP:
             return `$${handle.replace(/^\$/u, '')}`;
-        case CashoutRail.PAYPAL:
+        case PayoutRail.PAYPAL:
             return `paypal.me/${handle}`;
-        case CashoutRail.ZELLE:
-        case CashoutRail.CHIME:
+        case PayoutRail.ZELLE:
+        case PayoutRail.CHIME:
             return handle;
     }
 }

package/dist/crypto.d.ts

@@ -68,13 +68,13 @@ export declare function resolvePayCryptoTokenConfig(chainId: number, symbol: str
 export declare function resolvePayCryptoTokenConfigByAddress(chainId: number, address: string | null | undefined): SupportedCryptoTokenConfig | null;
 export declare function getSupportedDestinationBalanceTokenConfigsForChain(chainId: number, enabledSymbols?: readonly string[] | null): SupportedCryptoTokenConfig[];
 export declare function resolveDestinationBalanceTokenConfig(chainId: number, symbol: string | null | undefined): SupportedCryptoTokenConfig | null;
-/** Chains a cashout can be funded from through Relay. Zcash is out: ZEC funding is out of scope (2026-10-07). */
-export declare const CASHOUT_FUNDING_CHAIN_IDS: readonly number[];
+/** Chains a payout can be funded from through Relay. Zcash is out: ZEC funding is out of scope (2026-10-07). */
+export declare const PAYOUT_FUNDING_CHAIN_IDS: readonly number[];
 /**
- * The tokens a cashout can be funded with: every supported pay-crypto token on a Relay-fundable chain. An explicit list,
+ * The tokens a payout can be funded with: every supported pay-crypto token on a Relay-fundable chain. An explicit list,
  * because isEvmChain answers true for chains the table doesn't know, which let Bitcoin and Zcash in by accident.
  */
-export declare function getCashoutFundingTokenConfigs(): SupportedCryptoTokenConfig[];
+export declare function getPayoutFundingTokenConfigs(): SupportedCryptoTokenConfig[];
 /** The address formats a cashout address can take. */
 export declare const CashoutAddressFamily: {
     readonly EVM: "EVM";

package/dist/crypto.js

@@ -299,17 +299,17 @@ export function getSupportedDestinationBalanceTokenConfigsForChain(chainId, enab
 export function resolveDestinationBalanceTokenConfig(chainId, symbol) {
     return resolvePayCryptoTokenConfig(chainId, symbol);
 }
-/** Chains a cashout can be funded from through Relay. Zcash is out: ZEC funding is out of scope (2026-10-07). */
-export const CASHOUT_FUNDING_CHAIN_IDS = [
+/** Chains a payout can be funded from through Relay. Zcash is out: ZEC funding is out of scope (2026-10-07). */
+export const PAYOUT_FUNDING_CHAIN_IDS = [
     ETHEREUM_CHAIN_ID, 10, 56, 137, 480, HYPEREVM_CHAIN_ID, 5042, BASE_CHAIN_ID, 42161, BITCOIN_CHAIN_ID,
 ];
 /**
- * The tokens a cashout can be funded with: every supported pay-crypto token on a Relay-fundable chain. An explicit list,
+ * The tokens a payout can be funded with: every supported pay-crypto token on a Relay-fundable chain. An explicit list,
  * because isEvmChain answers true for chains the table doesn't know, which let Bitcoin and Zcash in by accident.
  */
-export function getCashoutFundingTokenConfigs() {
+export function getPayoutFundingTokenConfigs() {
     return getSupportedPayCryptoChainIds(PAY_CRYPTO_TOKEN_SYMBOLS)
-        .filter((chainId) => CASHOUT_FUNDING_CHAIN_IDS.includes(chainId))
+        .filter((chainId) => PAYOUT_FUNDING_CHAIN_IDS.includes(chainId))
         .flatMap((chainId) => getSupportedPayCryptoTokenConfigsForChain(chainId, PAY_CRYPTO_TOKEN_SYMBOLS))
         .filter((token) => resolvePayCryptoTokenConfigByAddress(token.chainId, token.address) !== null);
 }

package/dist/index.d.ts

@@ -5,6 +5,7 @@ export * from './fees.js';
 export * from './crypto.js';
 export * from './rails.js';
 export * from './cashoutRails.js';
+export * from './cashoutCurrencies.js';
 export * from './buyerTee.js';
 export * from './bitcoin.js';
 export * from './addressValidators.js';

package/dist/index.js

@@ -5,6 +5,7 @@ export * from './fees.js';
 export * from './crypto.js';
 export * from './rails.js';
 export * from './cashoutRails.js';
+export * from './cashoutCurrencies.js';
 export * from './buyerTee.js';
 export * from './bitcoin.js';
 export * from './addressValidators.js';