@zkp2p/pay-shared 1.0.0 → 2.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@1.0.0
+npm install @zkp2p/pay-shared@2.0.0
 ```
 
 ## Published artifacts
@@ -66,7 +66,7 @@ import {
 
 const chainId = parseSupportedChainSelection('polygon'); // 137
 const usdc = resolveDestinationTokenAddress('USDC', 137); // Chain-specific USDC address
-const supportedAliases = getSupportedDestinationTokenAliasesForChain(BASE_CHAIN_ID); // ["USDC"]
+const supportedAliases = getSupportedDestinationTokenAliasesForChain(BASE_CHAIN_ID); // ["USDC", "USDT"]
 
 console.log(getSupportedChainIds(), chainId, usdc, supportedAliases);
 ```

package/dist/buyerTee.d.ts

@@ -0,0 +1,4 @@
+export declare const ProofMode: {
+    readonly BUYER_TEE: "buyerTee";
+};
+export type ProofMode = typeof ProofMode[keyof typeof ProofMode];

package/dist/buyerTee.js

@@ -0,0 +1,3 @@
+export const ProofMode = {
+    BUYER_TEE: 'buyerTee',
+};

package/dist/chains.d.ts

@@ -5,6 +5,7 @@
  * Import this module instead of duplicating chain configs in each app.
  */
 export declare const BASE_CHAIN_ID = 8453;
+export declare const ETHEREUM_CHAIN_ID = 1;
 export declare const HYPEREVM_CHAIN_ID = 999;
 export declare const SOLANA_CHAIN_ID = 792703809;
 export declare const SUPPORTED_DESTINATION_TOKEN_ALIASES: readonly ["USDC", "USDT"];

package/dist/chains.js

@@ -6,6 +6,7 @@
  */
 // Chain IDs
 export const BASE_CHAIN_ID = 8453;
+export const ETHEREUM_CHAIN_ID = 1;
 export const HYPEREVM_CHAIN_ID = 999;
 export const SOLANA_CHAIN_ID = 792703809;
 export const SUPPORTED_DESTINATION_TOKEN_ALIASES = ['USDC', 'USDT'];
@@ -135,6 +136,10 @@ for (const chainId of SUPPORTED_CHAIN_IDS) {
     }
 }
 const DESTINATION_TOKEN_ADDRESSES = {
+    // Base
+    8453: {
+        usdt: '0xfde4C96c8593536E31F229EA8f37b2ADa2699bb2',
+    },
     // Ethereum
     1: {
         usdt: '0xdAC17F958D2ee523a2206206994597C13D831ec7',

package/dist/crypto.d.ts

@@ -4,6 +4,12 @@ export declare const PAY_CRYPTO_TOKEN_SYMBOLS: readonly ["BTC", "USDC", "USDT",
 export type PayCryptoTokenSymbol = (typeof PAY_CRYPTO_TOKEN_SYMBOLS)[number];
 export declare const DEFAULT_ENABLED_PAY_CRYPTO_TOKENS: PayCryptoTokenSymbol[];
 export declare const DEFAULT_ENABLED_DESTINATION_TOKENS: PayCryptoTokenSymbol[];
+/**
+ * Display-order priority for the "Pay with crypto" chain dropdown.
+ * Chains not in this list fall back to the existing numeric chain-ID
+ * iteration order of PAY_CRYPTO_CHAIN_CONFIGS as a stable tiebreaker.
+ */
+export declare const PAY_CRYPTO_CHAIN_DISPLAY_PRIORITY: readonly number[];
 export declare const STABLECOIN_SYMBOLS: Set<"USDC" | "USDT" | "ETH" | "BNB" | "SOL" | "BTC" | "PYUSD" | "HYPE" | "WBTC" | "USDH">;
 export interface SupportedCryptoTokenConfig {
     chainId: number;
@@ -18,6 +24,31 @@ export declare function normalizePayCryptoTokenSymbol(value: string | null | und
 export declare function isStablecoinSymbol(symbol: string | null | undefined): boolean;
 export declare function getSupportedPayCryptoTokenConfigsForChain(chainId: number, enabledSymbols?: readonly string[] | null): SupportedCryptoTokenConfig[];
 export declare function getSupportedPayCryptoChainIds(enabledSymbols?: readonly string[] | null): number[];
+/**
+ * Returns the union of tokens supported by any of `enabledChainIds`,
+ * sorted by the canonical pay-crypto display order
+ * (DEFAULT_ENABLED_PAY_CRYPTO_TOKENS order).
+ *
+ * When `enabledChainIds` is undefined, uses every supported chain.
+ * When `enabledChainIds` is an empty array, returns [].
+ */
+export declare function getAvailablePayCryptoTokens(enabledChainIds?: readonly number[]): PayCryptoTokenSymbol[];
+/**
+ * Returns the chain IDs that support `symbol`, optionally filtered
+ * to `enabledChainIds`, sorted by PAY_CRYPTO_CHAIN_DISPLAY_PRIORITY
+ * with ascending numeric chain-ID order as the stable tiebreaker.
+ *
+ * When `enabledChainIds` is undefined, uses every supported chain.
+ * When `enabledChainIds` is an empty array, returns [].
+ */
+export declare function getSupportedPayCryptoChainIdsForToken(symbol: PayCryptoTokenSymbol, enabledChainIds?: readonly number[]): number[];
+/**
+ * Returns the display name for a chain used by the "Pay with crypto"
+ * flow. Resolves through PAY_CRYPTO_CHAIN_CONFIGS first so Bitcoin
+ * and Tron (which are not in MAINNET_CHAINS) get the correct label.
+ * Falls back to getChainName for chains not registered here.
+ */
+export declare function getPayCryptoChainName(chainId: number): string;
 export declare function resolvePayCryptoTokenConfig(chainId: number, symbol: string | null | undefined): SupportedCryptoTokenConfig | null;
 /**
  * Reverse lookup of a token config by contract address on a specific chain.

package/dist/crypto.js

@@ -1,4 +1,4 @@
-import { MAINNET_CHAINS, } from './chains.js';
+import { MAINNET_CHAINS, BASE_CHAIN_ID, ETHEREUM_CHAIN_ID, SOLANA_CHAIN_ID, getChainName, } from './chains.js';
 export const BITCOIN_CHAIN_ID = 8253038;
 export const TRON_CHAIN_ID = 728126428;
 export const PAY_CRYPTO_TOKEN_SYMBOLS = [
@@ -15,9 +15,9 @@ export const PAY_CRYPTO_TOKEN_SYMBOLS = [
 ];
 export const DEFAULT_ENABLED_PAY_CRYPTO_TOKENS = [
     'BTC',
-    'USDC',
-    'USDT',
     'ETH',
+    'USDT',
+    'USDC',
     'PYUSD',
     'SOL',
     'BNB',
@@ -29,6 +29,17 @@ export const DEFAULT_ENABLED_DESTINATION_TOKENS = [
     'USDC',
     'USDT',
 ];
+/**
+ * Display-order priority for the "Pay with crypto" chain dropdown.
+ * Chains not in this list fall back to the existing numeric chain-ID
+ * iteration order of PAY_CRYPTO_CHAIN_CONFIGS as a stable tiebreaker.
+ */
+export const PAY_CRYPTO_CHAIN_DISPLAY_PRIORITY = [
+    BITCOIN_CHAIN_ID,
+    ETHEREUM_CHAIN_ID,
+    SOLANA_CHAIN_ID,
+    BASE_CHAIN_ID,
+];
 export const STABLECOIN_SYMBOLS = new Set([
     'USDC',
     'USDT',
@@ -160,6 +171,60 @@ export function getSupportedPayCryptoChainIds(enabledSymbols) {
         .map(Number)
         .filter((chainId) => getSupportedPayCryptoTokenConfigsForChain(chainId, enabledSymbols).length > 0);
 }
+/**
+ * Returns the union of tokens supported by any of `enabledChainIds`,
+ * sorted by the canonical pay-crypto display order
+ * (DEFAULT_ENABLED_PAY_CRYPTO_TOKENS order).
+ *
+ * When `enabledChainIds` is undefined, uses every supported chain.
+ * When `enabledChainIds` is an empty array, returns [].
+ */
+export function getAvailablePayCryptoTokens(enabledChainIds) {
+    const chainIds = enabledChainIds === undefined
+        ? Object.keys(CHAIN_TOKEN_CONFIGS).map(Number)
+        : enabledChainIds;
+    const available = new Set();
+    for (const chainId of chainIds) {
+        const chainTokens = CHAIN_TOKEN_CONFIGS[chainId];
+        if (chainTokens === undefined)
+            continue;
+        for (const symbol of Object.keys(chainTokens)) {
+            available.add(symbol);
+        }
+    }
+    return DEFAULT_ENABLED_PAY_CRYPTO_TOKENS.filter((symbol) => available.has(symbol));
+}
+/**
+ * Returns the chain IDs that support `symbol`, optionally filtered
+ * to `enabledChainIds`, sorted by PAY_CRYPTO_CHAIN_DISPLAY_PRIORITY
+ * with ascending numeric chain-ID order as the stable tiebreaker.
+ *
+ * When `enabledChainIds` is undefined, uses every supported chain.
+ * When `enabledChainIds` is an empty array, returns [].
+ */
+export function getSupportedPayCryptoChainIdsForToken(symbol, enabledChainIds) {
+    const candidateChainIds = enabledChainIds === undefined
+        ? Object.keys(CHAIN_TOKEN_CONFIGS).map(Number)
+        : Array.from(new Set(enabledChainIds));
+    const supporting = candidateChainIds.filter((chainId) => (CHAIN_TOKEN_CONFIGS[chainId]?.[symbol] !== undefined));
+    const supportingSet = new Set(supporting);
+    const priorityPortion = PAY_CRYPTO_CHAIN_DISPLAY_PRIORITY
+        .filter((chainId) => supportingSet.has(chainId));
+    const prioritySet = new Set(PAY_CRYPTO_CHAIN_DISPLAY_PRIORITY);
+    const restPortion = supporting
+        .filter((chainId) => !prioritySet.has(chainId))
+        .sort((a, b) => a - b);
+    return [...priorityPortion, ...restPortion];
+}
+/**
+ * Returns the display name for a chain used by the "Pay with crypto"
+ * flow. Resolves through PAY_CRYPTO_CHAIN_CONFIGS first so Bitcoin
+ * and Tron (which are not in MAINNET_CHAINS) get the correct label.
+ * Falls back to getChainName for chains not registered here.
+ */
+export function getPayCryptoChainName(chainId) {
+    return PAY_CRYPTO_CHAIN_CONFIGS[chainId]?.name ?? getChainName(chainId);
+}
 export function resolvePayCryptoTokenConfig(chainId, symbol) {
     const normalizedSymbol = normalizePayCryptoTokenSymbol(symbol);
     if (!normalizedSymbol) {

package/dist/fiatAmount.d.ts

@@ -0,0 +1,19 @@
+export interface DisplayedFiatAmountInput {
+    readonly feePayer: 'MERCHANT' | 'PAYEE';
+    readonly signalIntentAmountBaseUnits: string | null;
+    readonly conversionRateDecimal: string | null;
+    readonly remainingUsdcAmount: string;
+    readonly currencyPerUsdRate: string;
+    readonly paymentAmountFallback: string;
+}
+/**
+ * The exact fiat amount the buyer is instructed to pay, as a decimal string.
+ * BYTE-IDENTICAL to checkoutData.ts mapCheckoutPaymentToQuote (lines 336-351):
+ *   quotedFiatAmount (PAYEE ceil-cents, else null)
+ *     ?? (validRemaining&Rate ? (remaining*rate).toFixed(2) : paymentAmount)
+ * Always returns a string; the API caller passes it to fiatMinorUnitsFromDisplayedAmount,
+ * which returns null for an unusable "0"/malformed value so the API fails SAR closed.
+ */
+export declare function computeDisplayedFiatAmount(input: DisplayedFiatAmountInput): string;
+/** Parse a 2-decimal (or fewer) positive decimal string to integer minor units. Null if non-positive/malformed/>2dp. */
+export declare function fiatMinorUnitsFromDisplayedAmount(displayed: string): bigint | null;

package/dist/fiatAmount.js

@@ -0,0 +1,58 @@
+const USDC_SCALE = 1000000n;
+const RATE_SCALE = 10n ** 18n;
+const CENT_SCALE = 100n;
+const QUOTE_DENOMINATOR = USDC_SCALE * RATE_SCALE; // 1e6 * 1e18
+function parseDecimalToScaledUnits(value, decimals) {
+    const normalized = value.trim();
+    if (!/^\d+(\.\d+)?$/.test(normalized))
+        return null;
+    const [whole, fraction = ''] = normalized.split('.');
+    const base = 10n ** BigInt(decimals);
+    const scaledFraction = fraction.slice(0, decimals).padEnd(decimals, '0');
+    return BigInt(whole) * base + BigInt(scaledFraction);
+}
+function ceilCentsFromSignalIntent(amountBaseUnits, conversionRateDecimal) {
+    if (!/^\d+$/.test(amountBaseUnits))
+        return null;
+    const units = BigInt(amountBaseUnits);
+    const rate = parseDecimalToScaledUnits(conversionRateDecimal, 18);
+    if (rate === null || rate <= 0n || units <= 0n)
+        return null;
+    const numerator = units * rate * CENT_SCALE;
+    return (numerator + QUOTE_DENOMINATOR - 1n) / QUOTE_DENOMINATOR; // ceil
+}
+function centsToDecimalString(cents) {
+    const whole = cents / CENT_SCALE;
+    const fraction = (cents % CENT_SCALE).toString().padStart(2, '0');
+    return `${whole.toString()}.${fraction}`;
+}
+/**
+ * The exact fiat amount the buyer is instructed to pay, as a decimal string.
+ * BYTE-IDENTICAL to checkoutData.ts mapCheckoutPaymentToQuote (lines 336-351):
+ *   quotedFiatAmount (PAYEE ceil-cents, else null)
+ *     ?? (validRemaining&Rate ? (remaining*rate).toFixed(2) : paymentAmount)
+ * Always returns a string; the API caller passes it to fiatMinorUnitsFromDisplayedAmount,
+ * which returns null for an unusable "0"/malformed value so the API fails SAR closed.
+ */
+export function computeDisplayedFiatAmount(input) {
+    const quotedCents = input.feePayer === 'PAYEE' && input.signalIntentAmountBaseUnits !== null && input.conversionRateDecimal !== null
+        ? ceilCentsFromSignalIntent(input.signalIntentAmountBaseUnits, input.conversionRateDecimal)
+        : null;
+    if (quotedCents !== null)
+        return centsToDecimalString(quotedCents);
+    const remainingUsdc = Number(input.remainingUsdcAmount);
+    const rate = Number(input.currencyPerUsdRate);
+    if (Number.isFinite(remainingUsdc) && Number.isFinite(rate) && remainingUsdc > 0 && rate > 0) {
+        return (remainingUsdc * rate).toFixed(2);
+    }
+    return input.paymentAmountFallback;
+}
+/** Parse a 2-decimal (or fewer) positive decimal string to integer minor units. Null if non-positive/malformed/>2dp. */
+export function fiatMinorUnitsFromDisplayedAmount(displayed) {
+    const normalized = displayed.trim();
+    if (!/^\d+(\.\d{1,2})?$/.test(normalized))
+        return null;
+    const [whole, fraction = ''] = normalized.split('.');
+    const cents = BigInt(whole) * CENT_SCALE + BigInt(fraction.padEnd(2, '0'));
+    return cents > 0n ? cents : null;
+}

package/dist/index.d.ts

@@ -3,4 +3,8 @@ export * from './chains.js';
 export * from './fees.js';
 export * from './crypto.js';
 export * from './rails.js';
+export * from './buyerTee.js';
 export * from './bitcoin.js';
+export * from './fiatAmount.js';
+export * from './paypalSarPhase.js';
+export * from './paypalSarVerify.js';

package/dist/index.js

@@ -3,4 +3,8 @@ export * from './chains.js';
 export * from './fees.js';
 export * from './crypto.js';
 export * from './rails.js';
+export * from './buyerTee.js';
 export * from './bitcoin.js';
+export * from './fiatAmount.js';
+export * from './paypalSarPhase.js';
+export * from './paypalSarVerify.js';

package/dist/paypalSarPhase.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Whether a name-mode SAR verify poll outcome is worth retrying. Only a "no receipt found yet" (404)
+ * may resolve on a later poll; every other terminal status is deterministic and must fail fast.
+ */
+export declare function isRetryableSarPollStatus(statusCode: number): boolean;

package/dist/paypalSarPhase.js

@@ -0,0 +1,8 @@
+const NO_RECEIPT_STATUS = 404; // SELLER_TXID_NOT_FOUND — the only status worth re-polling
+/**
+ * Whether a name-mode SAR verify poll outcome is worth retrying. Only a "no receipt found yet" (404)
+ * may resolve on a later poll; every other terminal status is deterministic and must fail fast.
+ */
+export function isRetryableSarPollStatus(statusCode) {
+    return statusCode === NO_RECEIPT_STATUS;
+}

package/dist/paypalSarVerify.d.ts

@@ -0,0 +1,41 @@
+export type SarAttemptOutcome = {
+    kind: 'success';
+    proofAttemptId: string;
+} | {
+    kind: 'unavailable';
+} | {
+    kind: 'error';
+    errorCode: string;
+    errorMessage: string;
+    statusCode: number;
+};
+export type SarVerifyResult = {
+    kind: 'success';
+    proofAttemptId: string;
+} | {
+    kind: 'unavailable';
+} | {
+    kind: 'error';
+    errorCode: string;
+    errorMessage: string;
+} | {
+    kind: 'aborted';
+};
+export interface RunPaypalSarNameVerifyDeps {
+    /** POST a name-mode attempt. attemptNumber is 1-based and increments per name poll. */
+    submitNameAttempt: (attemptNumber: number) => Promise<SarAttemptOutcome>;
+    sleep: (ms: number) => Promise<void>;
+    /** Re-checked after every await; returning false short-circuits to { kind: 'aborted' }. */
+    isMounted: () => boolean;
+    now: () => number;
+    retryIntervalMs: number;
+    retryDurationMs: number;
+}
+/**
+ * Name-only PayPal SAR verification.
+ * Polls name-mode verify (retrying only on retryable poll statuses until the deadline). Terminal
+ * name failures surface directly. Success / unavailable short-circuit. The caller maps the returned
+ * result to its own UI side effects; 'aborted' means the component unmounted and the caller should
+ * do nothing.
+ */
+export declare function runPaypalSarNameVerify(deps: RunPaypalSarNameVerifyDeps): Promise<SarVerifyResult>;

package/dist/paypalSarVerify.js

@@ -0,0 +1,31 @@
+import { isRetryableSarPollStatus } from './paypalSarPhase.js';
+/**
+ * Name-only PayPal SAR verification.
+ * Polls name-mode verify (retrying only on retryable poll statuses until the deadline). Terminal
+ * name failures surface directly. Success / unavailable short-circuit. The caller maps the returned
+ * result to its own UI side effects; 'aborted' means the component unmounted and the caller should
+ * do nothing.
+ */
+export async function runPaypalSarNameVerify(deps) {
+    const { submitNameAttempt, sleep, isMounted, now, retryIntervalMs, retryDurationMs } = deps;
+    const deadline = now() + retryDurationMs;
+    let attemptNumber = 1;
+    while (true) {
+        const outcome = await submitNameAttempt(attemptNumber);
+        if (!isMounted())
+            return { kind: 'aborted' };
+        if (outcome.kind === 'success')
+            return { kind: 'success', proofAttemptId: outcome.proofAttemptId };
+        if (outcome.kind === 'unavailable')
+            return { kind: 'unavailable' };
+        const deadlineReached = now() + retryIntervalMs > deadline;
+        if (isRetryableSarPollStatus(outcome.statusCode) && !deadlineReached) {
+            await sleep(retryIntervalMs);
+            if (!isMounted())
+                return { kind: 'aborted' };
+            attemptNumber += 1;
+            continue;
+        }
+        return { kind: 'error', errorCode: outcome.errorCode, errorMessage: outcome.errorMessage };
+    }
+}

package/dist/rails.d.ts

@@ -42,6 +42,17 @@ export declare enum SupportedRelayRail {
 export declare const DEFAULT_FIAT_RAILS: readonly SupportedRail[];
 export declare const SUPPORTED_RAILS: readonly SupportedRail[];
 export declare const SUPPORTED_RELAY_RAILS: readonly SupportedRelayRail[];
+export declare const FIAT_SUPPORTED_RAILS: readonly ["venmo", "cashapp", "revolut", "wise", "zelle", "paypal", "monzo", "n26", "chime"];
+export type FiatSupportedRail = typeof FIAT_SUPPORTED_RAILS[number];
+export declare const PAYMENT_PLATFORM_LABELS: Record<string, string>;
+export declare const FIAT_RAIL_DISPLAY_NAMES: Record<FiatSupportedRail, string>;
+export declare const ORDER_SEARCH_MIN_QUERY_LENGTH = 3;
+export declare function railKeysForQuery(query: string): string[];
+export declare const RELAY_CHAIN_DISPLAY_NAMES: Record<number, string>;
+/**
+ * Surfaces crypto-settled orders for token, chain, and "crypto" prefix queries.
+ */
+export declare function isCryptoMethodQuery(query: string): boolean;
 /**
  * Normalizes a rail string into a crypto chain id.
  *
@@ -51,11 +62,76 @@ export declare const SUPPORTED_RELAY_RAILS: readonly SupportedRelayRail[];
  */
 export declare function parseCryptoRailChainId(rail: string | null | undefined): number | null;
 export declare function isSupportedRail(rail: string): rail is SupportedRail;
+export declare function isFiatSupportedRail(rail: string): rail is FiatSupportedRail;
+/** Returns false for rails that remain recognized but are disabled at runtime. */
+export declare function isRailRuntimeEnabled(rail: string | null | undefined): boolean;
+/** Filters out globally disabled runtime rails while preserving caller ordering. */
+export declare function filterRuntimeEnabledRails<T extends string>(rails: readonly T[]): T[];
+/**
+ * Replaces the set of globally runtime-disabled fiat rails. Only EXACT base
+ * fiat rails are honored (e.g. `venmo`, `paypal`, `zelle`); rail variants
+ * (e.g. `zelle-chase`, or an env typo like `paypal-test`), crypto/relay rails,
+ * and unknown strings are ignored so a malformed env value cannot silently
+ * disable a live rail. Disable is base-granular: disabling `zelle` also
+ * disables its variants at check time (isRailRuntimeEnabled normalizes the
+ * checked rail to its base). Backend-only: the API applies the `DISABLED_RAILS`
+ * env at boot; the frontend never calls this, so its disabled set stays empty.
+ */
+export declare function setRuntimeDisabledFiatRails(rails: readonly string[]): void;
+/** Returns the currently runtime-disabled fiat rails (canonical base rails). */
+export declare function getRuntimeDisabledFiatRails(): string[];
 /** Returns true when the rail targets a crypto chain (legacy numeric or relay-prefixed format). */
 export declare function isCryptoRail(rail: string | null | undefined): boolean;
 /** Formats a chain id into the canonical relay rail string: `relay_<chainId>`. */
 export declare function formatRelayRail(chainId: number): string;
 /** Normalizes any crypto rail into canonical relay format (or null for non-crypto rails). */
 export declare function normalizeCryptoRail(rail: string | null | undefined): string | null;
+/** Returns the canonical base fiat rail for base rails and supported variants such as `zelle-chase`. */
+export declare function normalizeFiatRail(rail: string | null | undefined): string | null;
+/**
+ * Fiat rails that support Seller Automated Release (SAR). Merchants in
+ * EXCLUSIVE_SAR mode may only offer these rails; every other fiat rail is
+ * force-disabled in the merchant and admin dashboards.
+ */
+export declare const SAR_SUPPORTED_FIAT_RAILS: readonly ["venmo", "cashapp", "wise", "paypal"];
+export type SarSupportedFiatRail = typeof SAR_SUPPORTED_FIAT_RAILS[number];
+/** Returns true when the fiat rail (incl. variants like `zelle-chase`) supports SAR. */
+export declare function isSarSupportedFiatRail(rail: string | null | undefined): boolean;
+/**
+ * Returns `rails` with non-SAR fiat rails removed, preserving crypto/relay rails,
+ * SAR-supported fiat rails, and original ordering. Used to keep an EXCLUSIVE_SAR
+ * merchant's `enabledRails` in sync with their quote preference: non-SAR fiat
+ * rails (e.g. `zelle`, `revolut`, incl. variants like `zelle-chase`) are dropped
+ * while crypto rails and SAR rails (venmo/cashapp/wise/paypal) are kept.
+ */
+export declare function filterRailsForExclusiveSar(rails: readonly string[]): string[];
+/** Canonical Zelle paymentMethodId -> attestation-service actionType suffix. */
+export declare const ZELLE_METHOD_ACTION_SUFFIX: Record<string, string>;
+/** Strict create-boundary set for Zelle method ids and transitional variant rails. */
+export declare const ZELLE_PAYMENT_METHOD_IDS: ReadonlySet<string>;
+/** Bank-qualified buyer TEE action types accepted for generic Zelle proofs. */
+export declare const ZELLE_BUYER_TEE_ACTION_TYPES: ReadonlySet<string>;
+export type AttestationRoute = {
+    readonly platform: string;
+    readonly actionType: string;
+};
+/**
+ * Resolves the attestation-service verifier route (`platform` + `actionType`)
+ * for a persisted `payment.rail` value.
+ *
+ * Zelle variants map to the new generic `zelle` platform with a bank-qualified
+ * actionType. Legacy bank-specific verifier routes are drain-only and should
+ * stay outside shared core. Non-Zelle fiat rails use the base rail as platform
+ * and `transfer_{rail}` as actionType. Unknown / crypto rails fall back to the
+ * raw trimmed rail so callers still surface a verifier mismatch via the
+ * attestation response rather than silently mis-routing.
+ */
+export declare function resolveAttestationRoute(rail: string | null | undefined): AttestationRoute;
+/** Canonical generic Zelle on-chain method hash: keccak256("zelle"), lowercase. */
+export declare const GENERIC_ZELLE_PAYMENT_METHOD_HASH = "0xf752c7d19698ecb0bb8988abf9b9a53a4c3657f3bc8850a6fb59fdf3e3ce8cd3";
+/** Case-insensitive check that a hash is the canonical generic Zelle on-chain method hash. */
+export declare function isGenericZellePaymentMethodHash(hash: string | null | undefined): boolean;
+/** True when the rail is Zelle (generic or a bank variant). */
+export declare function isZelleRail(rail: string | null | undefined): boolean;
 /** Formats a rail value for human-readable UI labels. */
 export declare function getRailDisplayName(rail: string | null | undefined): string;

package/dist/rails.js

@@ -51,18 +51,49 @@ export const DEFAULT_FIAT_RAILS = [
 export const SUPPORTED_RAILS = Object.values(SupportedRail);
 export const SUPPORTED_RELAY_RAILS = Object.values(SupportedRelayRail);
 const SUPPORTED_RAIL_SET = new Set(SUPPORTED_RAILS);
-const FIAT_RAIL_DISPLAY_NAMES = {
+// Globally runtime-disabled fiat rails: removed from new offers/acceptance
+// everywhere isRailRuntimeEnabled / filterRuntimeEnabledRails are consumed,
+// while staying recognized for historical orders. Empty by default; the API
+// seeds this from the DISABLED_RAILS env at boot via setRuntimeDisabledFiatRails.
+// The frontend never sets it, so the browser bundle keeps an empty (no-op) set.
+let runtimeDisabledFiatRails = new Set();
+export const FIAT_SUPPORTED_RAILS = [
+    'venmo',
+    'cashapp',
+    'revolut',
+    'wise',
+    'zelle',
+    'paypal',
+    'monzo',
+    'n26',
+    'chime',
+];
+const PAYMENT_PLATFORM_LABEL_ENTRIES = {
     [SupportedRail.VENMO]: 'Venmo',
     [SupportedRail.CASHAPP]: 'Cash App',
     [SupportedRail.REVOLUT]: 'Revolut',
+    [SupportedRail.WISE]: 'Wise',
     [SupportedRail.ZELLE]: 'Zelle',
     [SupportedRail.PAYPAL]: 'PayPal',
-    [SupportedRail.WISE]: 'Wise',
     [SupportedRail.MONZO]: 'Monzo',
     [SupportedRail.N26]: 'N26',
     [SupportedRail.CHIME]: 'Chime',
 };
-const RELAY_CHAIN_DISPLAY_NAMES = {
+export const PAYMENT_PLATFORM_LABELS = PAYMENT_PLATFORM_LABEL_ENTRIES;
+export const FIAT_RAIL_DISPLAY_NAMES = PAYMENT_PLATFORM_LABEL_ENTRIES;
+// Shared FE/BE minimum so queries too short for the pg_trgm trigram index are no-ops.
+export const ORDER_SEARCH_MIN_QUERY_LENGTH = 3;
+export function railKeysForQuery(query) {
+    const normalizedQuery = query.trim().toLowerCase();
+    if (normalizedQuery.length === 0) {
+        return [];
+    }
+    return Object.entries(PAYMENT_PLATFORM_LABELS)
+        .filter(([, label]) => label.toLowerCase().includes(normalizedQuery))
+        .map(([key]) => key);
+}
+const SUPPORTED_FIAT_RAILS = new Set(Object.keys(FIAT_RAIL_DISPLAY_NAMES));
+export const RELAY_CHAIN_DISPLAY_NAMES = {
     1: 'Ethereum',
     10: 'Optimism',
     56: 'BNB Smart Chain',
@@ -75,6 +106,22 @@ const RELAY_CHAIN_DISPLAY_NAMES = {
     728126428: 'Tron',
     792703809: 'Solana',
 };
+const CRYPTO_METHOD_ALIASES = [
+    'crypto',
+    'usdc',
+    'usdt',
+    ...Object.values(RELAY_CHAIN_DISPLAY_NAMES).map((name) => name.toLowerCase()),
+];
+/**
+ * Surfaces crypto-settled orders for token, chain, and "crypto" prefix queries.
+ */
+export function isCryptoMethodQuery(query) {
+    const normalizedQuery = query.trim().toLowerCase();
+    if (normalizedQuery.length === 0) {
+        return false;
+    }
+    return CRYPTO_METHOD_ALIASES.some((alias) => alias.startsWith(normalizedQuery));
+}
 /**
  * Normalizes a rail string into a crypto chain id.
  *
@@ -105,6 +152,45 @@ export function parseCryptoRailChainId(rail) {
 export function isSupportedRail(rail) {
     return SUPPORTED_RAIL_SET.has(rail);
 }
+export function isFiatSupportedRail(rail) {
+    return FIAT_SUPPORTED_RAILS.includes(rail);
+}
+/** Returns false for rails that remain recognized but are disabled at runtime. */
+export function isRailRuntimeEnabled(rail) {
+    const normalizedFiatRail = normalizeFiatRail(rail);
+    return normalizedFiatRail === null || !runtimeDisabledFiatRails.has(normalizedFiatRail);
+}
+/** Filters out globally disabled runtime rails while preserving caller ordering. */
+export function filterRuntimeEnabledRails(rails) {
+    return rails.filter((rail) => isRailRuntimeEnabled(rail));
+}
+/**
+ * Replaces the set of globally runtime-disabled fiat rails. Only EXACT base
+ * fiat rails are honored (e.g. `venmo`, `paypal`, `zelle`); rail variants
+ * (e.g. `zelle-chase`, or an env typo like `paypal-test`), crypto/relay rails,
+ * and unknown strings are ignored so a malformed env value cannot silently
+ * disable a live rail. Disable is base-granular: disabling `zelle` also
+ * disables its variants at check time (isRailRuntimeEnabled normalizes the
+ * checked rail to its base). Backend-only: the API applies the `DISABLED_RAILS`
+ * env at boot; the frontend never calls this, so its disabled set stays empty.
+ */
+export function setRuntimeDisabledFiatRails(rails) {
+    const next = new Set();
+    for (const rail of rails) {
+        if (typeof rail !== 'string') {
+            continue;
+        }
+        const normalized = rail.trim().toLowerCase();
+        if (isFiatSupportedRail(normalized)) {
+            next.add(normalized);
+        }
+    }
+    runtimeDisabledFiatRails = next;
+}
+/** Returns the currently runtime-disabled fiat rails (canonical base rails). */
+export function getRuntimeDisabledFiatRails() {
+    return [...runtimeDisabledFiatRails];
+}
 /** Returns true when the rail targets a crypto chain (legacy numeric or relay-prefixed format). */
 export function isCryptoRail(rail) {
     return parseCryptoRailChainId(rail) !== null;
@@ -121,6 +207,97 @@ export function normalizeCryptoRail(rail) {
     const chainId = parseCryptoRailChainId(rail);
     return chainId === null ? null : formatRelayRail(chainId);
 }
+/** Returns the canonical base fiat rail for base rails and supported variants such as `zelle-chase`. */
+export function normalizeFiatRail(rail) {
+    if (typeof rail !== 'string') {
+        return null;
+    }
+    const trimmed = rail.trim().toLowerCase();
+    if (trimmed === '') {
+        return null;
+    }
+    if (SUPPORTED_FIAT_RAILS.has(trimmed)) {
+        return trimmed;
+    }
+    for (const baseRail of SUPPORTED_FIAT_RAILS) {
+        if (trimmed.startsWith(`${baseRail}-`)) {
+            return baseRail;
+        }
+    }
+    return null;
+}
+/**
+ * Fiat rails that support Seller Automated Release (SAR). Merchants in
+ * EXCLUSIVE_SAR mode may only offer these rails; every other fiat rail is
+ * force-disabled in the merchant and admin dashboards.
+ */
+export const SAR_SUPPORTED_FIAT_RAILS = ['venmo', 'cashapp', 'wise', 'paypal'];
+const SAR_SUPPORTED_FIAT_RAIL_SET = new Set(SAR_SUPPORTED_FIAT_RAILS);
+/** Returns true when the fiat rail (incl. variants like `zelle-chase`) supports SAR. */
+export function isSarSupportedFiatRail(rail) {
+    const normalized = normalizeFiatRail(rail);
+    return normalized !== null && SAR_SUPPORTED_FIAT_RAIL_SET.has(normalized);
+}
+/**
+ * Returns `rails` with non-SAR fiat rails removed, preserving crypto/relay rails,
+ * SAR-supported fiat rails, and original ordering. Used to keep an EXCLUSIVE_SAR
+ * merchant's `enabledRails` in sync with their quote preference: non-SAR fiat
+ * rails (e.g. `zelle`, `revolut`, incl. variants like `zelle-chase`) are dropped
+ * while crypto rails and SAR rails (venmo/cashapp/wise/paypal) are kept.
+ */
+export function filterRailsForExclusiveSar(rails) {
+    return rails.filter((rail) => {
+        const normalizedFiat = normalizeFiatRail(rail);
+        // Non-fiat (crypto/relay) or unrecognized rails are preserved verbatim.
+        if (normalizedFiat === null) {
+            return true;
+        }
+        // Recognized fiat rail: keep only if it supports SAR.
+        return SAR_SUPPORTED_FIAT_RAIL_SET.has(normalizedFiat);
+    });
+}
+/** Canonical Zelle paymentMethodId -> attestation-service actionType suffix. */
+export const ZELLE_METHOD_ACTION_SUFFIX = {
+    'zelle-bofa': 'bofa',
+    'zelle-chase': 'chase',
+    'zelle-citi': 'citi',
+};
+/** Strict create-boundary set for Zelle method ids and transitional variant rails. */
+export const ZELLE_PAYMENT_METHOD_IDS = new Set(Object.keys(ZELLE_METHOD_ACTION_SUFFIX));
+/** Bank-qualified buyer TEE action types accepted for generic Zelle proofs. */
+export const ZELLE_BUYER_TEE_ACTION_TYPES = new Set(Object.values(ZELLE_METHOD_ACTION_SUFFIX).map((suffix) => `transfer_zelle_${suffix}`));
+/**
+ * Resolves the attestation-service verifier route (`platform` + `actionType`)
+ * for a persisted `payment.rail` value.
+ *
+ * Zelle variants map to the new generic `zelle` platform with a bank-qualified
+ * actionType. Legacy bank-specific verifier routes are drain-only and should
+ * stay outside shared core. Non-Zelle fiat rails use the base rail as platform
+ * and `transfer_{rail}` as actionType. Unknown / crypto rails fall back to the
+ * raw trimmed rail so callers still surface a verifier mismatch via the
+ * attestation response rather than silently mis-routing.
+ */
+export function resolveAttestationRoute(rail) {
+    const trimmed = typeof rail === 'string' ? rail.trim().toLowerCase() : '';
+    // TRANSITIONAL: rail-variant fold, delete after drain window.
+    const zelleVariantSuffix = ZELLE_METHOD_ACTION_SUFFIX[trimmed];
+    if (zelleVariantSuffix !== undefined) {
+        return { platform: 'zelle', actionType: `transfer_zelle_${zelleVariantSuffix}` };
+    }
+    const baseRail = normalizeFiatRail(trimmed) ?? trimmed;
+    return { platform: baseRail, actionType: `transfer_${baseRail}` };
+}
+/** Canonical generic Zelle on-chain method hash: keccak256("zelle"), lowercase. */
+export const GENERIC_ZELLE_PAYMENT_METHOD_HASH = '0xf752c7d19698ecb0bb8988abf9b9a53a4c3657f3bc8850a6fb59fdf3e3ce8cd3';
+/** Case-insensitive check that a hash is the canonical generic Zelle on-chain method hash. */
+export function isGenericZellePaymentMethodHash(hash) {
+    return typeof hash === 'string'
+        && hash.trim().toLowerCase() === GENERIC_ZELLE_PAYMENT_METHOD_HASH;
+}
+/** True when the rail is Zelle (generic or a bank variant). */
+export function isZelleRail(rail) {
+    return normalizeFiatRail(rail) === 'zelle';
+}
 /** Formats a rail value for human-readable UI labels. */
 export function getRailDisplayName(rail) {
     if (typeof rail !== 'string') {
@@ -131,9 +308,8 @@ export function getRailDisplayName(rail) {
         return 'Unknown';
     }
     const normalized = trimmed.toLowerCase();
-    const fiatDisplayName = FIAT_RAIL_DISPLAY_NAMES[normalized];
-    if (fiatDisplayName) {
-        return fiatDisplayName;
+    if (isFiatSupportedRail(normalized)) {
+        return FIAT_RAIL_DISPLAY_NAMES[normalized];
     }
     const chainId = parseCryptoRailChainId(trimmed);
     if (chainId !== null) {

package/dist/types.d.ts

@@ -1,4 +1,5 @@
 import type { PayCryptoTokenSymbol } from './crypto.js';
+import type { ProofMode } from './buyerTee.js';
 export declare const PaymentPlatform: {
     readonly VENMO: "venmo";
     readonly CASHAPP: "cashapp";
@@ -11,6 +12,11 @@ export declare const PaymentPlatform: {
     readonly CHIME: "chime";
 };
 export type PaymentPlatformType = typeof PaymentPlatform[keyof typeof PaymentPlatform];
+/**
+ * Type guard for PaymentPlatform values.
+ * Returns true if `value` is one of the known PaymentPlatform enum values.
+ */
+export declare function isPaymentPlatform(value: unknown): value is PaymentPlatformType;
 export declare const SupportedChains: Record<number, string>;
 export type SupportedChainId = keyof typeof SupportedChains;
 export declare const CheckoutMode: {
@@ -57,6 +63,13 @@ export declare const FeePayer: {
     readonly PAYEE: "PAYEE";
 };
 export type FeePayerType = typeof FeePayer[keyof typeof FeePayer];
+export declare const MerchantPaymentFlowMode: {
+    readonly EXCLUSIVE_SAR: "EXCLUSIVE_SAR";
+    readonly PREFER_SAR: "PREFER_SAR";
+    readonly PREFER_BUYER_TEE: "PREFER_BUYER_TEE";
+    readonly EXCLUSIVE_BUYER_TEE: "EXCLUSIVE_BUYER_TEE";
+};
+export type MerchantPaymentFlowModeType = typeof MerchantPaymentFlowMode[keyof typeof MerchantPaymentFlowMode];
 export declare const CheckoutOrderStatus: {
     readonly CREATED: "CREATED";
     readonly PARTIALLY_FULFILLED: "PARTIALLY_FULFILLED";
@@ -64,6 +77,12 @@ export declare const CheckoutOrderStatus: {
     readonly CANCELLED: "CANCELLED";
 };
 export type CheckoutOrderStatusType = typeof CheckoutOrderStatus[keyof typeof CheckoutOrderStatus];
+export declare const CheckoutOrderRefundStatus: {
+    readonly NONE: "NONE";
+    readonly PENDING: "PENDING";
+    readonly COMPLETED: "COMPLETED";
+};
+export type CheckoutOrderRefundStatusType = typeof CheckoutOrderRefundStatus[keyof typeof CheckoutOrderRefundStatus];
 export declare const CheckoutPaymentStatus: {
     readonly CREATED: "CREATED";
     readonly SETTLED: "SETTLED";
@@ -72,6 +91,12 @@ export declare const CheckoutPaymentStatus: {
     readonly FAILED: "FAILED";
 };
 export type CheckoutPaymentStatusType = typeof CheckoutPaymentStatus[keyof typeof CheckoutPaymentStatus];
+export declare const CheckoutPaymentMemoPolicy: {
+    readonly NONE: "NONE";
+    readonly REQUIRED: "REQUIRED";
+    readonly EMPTY: "EMPTY";
+};
+export type CheckoutPaymentMemoPolicyType = typeof CheckoutPaymentMemoPolicy[keyof typeof CheckoutPaymentMemoPolicy];
 export type ReferralFeeEntry = {
     recipient: string;
     feeBps: number;
@@ -125,11 +150,19 @@ export type CheckoutMerchant = {
     disableBranding: boolean;
     checkoutTheme: MerchantCheckoutTheme | null;
     defaultPaymentCurrency?: string | null;
+    /** Whether the merchant has been verified by ZKP2P. */
+    verified: boolean;
 };
 export type CheckoutOrder = {
     id: string;
     merchantId: string;
     status: CheckoutOrderStatusType;
+    refundStatus: CheckoutOrderRefundStatusType;
+    refundAmountUsdc: string | null;
+    refundDepositId: string | null;
+    refundTransactionHash: string | null;
+    refundMetadata: unknown | null;
+    inPersonCheckout: boolean;
     requestedUsdcAmount: string;
     remainingUsdcAmount: string;
     destinationAddress: string;
@@ -163,6 +196,7 @@ export type CheckoutPaymentQuote = {
         depositData: Record<string, string>;
     };
     intentHash?: string;
+    sellerAutomatedReleaseAvailable?: boolean;
 };
 export type CheckoutQuote = {
     displayAmount: string;
@@ -172,6 +206,7 @@ export type CheckoutQuoteEntry = {
     platform: string;
     displayAmount: string;
     spreadPercentage: number;
+    sellerAutomatedReleaseAvailable?: boolean;
 };
 export type CheckoutQuotes = {
     orderId: string;
@@ -183,10 +218,19 @@ export type CheckoutPayment = {
     orderId: string;
     status: CheckoutPaymentStatusType;
     rail: string;
+    paymentMethodId: string | null;
+    proofMode: ProofMode;
+    attestation: {
+        serviceUrl: string;
+    };
     currency: string;
     payTo: string;
+    /** Recipient rating in the 1.0–5.0 range, rounded to one decimal. */
+    recipientRating: number;
     quote: CheckoutPaymentQuote;
     quoteExpiresAt: string;
+    memoPolicy: CheckoutPaymentMemoPolicyType;
+    suggestedMemo: string | null;
     paymentAmount: string;
     currencyPerUsdRate: string;
     netSettledUsdcAmount: string | null;
@@ -194,14 +238,19 @@ export type CheckoutPayment = {
     referralFees: SettlementReferralFeeEntry[] | null;
     railIdentifier: string | null;
     fulfillTransaction: string | null;
+    errorCode?: string | null;
+    errorMessage?: string | null;
     completedAt: string | null;
     createdAt: string;
     updatedAt: string | null;
 };
+export type CheckoutAggregatePayment = Omit<CheckoutPayment, 'paymentMethodId'> & {
+    paymentMethodId?: string | null;
+};
 export type CheckoutAggregate = {
     order: CheckoutOrder;
     merchant: CheckoutMerchant;
-    currentPayment: CheckoutPayment | null;
+    currentPayment: CheckoutAggregatePayment | null;
 };
 export type CreateOrderResponse = {
     order: CheckoutOrder;
@@ -211,6 +260,7 @@ export type CreateCheckoutResponse = CreateOrderResponse;
 export type CheckoutCreateResponse = CreateOrderResponse;
 export type CreatePaymentRequest = {
     rail: string;
+    paymentMethodId?: string;
     fiatCurrency?: string;
     currency?: string;
     replacementPaymentId?: string;
@@ -227,6 +277,7 @@ export type PaymentDeeplinkResponse = {
     url: string;
     proofSubmissionUrl: string;
     checkoutReturnUrl: string;
+    linkKind?: 'app_clip' | 'deeplink';
 };
 export type CheckoutDeeplinkResponse = PaymentDeeplinkResponse;
 export type MerchantConfig = {
@@ -246,11 +297,24 @@ export type MerchantConfig = {
     createdAt: string;
     updatedAt: string | null;
 };
+export declare const DashboardPrivyApp: {
+    readonly LEGACY: "LEGACY";
+    readonly V1: "V1";
+};
+export type DashboardPrivyAppType = typeof DashboardPrivyApp[keyof typeof DashboardPrivyApp];
+export declare const MerchantMigrationStatus: {
+    readonly PENDING: "PENDING";
+    readonly MIGRATING: "MIGRATING";
+    readonly COMPLETE: "COMPLETE";
+    readonly FAILED: "FAILED";
+};
+export type MerchantMigrationStatusType = typeof MerchantMigrationStatus[keyof typeof MerchantMigrationStatus];
 export type MerchantUser = {
     id: string;
     email: string | null;
-    privyUserId: string;
-    role: 'OWNER' | 'MANAGER';
+    privyUserId: string | null;
+    v1PrivyUserId: string | null;
+    role: 'OWNER' | 'MANAGER' | 'CASHIER';
     merchantId: string | null;
     createdAt: string;
     updatedAt: string | null;
@@ -259,11 +323,17 @@ export type MerchantProfile = {
     id: string;
     name: string;
     logoUrl: string | null;
+    industryType: string | null;
+    industryOtherText: string | null;
     apiKey: string;
     environment: MerchantEnvironmentType;
     sandboxMerchantId: string | null;
+    inPersonCheckoutEnabled: boolean;
+    migrationStatus: MerchantMigrationStatusType;
     evmWalletAddress: string | null;
     solanaWalletAddress: string | null;
+    v1EvmWalletAddress: string | null;
+    v1SolanaWalletAddress: string | null;
     tier: 'FREE' | 'PRO';
     createdAt: string;
     updatedAt: string | null;
@@ -328,6 +398,8 @@ export type Merchant = {
     id: string;
     name: string;
     logoUrl?: string | null;
+    industryType?: string | null;
+    industryOtherText?: string | null;
     disableBranding?: boolean;
     apiKey: string;
     environment?: MerchantEnvironmentType;
@@ -605,6 +677,8 @@ export declare const WebhookEventType: {
     readonly PAYMENT_CANCELLED: "PAYMENT_CANCELLED";
     readonly PAYMENT_EXPIRED: "PAYMENT_EXPIRED";
     readonly PAYMENT_FAILED: "PAYMENT_FAILED";
+    readonly REFUND_PENDING: "REFUND_PENDING";
+    readonly REFUND_COMPLETED: "REFUND_COMPLETED";
     readonly PAYMENT_BRIDGE_PENDING: "PAYMENT_BRIDGE_PENDING";
     readonly PAYMENT_BRIDGE_SUBMITTED: "PAYMENT_BRIDGE_SUBMITTED";
     readonly PAYMENT_BRIDGE_COMPLETED: "PAYMENT_BRIDGE_COMPLETED";
@@ -653,6 +727,7 @@ export type WebhookPayload = {
     data: {
         order: CheckoutOrder | null;
         payment: CheckoutPayment | null;
+        refund: Record<string, unknown> | null;
         paymentBridge: Record<string, unknown> | null;
     };
 };

package/dist/types.js

@@ -10,6 +10,14 @@ export const PaymentPlatform = {
     N26: 'n26',
     CHIME: 'chime',
 };
+const PAYMENT_PLATFORM_VALUES = new Set(Object.values(PaymentPlatform));
+/**
+ * Type guard for PaymentPlatform values.
+ * Returns true if `value` is one of the known PaymentPlatform enum values.
+ */
+export function isPaymentPlatform(value) {
+    return typeof value === 'string' && PAYMENT_PLATFORM_VALUES.has(value);
+}
 // Supported chains for USDC destination
 // Re-exported from chains.ts for backward compatibility
 export const SupportedChains = SupportedChainsMap;
@@ -53,12 +61,23 @@ export const FeePayer = {
     MERCHANT: 'MERCHANT',
     PAYEE: 'PAYEE',
 };
+export const MerchantPaymentFlowMode = {
+    EXCLUSIVE_SAR: 'EXCLUSIVE_SAR',
+    PREFER_SAR: 'PREFER_SAR',
+    PREFER_BUYER_TEE: 'PREFER_BUYER_TEE',
+    EXCLUSIVE_BUYER_TEE: 'EXCLUSIVE_BUYER_TEE',
+};
 export const CheckoutOrderStatus = {
     CREATED: 'CREATED',
     PARTIALLY_FULFILLED: 'PARTIALLY_FULFILLED',
     FULFILLED: 'FULFILLED',
     CANCELLED: 'CANCELLED',
 };
+export const CheckoutOrderRefundStatus = {
+    NONE: 'NONE',
+    PENDING: 'PENDING',
+    COMPLETED: 'COMPLETED',
+};
 export const CheckoutPaymentStatus = {
     CREATED: 'CREATED',
     SETTLED: 'SETTLED',
@@ -66,6 +85,21 @@ export const CheckoutPaymentStatus = {
     EXPIRED: 'EXPIRED',
     FAILED: 'FAILED',
 };
+export const CheckoutPaymentMemoPolicy = {
+    NONE: 'NONE',
+    REQUIRED: 'REQUIRED',
+    EMPTY: 'EMPTY',
+};
+export const DashboardPrivyApp = {
+    LEGACY: 'LEGACY',
+    V1: 'V1',
+};
+export const MerchantMigrationStatus = {
+    PENDING: 'PENDING',
+    MIGRATING: 'MIGRATING',
+    COMPLETE: 'COMPLETE',
+    FAILED: 'FAILED',
+};
 // Structured error codes for Order failures
 export const OrderErrorCode = {
     // Proof verification errors
@@ -107,6 +141,8 @@ export const WebhookEventType = {
     PAYMENT_CANCELLED: 'PAYMENT_CANCELLED',
     PAYMENT_EXPIRED: 'PAYMENT_EXPIRED',
     PAYMENT_FAILED: 'PAYMENT_FAILED',
+    REFUND_PENDING: 'REFUND_PENDING',
+    REFUND_COMPLETED: 'REFUND_COMPLETED',
     PAYMENT_BRIDGE_PENDING: 'PAYMENT_BRIDGE_PENDING',
     PAYMENT_BRIDGE_SUBMITTED: 'PAYMENT_BRIDGE_SUBMITTED',
     PAYMENT_BRIDGE_COMPLETED: 'PAYMENT_BRIDGE_COMPLETED',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zkp2p/pay-shared",
-  "version": "1.0.0",
+  "version": "2.0.0",
   "description": "Shared TypeScript types, enums, and chain utilities used by ZKP2P Pay API, SDK, and frontend apps.",
   "type": "module",
   "main": "dist/index.js",
@@ -37,7 +37,11 @@
   "scripts": {
     "build": "rm -rf dist && tsc -p tsconfig.json",
     "lint": "eslint . --ext .ts,.tsx",
+    "test": "vitest run",
     "prepack": "npm run build",
     "prepublishOnly": "npm pack --dry-run"
+  },
+  "devDependencies": {
+    "vitest": "^1.6.1"
   }
 }