-
{truncateAddress(address)}
{!compact && (
-
+
{balanceLoading
? "Loading USDC…"
: balance !== null
@@ -192,21 +172,12 @@ export default function WalletConnect() {
{error &&
Could not connect.
}
-
- {balanceLoading
- ? "Loading USDC…"
- : balance !== null
- ? `${formatAmount(balance)} USDC`
- : USDC_CONTRACT_ID
- ? "Unable to load balance"
- : "USDC contract not configured"}
-
);
}
@@ -218,11 +189,8 @@ export default function WalletConnect() {
@@ -230,11 +198,8 @@ export default function WalletConnect() {
@@ -252,7 +217,10 @@ export default function WalletConnect() {
setModalError(null)}
- onRetry={() => { setModalError(null); handleConnect(); }}
+ onRetry={() => {
+ setModalError(null);
+ handleConnect();
+ }}
/>
);
diff --git a/src/components/invoice/FeeEstimateBar.tsx b/src/components/invoice/FeeEstimateBar.tsx
new file mode 100644
index 0000000..e2fbfc8
--- /dev/null
+++ b/src/components/invoice/FeeEstimateBar.tsx
@@ -0,0 +1,126 @@
+"use client";
+
+import { useFeeEstimate, FALLBACK_BASE_FEE } from "@/hooks/useFeeEstimate";
+
+interface Props {
+ /** Number of operations in the transaction; fees scale linearly. */
+ operationCount?: number;
+}
+
+const STROOPS_PER_XLM = 10_000_000;
+
+interface Tier {
+ id: "economy" | "standard" | "priority";
+ label: string;
+ description: string;
+ stroopsPerOp: number;
+ segmentClass: string;
+}
+
+function toXlm(stroops: number): string {
+ return (stroops / STROOPS_PER_XLM).toFixed(7);
+}
+
+/**
+ * FeeEstimateBar (#411) — shows live network fees across three tiers with a
+ * segmented bar visualization, scaled by the operation count of the invoice
+ * transaction being built.
+ */
+export default function FeeEstimateBar({ operationCount = 1 }: Props) {
+ const { baseFee, medianFee, p90Fee, loading, error } = useFeeEstimate();
+
+ if (loading) {
+ return (
+
+
+ Loading fee estimates…
+
+
+ );
+ }
+
+ const ops = Math.max(1, operationCount);
+ const economy = baseFee ?? FALLBACK_BASE_FEE;
+ const standard = Math.max(economy, medianFee ?? economy);
+ const priority = Math.max(standard, p90Fee ?? standard);
+
+ const tiers: Tier[] = [
+ {
+ id: "economy",
+ label: "Economy",
+ description: "Slowest confirmation, base network fee",
+ stroopsPerOp: economy,
+ segmentClass: "bg-emerald-500",
+ },
+ {
+ id: "standard",
+ label: "Standard",
+ description: "Median network fee, typical confirmation time",
+ stroopsPerOp: standard,
+ segmentClass: "bg-indigo-500",
+ },
+ {
+ id: "priority",
+ label: "Priority",
+ description: "90th percentile fee, fastest confirmation",
+ stroopsPerOp: priority,
+ segmentClass: "bg-amber-500",
+ },
+ ];
+
+ const maxTotal = tiers[tiers.length - 1].stroopsPerOp * ops;
+
+ return (
+
+ {error && (
+
+ Error loading live fee stats. Showing fallback estimates.
+
+ )}
+
+
+ Network fees shown in stroops with XLM equivalents (1 XLM = 10,000,000
+ base units), scaled to {ops} operation{ops === 1 ? "" : "s"}.
+
+
+ {/* Segmented bar visualization */}
+
+ {tiers.map((tier) => (
+ 0 ? (tier.stroopsPerOp * ops * 100) / maxTotal : 33.33}%`,
+ }}
+ />
+ ))}
+
+
+
+ {tiers.map((tier) => {
+ const totalStroops = tier.stroopsPerOp * ops;
+ return (
+ -
+
+ {tier.label}
+
+
+ {totalStroops}
+
+
+ {toXlm(totalStroops)}
+
+
+ );
+ })}
+
+
+ );
+}
diff --git a/src/components/settings/BrandingForm.tsx b/src/components/settings/BrandingForm.tsx
new file mode 100644
index 0000000..2f0694c
--- /dev/null
+++ b/src/components/settings/BrandingForm.tsx
@@ -0,0 +1,423 @@
+"use client";
+
+import { useCallback, useEffect, useState } from "react";
+import { useForm } from "react-hook-form";
+import { zodResolver } from "@hookform/resolvers/zod";
+import { getFreighterPublicKey } from "@/lib/freighter";
+import {
+ ALLOWED_LOGO_MIME_TYPES,
+ brandSettingsSchema,
+ DEFAULT_ACCENT_COLOR,
+ isAllowedLogoMimeType,
+ isLogoSizeOk,
+ LOGO_SIZE_ERROR,
+ LOGO_TYPE_ERROR,
+ MAX_LOGO_BYTES,
+ MAX_TAGLINE_LENGTH,
+ type BrandSettingsInput,
+ type BrandSettingsOutput,
+} from "@/lib/brandSettings";
+import { checkContrast, isValidHexColor } from "@/lib/contrast";
+import {
+ clearBrandSettingsRemote,
+ fetchBrandSettings,
+ saveBrandSettingsRemote,
+ uploadBrandLogo,
+} from "@/lib/branding";
+
+const EMPTY_VALUES = { logoUrl: "", accentColor: "", tagline: "" } as const;
+
+const MAX_LOGO_MB = MAX_LOGO_BYTES / (1024 * 1024);
+
+/**
+ * Account branding editor for /settings/branding.
+ *
+ * - react-hook-form + zod (brandSettingsSchema) validated on change
+ * - logo uploads are pre-validated for MIME type and the 2 MB cap BEFORE any
+ * request is made, so the server is only ever called with acceptable files
+ * - accent color previews in real time and flags colors that fail WCAG AA
+ * contrast against white both as an inline warning and as a submit blocker
+ */
+export default function BrandingForm() {
+ const [address, setAddress] = useState
(null);
+ const [loading, setLoading] = useState(true);
+ const [feedback, setFeedback] = useState<{ kind: "success" | "error"; text: string } | null>(null);
+ const [logoError, setLogoError] = useState(null);
+ const [logoWarning, setLogoWarning] = useState(null);
+ const [logoUploading, setLogoUploading] = useState(false);
+ const [removing, setRemoving] = useState(false);
+
+ const {
+ register,
+ handleSubmit,
+ reset,
+ setValue,
+ watch,
+ formState: { errors, isSubmitting, isDirty },
+ } = useForm({
+ resolver: zodResolver(brandSettingsSchema),
+ mode: "onChange",
+ defaultValues: { ...EMPTY_VALUES },
+ });
+
+ useEffect(() => {
+ let cancelled = false;
+ getFreighterPublicKey()
+ .then(async (key) => {
+ if (cancelled) return;
+ setAddress(key);
+ const settings = await fetchBrandSettings(key);
+ if (cancelled) return;
+ reset({
+ logoUrl: settings.logoUrl ?? "",
+ accentColor: settings.accentColor ?? "",
+ tagline: settings.tagline ?? "",
+ });
+ })
+ .catch(() => {
+ // wallet not connected — the form stays disabled with guidance
+ })
+ .finally(() => {
+ if (!cancelled) setLoading(false);
+ });
+ return () => {
+ cancelled = true;
+ };
+ }, [reset]);
+
+ const logoUrl = watch("logoUrl") ?? "";
+ const accentColor = watch("accentColor") ?? "";
+ const tagline = watch("tagline") ?? "";
+
+ // Real-time contrast feedback: warn inline as soon as the typed/picked
+ // color fails WCAG AA against white — before the user even hits save.
+ const liveContrast =
+ accentColor && isValidHexColor(accentColor) ? checkContrast(accentColor, "#ffffff") : null;
+ const previewAccent =
+ accentColor && isValidHexColor(accentColor) ? accentColor : DEFAULT_ACCENT_COLOR;
+
+ const handleLogoSelected = useCallback(
+ async (event: React.ChangeEvent) => {
+ const file = event.target.files?.[0];
+ // Reset the input so re-selecting the same file re-triggers onChange.
+ event.target.value = "";
+ if (!file || !address) return;
+
+ setLogoError(null);
+ setLogoWarning(null);
+ setFeedback(null);
+
+ // Client-side pre-validation with specific messages — invalid files are
+ // rejected here and never reach the network.
+ if (!isAllowedLogoMimeType(file.type)) {
+ setLogoError(LOGO_TYPE_ERROR);
+ return;
+ }
+ if (!isLogoSizeOk(file.size)) {
+ setLogoError(LOGO_SIZE_ERROR);
+ return;
+ }
+
+ setLogoUploading(true);
+ try {
+ const result = await uploadBrandLogo(address, file);
+ setValue("logoUrl", result.logoUrl, { shouldDirty: true, shouldValidate: true });
+ setLogoWarning(result.warning);
+ } catch (err) {
+ setLogoError(err instanceof Error ? err.message : "Logo upload failed");
+ } finally {
+ setLogoUploading(false);
+ }
+ },
+ [address, setValue],
+ );
+
+ const onSubmit = handleSubmit(async (data: BrandSettingsOutput) => {
+ if (!address) return;
+ setFeedback(null);
+ try {
+ const saved = await saveBrandSettingsRemote(address, {
+ logoUrl: data.logoUrl ?? null,
+ accentColor: data.accentColor ?? null,
+ tagline: data.tagline ?? null,
+ });
+ reset({
+ logoUrl: saved.logoUrl ?? "",
+ accentColor: saved.accentColor ?? "",
+ tagline: saved.tagline ?? "",
+ });
+ setFeedback({ kind: "success", text: "Branding saved — it now applies to all of your invoices." });
+ } catch (err) {
+ setFeedback({ kind: "error", text: err instanceof Error ? err.message : "Could not save branding" });
+ }
+ });
+
+ const handleRemoveBranding = useCallback(async () => {
+ if (!address) return;
+ setRemoving(true);
+ setFeedback(null);
+ try {
+ await clearBrandSettingsRemote(address);
+ reset({ ...EMPTY_VALUES });
+ setLogoError(null);
+ setLogoWarning(null);
+ setFeedback({ kind: "success", text: "Branding removed — invoices revert to platform-default styling." });
+ } catch (err) {
+ setFeedback({ kind: "error", text: err instanceof Error ? err.message : "Could not remove branding" });
+ } finally {
+ setRemoving(false);
+ }
+ }, [address, reset]);
+
+ if (loading) {
+ return (
+
+ Loading your branding settings…
+
+ );
+ }
+
+ if (!address) {
+ return (
+
+ Connect your Freighter wallet to manage the branding for your account.
+
+ );
+ }
+
+ return (
+
+ );
+}
diff --git a/src/emails/PaymentReceiptEmail.tsx b/src/emails/PaymentReceiptEmail.tsx
index a5d0930..34e05fe 100644
--- a/src/emails/PaymentReceiptEmail.tsx
+++ b/src/emails/PaymentReceiptEmail.tsx
@@ -64,7 +64,7 @@ export default function PaymentReceiptEmail({
- We're confirming that we've received your payment for Invoice #{invoice.id}. Thank you!
+ We're confirming that we've received your payment for Invoice #{invoice.id}. Thank you!
{/* Payment Summary Box */}
diff --git a/src/hooks/useAddressLabel.ts b/src/hooks/useAddressLabel.ts
index 1ed87fc..bbb7e23 100644
--- a/src/hooks/useAddressLabel.ts
+++ b/src/hooks/useAddressLabel.ts
@@ -15,8 +15,8 @@ export async function resolveAddressLabel(address: string): Promise 0) {
diff --git a/src/hooks/useAddressValidation.ts b/src/hooks/useAddressValidation.ts
index 65a15e7..9296d1d 100644
--- a/src/hooks/useAddressValidation.ts
+++ b/src/hooks/useAddressValidation.ts
@@ -98,10 +98,10 @@ export function useAddressValidation() {
// Try to extract memo info from federation resolution
try {
- const { FederationServer } = await import('@stellar/stellar-sdk');
- const federationResult = await FederationServer.resolveAddress(address);
- if (federationResult.memo_id) {
- federationMemoId = federationResult.memo_id;
+ const { Federation } = await import('@stellar/stellar-sdk');
+ const federationResult = await Federation.Server.resolve(address);
+ if (federationResult.memo) {
+ federationMemoId = federationResult.memo;
}
if (federationResult.memo_type) {
federationMemoType = federationResult.memo_type;
diff --git a/src/hooks/useFeeEstimate.ts b/src/hooks/useFeeEstimate.ts
new file mode 100644
index 0000000..69d6fe6
--- /dev/null
+++ b/src/hooks/useFeeEstimate.ts
@@ -0,0 +1,120 @@
+"use client";
+
+import { useEffect, useRef, useState } from "react";
+
+/** Stellar network base fee used when fee stats cannot be loaded (stroops). */
+export const FALLBACK_BASE_FEE = 100;
+
+/** How often fee stats are refreshed while the hook is mounted. */
+export const FEE_POLL_MS = 10_000;
+
+export interface UseFeeEstimateResult {
+ /** Current ledger base fee, in stroops. */
+ baseFee?: number;
+ /** Median accepted fee (feeCharged.mode / modeAcceptanceRate), in stroops. */
+ medianFee?: number;
+ /** 90th percentile accepted fee, in stroops. */
+ p90Fee?: number;
+ loading: boolean;
+ error: string | null;
+}
+
+interface ParsedFeeStats {
+ baseFee: number;
+ medianFee: number;
+ p90Fee: number;
+}
+
+function toNumber(value: unknown, fallback: number): number {
+ const n = Number(value);
+ return Number.isFinite(n) && n > 0 ? n : fallback;
+}
+
+/**
+ * Normalizes both Horizon fee-stats shapes:
+ * legacy: { baseFee, modeAcceptanceRate, p10..p99AcceptanceRate }
+ * modern: { lastLedgerBaseFee, feeCharged: { mode, p10..p99 } }
+ */
+export function parseFeeStats(stats: {
+ baseFee?: string | number;
+ lastLedgerBaseFee?: string | number;
+ modeAcceptanceRate?: string | number;
+ p90AcceptanceRate?: string | number;
+ feeCharged?: { mode?: string | number; p90?: string | number };
+} | null | undefined): ParsedFeeStats {
+ const baseFee = toNumber(stats?.lastLedgerBaseFee ?? stats?.baseFee, FALLBACK_BASE_FEE);
+ const medianFee = toNumber(
+ stats?.feeCharged?.mode ?? stats?.modeAcceptanceRate,
+ baseFee,
+ );
+ const p90Fee = toNumber(
+ stats?.feeCharged?.p90 ?? stats?.p90AcceptanceRate,
+ medianFee,
+ );
+ return { baseFee, medianFee, p90Fee };
+}
+
+const HORIZON_URL =
+ process.env.NEXT_PUBLIC_HORIZON_URL ?? "https://horizon-testnet.stellar.org";
+
+/**
+ * Polls Horizon fee stats and exposes economy/standard/priority fee anchors.
+ *
+ * Always returns values in stroops; falls back to the 100-stroop base fee
+ * when the network is unreachable.
+ */
+export function useFeeEstimate(): UseFeeEstimateResult {
+ const [state, setState] = useState<{
+ baseFee?: number;
+ medianFee?: number;
+ p90Fee?: number;
+ error: string | null;
+ }>({ error: null });
+ const [loading, setLoading] = useState(true);
+ const mountedRef = useRef(true);
+
+ useEffect(() => {
+ mountedRef.current = true;
+
+ const fetchStats = async () => {
+ try {
+ // Horizon.Server is available from the top-level SDK export; access
+ // dynamically so environments without Horizon URLs degrade to the
+ // fallback fee instead of failing to bundle.
+ const sdk: any = await import("@stellar/stellar-sdk");
+ const ServerCtor = sdk.Server ?? sdk.Horizon?.Server;
+ const server = new ServerCtor(HORIZON_URL);
+ const stats = await server.feeStats();
+ if (!mountedRef.current) return;
+ const parsed = parseFeeStats(stats ?? null);
+ setState({ ...parsed, error: null });
+ } catch (err) {
+ if (!mountedRef.current) return;
+ setState((prev) => ({
+ ...prev,
+ error: err instanceof Error ? err.message : String(err),
+ }));
+ } finally {
+ if (mountedRef.current) setLoading(false);
+ }
+ };
+
+ fetchStats();
+ const interval = setInterval(fetchStats, FEE_POLL_MS);
+
+ return () => {
+ mountedRef.current = false;
+ clearInterval(interval);
+ };
+ }, []);
+
+ return {
+ baseFee: state.baseFee,
+ medianFee: state.medianFee,
+ p90Fee: state.p90Fee,
+ loading,
+ error: state.error,
+ };
+}
+
+export default useFeeEstimate;
diff --git a/src/hooks/useInvoiceStream.ts b/src/hooks/useInvoiceStream.ts
index 76d0403..0d72ea8 100644
--- a/src/hooks/useInvoiceStream.ts
+++ b/src/hooks/useInvoiceStream.ts
@@ -92,7 +92,7 @@ export function useInvoiceStream(invoiceId: string): UseInvoiceStreamResult {
const contractId = process.env.NEXT_PUBLIC_CONTRACT_ID ?? '';
if (!contractId) return;
- const response = await server.getEvents({
+ const params: any = {
filters: [
{
type: 'contract' as any,
@@ -105,17 +105,23 @@ export function useInvoiceStream(invoiceId: string): UseInvoiceStreamResult {
],
},
],
- cursor: lastEventCursorRef.current ?? undefined,
limit: 10,
- });
+ };
+ // GetEventsRequest is a discriminated union: pass `cursor` only when set.
+ if (lastEventCursorRef.current) {
+ params.cursor = lastEventCursorRef.current;
+ }
+ const response = await server.getEvents(params);
if (!mountedRef.current) return;
if (response.events && response.events.length > 0) {
for (const event of response.events) {
- // Update cursor to latest event
- if (event.pagingToken) {
- lastEventCursorRef.current = event.pagingToken;
+ // Update cursor to latest event (`pagingToken` is present on live
+ // events at runtime but missing from the SDK union type).
+ const pagingToken = (event as unknown as { pagingToken?: string }).pagingToken;
+ if (pagingToken) {
+ lastEventCursorRef.current = pagingToken;
}
// Parse event topics to determine event type
diff --git a/src/hooks/usePaymentVelocity.ts b/src/hooks/usePaymentVelocity.ts
new file mode 100644
index 0000000..7220577
--- /dev/null
+++ b/src/hooks/usePaymentVelocity.ts
@@ -0,0 +1,208 @@
+"use client";
+
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+
+/** Rolling windows tracked by the velocity gauge. */
+export type VelocityWindow = "1h" | "24h" | "7d";
+
+export const VELOCITY_WINDOWS: VelocityWindow[] = ["1h", "24h", "7d"];
+
+const WINDOW_MS: Record = {
+ "1h": 60 * 60 * 1000,
+ "24h": 24 * 60 * 60 * 1000,
+ "7d": 7 * 24 * 60 * 60 * 1000,
+};
+
+/** localStorage key for user-configured thresholds. */
+export const VELOCITY_THRESHOLDS_KEY = "stellarsplit:velocityThresholds";
+
+/** Default per-window thresholds (USDC). */
+export const DEFAULT_THRESHOLDS: Record = {
+ "1h": 1000,
+ "24h": 10000,
+ "7d": 50000,
+};
+
+/** How often velocity data is re-fetched. */
+export const VELOCITY_POLL_MS = 30_000;
+
+export interface VelocityStat {
+ volume: number;
+ threshold: number;
+}
+
+export interface PaymentVelocityAlert {
+ window: VelocityWindow;
+ volume: number;
+ threshold: number;
+}
+
+export interface UsePaymentVelocityResult {
+ velocities: Record | undefined;
+ lastUpdated: Date | undefined;
+ loading: boolean;
+ error: Error | null;
+ /** Current thresholds (from localStorage, else defaults). */
+ thresholds: Record;
+ /** Persist a new threshold for one window. */
+ setThreshold: (window: VelocityWindow, value: number) => void;
+ /** Refetch immediately. */
+ refresh: () => void;
+}
+
+interface HorizonPaymentRecord {
+ type?: string;
+ from?: string;
+ amount?: string;
+ created_at?: string;
+}
+
+function readThresholds(): Record {
+ if (typeof window === "undefined") return { ...DEFAULT_THRESHOLDS };
+ try {
+ const raw = window.localStorage.getItem(VELOCITY_THRESHOLDS_KEY);
+ if (!raw) return { ...DEFAULT_THRESHOLDS };
+ const parsed = JSON.parse(raw) as Partial>;
+ return {
+ "1h": typeof parsed["1h"] === "number" ? parsed["1h"] : DEFAULT_THRESHOLDS["1h"],
+ "24h": typeof parsed["24h"] === "number" ? parsed["24h"] : DEFAULT_THRESHOLDS["24h"],
+ "7d": typeof parsed["7d"] === "number" ? parsed["7d"] : DEFAULT_THRESHOLDS["7d"],
+ };
+ } catch {
+ return { ...DEFAULT_THRESHOLDS };
+ }
+}
+
+const HORIZON_URL =
+ process.env.NEXT_PUBLIC_HORIZON_URL ?? "https://horizon-testnet.stellar.org";
+
+async function fetchOutgoingPayments(account: string): Promise {
+ const sdk: any = await import("@stellar/stellar-sdk");
+ const ServerCtor = sdk.Server ?? sdk.Horizon?.Server;
+ const server = new ServerCtor(HORIZON_URL);
+ const page = await server
+ .payments()
+ .forAccount(account)
+ .order("desc")
+ .limit(200)
+ .call();
+ const records: HorizonPaymentRecord[] = page?.records ?? [];
+ // Outgoing payment operations only, in USDC-equivalent units.
+ return records.filter((r) => r.type === "payment" && r.from === account);
+}
+
+function computeVelocities(
+ records: HorizonPaymentRecord[],
+ thresholds: Record,
+ now = Date.now(),
+): Record {
+ const parsed = records
+ .map((r) => ({
+ amount: Number(r.amount ?? 0),
+ time: r.created_at ? new Date(r.created_at).getTime() : NaN,
+ }))
+ .filter((p) => Number.isFinite(p.amount) && Number.isFinite(p.time));
+
+ const sum = (window: VelocityWindow) =>
+ parsed
+ .filter((p) => p.time > now - WINDOW_MS[window])
+ .reduce((acc, p) => acc + p.amount, 0);
+
+ return {
+ "1h": { volume: sum("1h"), threshold: thresholds["1h"] },
+ "24h": { volume: sum("24h"), threshold: thresholds["24h"] },
+ "7d": { volume: sum("7d"), threshold: thresholds["7d"] },
+ };
+}
+
+/**
+ * usePaymentVelocity (#408) — tracks outgoing payment volume over rolling
+ * 1h / 24h / 7d windows against configurable thresholds, refreshing every
+ * 30 seconds. Dispatches a `velocity:alert` CustomEvent whenever a window's
+ * volume crosses its threshold.
+ */
+export function usePaymentVelocity(account?: string | null): UsePaymentVelocityResult {
+ const [thresholds, setThresholds] = useState>(readThresholds);
+ const [velocities, setVelocities] = useState | undefined>(
+ undefined,
+ );
+ const [lastUpdated, setLastUpdated] = useState(undefined);
+ const [loading, setLoading] = useState(true);
+ const [error, setError] = useState(null);
+ const mountedRef = useRef(true);
+ const alertStateRef = useRef>({
+ "1h": false,
+ "24h": false,
+ "7d": false,
+ });
+
+ const refresh = useCallback(async () => {
+ if (!account) {
+ if (mountedRef.current) {
+ setVelocities(computeVelocities([], thresholds));
+ setLastUpdated(new Date());
+ setError(null);
+ setLoading(false);
+ }
+ return;
+ }
+ try {
+ const records = await fetchOutgoingPayments(account);
+ if (!mountedRef.current) return;
+ const next = computeVelocities(records, thresholds);
+ setVelocities(next);
+ setLastUpdated(new Date());
+ setError(null);
+
+ // Fire alert events on threshold crossings (rising edge per window).
+ for (const window of VELOCITY_WINDOWS) {
+ const stat = next[window];
+ const breached = stat.volume > stat.threshold;
+ if (breached && !alertStateRef.current[window] && typeof globalThis.dispatchEvent === "function") {
+ globalThis.dispatchEvent(
+ new CustomEvent("velocity:alert", {
+ detail: { window, volume: stat.volume, threshold: stat.threshold },
+ }),
+ );
+ }
+ alertStateRef.current[window] = breached;
+ }
+ } catch (err) {
+ if (!mountedRef.current) return;
+ setError(err instanceof Error ? err : new Error(String(err)));
+ } finally {
+ if (mountedRef.current) setLoading(false);
+ }
+ }, [account, thresholds]);
+
+ useEffect(() => {
+ mountedRef.current = true;
+ refresh();
+ const interval = setInterval(refresh, VELOCITY_POLL_MS);
+ return () => {
+ mountedRef.current = false;
+ clearInterval(interval);
+ };
+ }, [refresh]);
+
+ const setThreshold = useCallback((window: VelocityWindow, value: number) => {
+ setThresholds((prev) => {
+ const next = { ...prev, [window]: value };
+ try {
+ if (typeof globalThis.localStorage !== "undefined") {
+ globalThis.localStorage.setItem(VELOCITY_THRESHOLDS_KEY, JSON.stringify(next));
+ }
+ } catch {
+ // storage unavailable — thresholds just won't persist
+ }
+ return next;
+ });
+ }, []);
+
+ return useMemo(
+ () => ({ velocities, lastUpdated, loading, error, thresholds, setThreshold, refresh }),
+ [velocities, lastUpdated, loading, error, thresholds, setThreshold, refresh],
+ );
+}
+
+export default usePaymentVelocity;
diff --git a/src/lib/brandAssetStorage.ts b/src/lib/brandAssetStorage.ts
new file mode 100644
index 0000000..2c44e50
--- /dev/null
+++ b/src/lib/brandAssetStorage.ts
@@ -0,0 +1,197 @@
+import {
+ AllowedLogoMimeType,
+ LOGO_MIME_EXTENSION,
+} from "@/lib/brandSettings";
+
+/**
+ * Brand asset (logo) storage.
+ *
+ * Production: streams uploads to Vercel Blob (`access: "public"`) and returns
+ * the CDN-backed `*.public.blob.vercel-storage.com` URL. Set
+ * BLOB_READ_WRITE_TOKEN to enable.
+ *
+ * Local/dev/CI fallback: keeps bytes in a process-level store and serves
+ * them through GET /api/settings/branding/logo/[...key] with immutable,
+ * year-long cache headers, which is the same shape a CDN edge cache
+ * consumes — no external services required.
+ */
+
+export interface StoredBrandAsset {
+ bytes: Uint8Array;
+ contentType: AllowedLogoMimeType;
+ createdAt: string;
+}
+
+export interface StoreBrandAssetResult {
+ /** Public URL (CDN-backed in production) for the stored asset. */
+ url: string;
+ /** Storage key assigned to the asset. */
+ key: string;
+ /** True when the asset landed in the Vercel Blob CDN. */
+ cdn: boolean;
+ /** Detected intrinsic image size (null when headers can't be parsed). */
+ width: number | null;
+ height: number | null;
+ /** Set when the image is likely to look soft at 300 dpi print. */
+ lowResolutionWarning: string | null;
+}
+
+/** Minimum logo width recommended for crisp 300 dpi print at ~2in display. */
+export const RECOMMENDED_LOGO_WIDTH_PX = 600;
+
+// In-memory fallback asset store per server process session.
+const assetStore = new Map();
+
+/** Build the canonical public URL for a locally-stored asset key. */
+export function localAssetUrl(key: string): string {
+ return `/api/settings/branding/logo/${key}`;
+}
+
+/** Retrieve a locally-stored asset (fallback store only). */
+export function getStoredBrandAsset(key: string): StoredBrandAsset | null {
+ return assetStore.get(key) ?? null;
+}
+
+/** Keys are `branding//logo-.` — validate path segments. */
+export function isValidAssetKey(key: string): boolean {
+ const parts = key.split("/");
+ if (parts.length !== 3 || parts[0] !== "branding") return false;
+ return parts.every((p) => /^[A-Za-z0-9._-]+$/.test(p));
+}
+
+// ── Intrinsic image size parsing (no external deps) ──────────────────────────
+
+function u32be(b: Uint8Array, o: number): number {
+ return ((b[o] << 24) | (b[o + 1] << 16) | (b[o + 2] << 8) | b[o + 3]) >>> 0;
+}
+function u16be(b: Uint8Array, o: number): number {
+ return (b[o] << 8) | b[o + 1];
+}
+
+function parsePngSize(b: Uint8Array): { width: number; height: number } | null {
+ // 8-byte signature + IHDR: width (4B BE) at offset 16, height at 20
+ const sig = [0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a];
+ if (b.length < 24 || sig.some((v, i) => b[i] !== v)) return null;
+ return { width: u32be(b, 16), height: u32be(b, 20) };
+}
+
+function parseJpegSize(b: Uint8Array): { width: number; height: number } | null {
+ if (b.length < 4 || b[0] !== 0xff || b[1] !== 0xd8) return null;
+ let o = 2;
+ while (o + 9 < b.length) {
+ if (b[o] !== 0xff) { o++; continue; }
+ const marker = b[o + 1];
+ // SOF0..SOF15 (excluding DHT/DAC/RST markers) carry the frame size
+ if (marker >= 0xc0 && marker <= 0xcf && ![0xc4, 0xc8, 0xcc].includes(marker)) {
+ return { height: u16be(b, o + 5), width: u16be(b, o + 7) };
+ }
+ const segLen = u16be(b, o + 2);
+ if (segLen < 2) return null;
+ o += 2 + segLen;
+ }
+ return null;
+}
+
+function parseWebpSize(b: Uint8Array): { width: number; height: number } | null {
+ if (b.length < 30) return null;
+ const riff = String.fromCharCode(b[0], b[1], b[2], b[3]);
+ const webp = String.fromCharCode(b[8], b[9], b[10], b[11]);
+ if (riff !== "RIFF" || webp !== "WEBP") return null;
+ const chunk = String.fromCharCode(b[12], b[13], b[14], b[15]);
+ if (chunk === "VP8X") {
+ // 24-bit little-endian canvas size minus one, at offsets 24..29
+ const width = 1 + (b[24] | (b[25] << 8) | (b[26] << 16));
+ const height = 1 + (b[27] | (b[28] << 8) | (b[29] << 16));
+ return { width, height };
+ }
+ if (chunk === "VP8 " && b.length > 29) {
+ // Start code 0x9D 0x01 0x2A at 23..25, then 14-bit LE width/height
+ if (b[23] === 0x9d && b[24] === 0x01 && b[25] === 0x2a) {
+ const width = (b[26] | (b[27] << 8)) & 0x3fff;
+ const height = (b[28] | (b[29] << 8)) & 0x3fff;
+ return { width, height };
+ }
+ }
+ if (chunk === "VP8L" && b.length > 24) {
+ // Signature byte 0x2F then 14-bit LE width/height minus one
+ if (b[20] !== 0x2f) return null;
+ const bits = b[21] | (b[22] << 8) | (b[23] << 16) | (b[24] << 24);
+ const width = (bits & 0x3fff) + 1;
+ const height = ((bits >>> 14) & 0x3fff) + 1;
+ return { width, height };
+ }
+ return null;
+}
+
+/** Best-effort intrinsic size detection for PNG / JPEG / WebP buffers. */
+export function parseImageDimensions(
+ bytes: Uint8Array,
+ contentType: AllowedLogoMimeType,
+): { width: number; height: number } | null {
+ try {
+ switch (contentType) {
+ case "image/png":
+ return parsePngSize(bytes);
+ case "image/jpeg":
+ return parseJpegSize(bytes);
+ case "image/webp":
+ return parseWebpSize(bytes);
+ default:
+ return null;
+ }
+ } catch {
+ return null;
+ }
+}
+
+/**
+ * Stores a validated logo upload and returns its public (CDN-friendly) URL.
+ */
+export async function storeBrandAsset(params: {
+ address: string;
+ bytes: Uint8Array;
+ contentType: AllowedLogoMimeType;
+}): Promise {
+ const { address, bytes, contentType } = params;
+ const ext = LOGO_MIME_EXTENSION[contentType];
+ const key = `branding/${address}/logo-${Date.now()}.${ext}`;
+
+ const size = parseImageDimensions(bytes, contentType);
+ const lowResolutionWarning =
+ size && size.width < RECOMMENDED_LOGO_WIDTH_PX
+ ? `Logo is ${size.width}px wide — upload at least ${RECOMMENDED_LOGO_WIDTH_PX}px-wide art for sharp 300 dpi print.`
+ : null;
+
+ // Production path: Vercel Blob (S3-compatible object store with a CDN).
+ if (process.env.BLOB_READ_WRITE_TOKEN) {
+ const { put } = await import("@vercel/blob");
+ const blob = await put(key, Buffer.from(bytes), {
+ access: "public",
+ contentType,
+ token: process.env.BLOB_READ_WRITE_TOKEN,
+ });
+ return {
+ url: blob.url,
+ key: blob.pathname,
+ cdn: true,
+ width: size?.width ?? null,
+ height: size?.height ?? null,
+ lowResolutionWarning,
+ };
+ }
+
+ // Local/dev fallback: process-level store served via the logo GET route.
+ assetStore.set(key, {
+ bytes,
+ contentType,
+ createdAt: new Date().toISOString(),
+ });
+ return {
+ url: localAssetUrl(key),
+ key,
+ cdn: false,
+ width: size?.width ?? null,
+ height: size?.height ?? null,
+ lowResolutionWarning,
+ };
+}
diff --git a/src/lib/brandSettings.ts b/src/lib/brandSettings.ts
new file mode 100644
index 0000000..ba28645
--- /dev/null
+++ b/src/lib/brandSettings.ts
@@ -0,0 +1,119 @@
+import { z } from "zod";
+import { checkContrast, isValidHexColor, WCAG_AA_CONTRAST_RATIO } from "@/lib/contrast";
+
+/** Maximum accepted logo upload size: 2 MB. */
+export const MAX_LOGO_BYTES = 2 * 1024 * 1024;
+
+/** MIME types accepted for logo uploads. */
+export const ALLOWED_LOGO_MIME_TYPES = ["image/png", "image/jpeg", "image/webp"] as const;
+export type AllowedLogoMimeType = (typeof ALLOWED_LOGO_MIME_TYPES)[number];
+
+/** Extension mapping used when building storage keys for uploaded logos. */
+export const LOGO_MIME_EXTENSION: Record = {
+ "image/png": "png",
+ "image/jpeg": "jpg",
+ "image/webp": "webp",
+};
+
+/** Max characters for the invoice tagline. */
+export const MAX_TAGLINE_LENGTH = 120;
+
+export const LOGO_TYPE_ERROR =
+ "Unsupported file type. Upload a PNG, JPEG, or WebP image.";
+export const LOGO_SIZE_ERROR = "Logo exceeds the 2 MB size limit.";
+
+/** True when the (already-typechecked) logo fits the 2 MB cap. */
+export function isLogoSizeOk(bytes: number): boolean {
+ return bytes > 0 && bytes <= MAX_LOGO_BYTES;
+}
+
+/** True when the supplied MIME type is in the logo allow-list. */
+export function isAllowedLogoMimeType(mime: string): mime is AllowedLogoMimeType {
+ return (ALLOWED_LOGO_MIME_TYPES as readonly string[]).includes(mime);
+}
+
+/**
+ * Brand settings scoped to one user account (identified by their Stellar
+ * address). `null` means "not set — fall back to platform defaults".
+ */
+export interface BrandSettings {
+ logoUrl: string | null;
+ accentColor: string | null;
+ tagline: string | null;
+ updatedAt: string;
+}
+
+/** Platform-default branding (used when the user has not customized). */
+export const DEFAULT_BRAND_SETTINGS: Omit = {
+ logoUrl: null,
+ accentColor: null,
+ tagline: null,
+};
+
+/** Platform default accent used when no accent color is configured. */
+export const DEFAULT_ACCENT_COLOR = "#4f46e5";
+
+const hexColorSchema = z
+ .string()
+ .trim()
+ .refine(isValidHexColor, {
+ message: "Enter a valid hex color (e.g. #4f46e5)",
+ })
+ .superRefine((value, ctx) => {
+ if (!isValidHexColor(value)) return;
+ const { ratio, passes } = checkContrast(value, "#ffffff");
+ if (!passes) {
+ ctx.addIssue({
+ code: z.ZodIssueCode.custom,
+ message: `Accent color fails WCAG AA contrast against white (${ratio.toFixed(
+ 2,
+ )}:1; needs ${WCAG_AA_CONTRAST_RATIO}:1)`,
+ });
+ }
+ });
+
+/**
+ * Accepts absolute http(s) URLs (CDN-hosted logos in production) or
+ * root-relative paths (the local dev asset route, e.g.
+ * "/api/settings/branding/logo/branding//logo-1.png").
+ */
+const logoUrlSchema = z
+ .string()
+ .trim()
+ .refine(
+ (value) => value.startsWith("/") || /^https?:\/\//i.test(value),
+ { message: "Logo URL must be a valid URL" },
+ );
+
+/**
+ * Zod schema shared by the branding form (react-hook-form resolver) and the
+ * PUT /api/settings/branding route. Empty strings and null treat a field as
+ * "cleared / platform default".
+ */
+export const brandSettingsSchema = z.object({
+ logoUrl: z
+ .union([z.literal(""), logoUrlSchema])
+ .nullable()
+ .transform((v) => (v === "" ? null : v ?? null))
+ .optional(),
+ accentColor: z
+ .union([z.literal(""), hexColorSchema])
+ .nullable()
+ .transform((v) => (v === "" ? null : v ?? null))
+ .optional(),
+ tagline: z
+ .string()
+ .trim()
+ .max(MAX_TAGLINE_LENGTH, `Tagline must be ${MAX_TAGLINE_LENGTH} characters or fewer`)
+ .transform((v) => (v.length === 0 ? null : v))
+ .nullable()
+ .optional(),
+});
+
+export type BrandSettingsInput = z.input;
+export type BrandSettingsOutput = z.output;
+
+/** Basic Stellar public key sanity check (G + 55 base32 chars). */
+export function isStellarAddress(address: string): boolean {
+ return /^G[A-Z2-7]{55}$/.test(address);
+}
diff --git a/src/lib/brandSettingsStore.ts b/src/lib/brandSettingsStore.ts
new file mode 100644
index 0000000..e5ebb2f
--- /dev/null
+++ b/src/lib/brandSettingsStore.ts
@@ -0,0 +1,65 @@
+import {
+ BrandSettings,
+ DEFAULT_BRAND_SETTINGS,
+} from "@/lib/brandSettings";
+
+/**
+ * Server-side store for per-account brand settings, keyed by Stellar
+ * address. Follows the same in-memory pattern as serverAddressBook.ts — the
+ * module-level map persists for the lifetime of the server process and is
+ * shared by the branding API routes.
+ */
+
+// In-memory store per server process session, keyed by Stellar address.
+const brandStore = new Map();
+
+function normalizeAddress(address: string): string {
+ return address.trim();
+}
+
+/**
+ * Returns the brand settings for an account, or platform defaults when the
+ * account has never saved any.
+ */
+export function getBrandSettings(address: string): BrandSettings {
+ const key = normalizeAddress(address);
+ return (
+ brandStore.get(key) ?? {
+ ...DEFAULT_BRAND_SETTINGS,
+ updatedAt: "",
+ }
+ );
+}
+
+/**
+ * True when the account has an explicitly-saved settings record.
+ */
+export function hasBrandSettings(address: string): boolean {
+ return brandStore.has(normalizeAddress(address));
+}
+
+/**
+ * Saves brand settings for an account, replacing any previous record.
+ */
+export function saveBrandSettings(
+ address: string,
+ settings: { logoUrl: string | null; accentColor: string | null; tagline: string | null },
+): BrandSettings {
+ const key = normalizeAddress(address);
+ const record: BrandSettings = {
+ logoUrl: settings.logoUrl,
+ accentColor: settings.accentColor,
+ tagline: settings.tagline,
+ updatedAt: new Date().toISOString(),
+ };
+ brandStore.set(key, record);
+ return record;
+}
+
+/**
+ * Removes any stored branding for an account, reverting its invoices to
+ * platform-default styling. Returns true when a record existed.
+ */
+export function clearBrandSettings(address: string): boolean {
+ return brandStore.delete(normalizeAddress(address));
+}
diff --git a/src/lib/branding.ts b/src/lib/branding.ts
new file mode 100644
index 0000000..f8ce79f
--- /dev/null
+++ b/src/lib/branding.ts
@@ -0,0 +1,121 @@
+import type { BrandSettings } from "@/lib/brandSettings";
+import { DEFAULT_BRAND_SETTINGS } from "@/lib/brandSettings";
+
+/**
+ * Client helpers for account branding: fetch/save/clear through the settings
+ * API with a localStorage mirror so invoices paint instantly on repeat views
+ * and stay branded when the dev server restarts.
+ */
+
+const cacheKey = (address: string) => `stellarsplit:branding:${address}`;
+
+function readCache(address: string): BrandSettings | null {
+ if (typeof window === "undefined") return null;
+ try {
+ const raw = window.localStorage.getItem(cacheKey(address));
+ if (!raw) return null;
+ const parsed = JSON.parse(raw);
+ if (parsed && typeof parsed === "object") {
+ return {
+ logoUrl: parsed.logoUrl ?? null,
+ accentColor: parsed.accentColor ?? null,
+ tagline: parsed.tagline ?? null,
+ updatedAt: parsed.updatedAt ?? "",
+ };
+ }
+ } catch {
+ // malformed cache — ignore
+ }
+ return null;
+}
+
+function writeCache(address: string, settings: BrandSettings): void {
+ if (typeof window === "undefined") return;
+ try {
+ window.localStorage.setItem(cacheKey(address), JSON.stringify(settings));
+ } catch {
+ // storage unavailable — server record still persists
+ }
+}
+
+function clearCache(address: string): void {
+ if (typeof window === "undefined") return;
+ try {
+ window.localStorage.removeItem(cacheKey(address));
+ } catch {
+ // ignore
+ }
+}
+
+/**
+ * Fetches the brand settings for an account. Falls back to the localStorage
+ * mirror when the network call fails, and finally to platform defaults.
+ */
+export async function fetchBrandSettings(address: string): Promise {
+ try {
+ const res = await fetch(`/api/settings/branding?address=${encodeURIComponent(address)}`);
+ if (!res.ok) throw new Error(`HTTP ${res.status}`);
+ const settings = (await res.json()) as BrandSettings;
+ writeCache(address, settings);
+ return settings;
+ } catch {
+ return (
+ readCache(address) ?? { ...DEFAULT_BRAND_SETTINGS, updatedAt: "" }
+ );
+ }
+}
+
+/** Persists brand settings for an account via the settings API. */
+export async function saveBrandSettingsRemote(
+ address: string,
+ settings: { logoUrl: string | null; accentColor: string | null; tagline: string | null },
+): Promise {
+ const res = await fetch("/api/settings/branding", {
+ method: "PUT",
+ headers: { "Content-Type": "application/json" },
+ body: JSON.stringify({ address, ...settings }),
+ });
+ const data = await res.json().catch(() => ({}));
+ if (!res.ok) {
+ throw new Error(typeof data?.error === "string" ? data.error : "Could not save branding");
+ }
+ writeCache(address, data as BrandSettings);
+ return data as BrandSettings;
+}
+
+/** Clears brand settings for an account (invoice styling reverts to default). */
+export async function clearBrandSettingsRemote(address: string): Promise {
+ const res = await fetch("/api/settings/branding", {
+ method: "DELETE",
+ headers: { "Content-Type": "application/json" },
+ body: JSON.stringify({ address }),
+ });
+ if (!res.ok) {
+ const data = await res.json().catch(() => ({}));
+ throw new Error(typeof data?.error === "string" ? data.error : "Could not clear branding");
+ }
+ clearCache(address);
+}
+
+/**
+ * Uploads a logo file for an account; returns the assigned URL. Client-side
+ * pre-validation in BrandingForm means the server should only fail this
+ * request for genuine transport/storage errors.
+ */
+export async function uploadBrandLogo(
+ address: string,
+ file: File,
+): Promise<{ logoUrl: string; width: number | null; height: number | null; warning: string | null; cdn: boolean }> {
+ const form = new FormData();
+ form.append("file", file);
+ form.append("address", address);
+ const res = await fetch("/api/settings/branding/logo", {
+ method: "POST",
+ body: form,
+ });
+ const data = await res.json().catch(() => ({}));
+ if (!res.ok) {
+ throw new Error(typeof data?.error === "string" ? data.error : "Logo upload failed");
+ }
+ return data;
+}
diff --git a/src/lib/contrast.ts b/src/lib/contrast.ts
new file mode 100644
index 0000000..2e811a4
--- /dev/null
+++ b/src/lib/contrast.ts
@@ -0,0 +1,94 @@
+/**
+ * WCAG 2.1 relative-luminance / contrast-ratio utilities.
+ * Used to validate brand accent colors against invoice backgrounds.
+ */
+
+/** Minimum contrast ratio required by WCAG AA for normal text. */
+export const WCAG_AA_CONTRAST_RATIO = 4.5;
+
+export interface RgbColor {
+ r: number;
+ g: number;
+ b: number;
+}
+
+/**
+ * Parses a hex color string ("#RGB" or "#RRGGBB", case-insensitive, "#"
+ * optional) into an RGB tuple. Returns null for anything else.
+ */
+export function hexToRgb(hex: string): RgbColor | null {
+ const trimmed = hex.trim().replace(/^#/, "");
+ if (!/^[0-9a-fA-F]{3}$/.test(trimmed) && !/^[0-9a-fA-F]{6}$/.test(trimmed)) {
+ return null;
+ }
+ const normalized =
+ trimmed.length === 3
+ ? trimmed
+ .split("")
+ .map((c) => c + c)
+ .join("")
+ : trimmed;
+ const int = parseInt(normalized, 16);
+ return {
+ r: (int >> 16) & 0xff,
+ g: (int >> 8) & 0xff,
+ b: int & 0xff,
+ };
+}
+
+/** True when the string is a well-formed hex color (#RGB / #RRGGBB). */
+export function isValidHexColor(hex: string): boolean {
+ return hexToRgb(hex) !== null;
+}
+
+function channelLuminance(channel: number): number {
+ const c = channel / 255;
+ return c <= 0.03928 ? c / 12.92 : Math.pow((c + 0.055) / 1.055, 2.4);
+}
+
+/** WCAG 2.1 relative luminance (0 = black, 1 = white). */
+export function relativeLuminance(hex: string): number {
+ const rgb = hexToRgb(hex);
+ if (!rgb) {
+ throw new Error(`Invalid hex color: ${hex}`);
+ }
+ return (
+ 0.2126 * channelLuminance(rgb.r) +
+ 0.7152 * channelLuminance(rgb.g) +
+ 0.0722 * channelLuminance(rgb.b)
+ );
+}
+
+/**
+ * WCAG 2.1 contrast ratio between two hex colors (1..21).
+ * Accepts colors in any order — the lighter one is luminance-maximized.
+ */
+export function contrastRatio(hexA: string, hexB: string): number {
+ const lumA = relativeLuminance(hexA);
+ const lumB = relativeLuminance(hexB);
+ const lighter = Math.max(lumA, lumB);
+ const darker = Math.min(lumA, lumB);
+ return (lighter + 0.05) / (darker + 0.05);
+}
+
+/**
+ * Returns an object describing whether `hex` meets WCAG AA contrast (4.5:1)
+ * for text rendered in `hex` over a `background` background (default white,
+ * which is what the invoice PDF / print view uses).
+ */
+export function checkContrast(
+ hex: string,
+ background = "#ffffff",
+): { ratio: number; passes: boolean } {
+ const ratio = contrastRatio(hex, background);
+ return { ratio, passes: ratio >= WCAG_AA_CONTRAST_RATIO };
+}
+
+/** Convenience boolean: does this color pass WCAG AA against white? */
+export function meetsWcagAaAgainstWhite(hex: string): boolean {
+ try {
+ return checkContrast(hex, "#ffffff").passes;
+ } catch {
+ return false;
+ }
+}
diff --git a/src/lib/dashboardFilters.ts b/src/lib/dashboardFilters.ts
index d4e1964..9304af4 100644
--- a/src/lib/dashboardFilters.ts
+++ b/src/lib/dashboardFilters.ts
@@ -1,5 +1,8 @@
import type { Invoice } from "@stellar-split/sdk";
+/** Dashboard view model for an invoice. Currently a direct alias of the SDK type. */
+export type DashboardInvoice = Invoice;
+
export type DashboardPresetId = "all" | "active" | "funded" | "refunded" | "expired" | "draft" | "overdue";
export type DashboardSortId = "newest" | "oldest" | "amount-desc" | "amount-asc" | "deadline";
@@ -157,18 +160,15 @@ export function filterDashboardInvoices(
invoices: Invoice[],
preset: DashboardPresetId,
now = Math.floor(Date.now() / 1000),
- selectedStatuses: InvoiceStatusFilter[] = [],
-): DashboardInvoice[] {
- return invoices.filter((invoice) => {
- const matchesPreset = matchesDashboardPreset(invoice, publicKey, preset, now);
- const matchesQuery = matchesTextSearch(invoice, query);
- const matchesStatus = matchesStatusFilter(invoice, selectedStatuses, now);
- return matchesPreset && matchesQuery && matchesStatus;
- });
splitMetaMap?: Record,
+ selectedStatuses: InvoiceStatusFilter[] = [],
+ query = "",
): Invoice[] {
- return invoices.filter((invoice) =>
- matchesDashboardPreset(invoice, preset, now, splitMetaMap?.[invoice.id]),
+ return invoices.filter(
+ (invoice) =>
+ matchesDashboardPreset(invoice, preset, now, splitMetaMap?.[invoice.id]) &&
+ matchesStatusFilter(invoice, selectedStatuses, now) &&
+ matchesTextSearch(invoice, query),
);
}
diff --git a/src/lib/fraudRiskScorer.ts b/src/lib/fraudRiskScorer.ts
index 26f45e4..ba99ce2 100644
--- a/src/lib/fraudRiskScorer.ts
+++ b/src/lib/fraudRiskScorer.ts
@@ -58,7 +58,11 @@ export function calculateFraudRiskScore(
(f) => f.type === AnomalyType.RAPID_SUCCESSION,
).length;
if (rapidCount > 0) {
- const contribution = Math.min(rapidCount * 15, WEIGHTS.RAPID_SUCCESSION);
+ // Each rapid-succession flag carries the full signal weight (capped).
+ const contribution = Math.min(
+ rapidCount * WEIGHTS.RAPID_SUCCESSION,
+ WEIGHTS.RAPID_SUCCESSION,
+ );
signals.push({
signal: "rapid_succession",
weight: WEIGHTS.RAPID_SUCCESSION,
@@ -73,8 +77,9 @@ export function calculateFraudRiskScore(
(f) => f.type === AnomalyType.FIRST_TIME_LARGE,
).length;
if (firstTimeLargeCount > 0) {
+ // Each first-time large-payer flag carries the full signal weight (capped).
const contribution = Math.min(
- firstTimeLargeCount * 20,
+ firstTimeLargeCount * WEIGHTS.FIRST_TIME_LARGE,
WEIGHTS.FIRST_TIME_LARGE,
);
signals.push({
@@ -94,7 +99,7 @@ export function calculateFraudRiskScore(
if (invoiceTotal > 1_000_000n) {
// Large invoice threshold (>1M stroops)
const contribution = Math.min(
- (Number(invoiceTotal) / 1_000_000n) * 5,
+ (Number(invoiceTotal) / 1_000_000) * 5,
WEIGHTS.LARGE_AMOUNT,
);
signals.push({
diff --git a/src/lib/invoiceExcelExport.ts b/src/lib/invoiceExcelExport.ts
index 25695a3..c396d48 100644
--- a/src/lib/invoiceExcelExport.ts
+++ b/src/lib/invoiceExcelExport.ts
@@ -93,15 +93,18 @@ export function transactionsToExportRows(invoices: Invoice[]): TransactionExport
for (const invoice of invoices) {
for (const payment of invoice.payments) {
+ // `timestamp` is set at runtime by the indexer but is not part of the
+ // published SDK Payment type — read it defensively.
+ const timestamp = (payment as { timestamp?: number }).timestamp;
rows.push({
invoiceId: invoice.id,
payer: payment.payer,
amount: formatAmount(payment.amount),
- timestamp: payment.timestamp
+ timestamp: timestamp
? new Date(
- payment.timestamp < 10000000000
- ? payment.timestamp * 1000
- : payment.timestamp
+ timestamp < 10000000000
+ ? timestamp * 1000
+ : timestamp
).toISOString()
: 'Unknown',
txHash: (payment as any).txHash || '',
@@ -248,7 +251,7 @@ export function downloadExcel(
): void {
if (typeof window === 'undefined') return;
- const blob = new Blob([data], {
+ const blob = new Blob([data as unknown as BlobPart], {
type: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
});
const url = URL.createObjectURL(blob);
diff --git a/src/lib/securitySettings.ts b/src/lib/securitySettings.ts
index e441d7c..cf3197f 100644
--- a/src/lib/securitySettings.ts
+++ b/src/lib/securitySettings.ts
@@ -1,5 +1,5 @@
import { createCipheriv, createDecipheriv, createHash, randomBytes } from "crypto";
-import { authenticator } from "otplib";
+import { generateSecret, generateURI, verifySync } from "otplib";
import QRCode from "qrcode";
export interface SecuritySettings {
@@ -84,8 +84,8 @@ export function getSecuritySettings(userId: string): SecuritySettings {
}
export async function beginMfaEnrollment(userId: string) {
- const secret = authenticator.generateSecret();
- const otpauthUrl = authenticator.keyuri(userId, "Stellar Split", secret);
+ const secret = generateSecret();
+ const otpauthUrl = generateURI({ issuer: "Stellar Split", label: userId, secret });
const qrCodeDataUrl = await QRCode.toDataURL(otpauthUrl);
PENDING_ENROLLMENTS.set(userId, {
@@ -113,7 +113,7 @@ export function confirmMfaEnrollment(userId: string, code: string) {
return { success: false, error: "Enrollment expired. Start again." };
}
- const isValid = authenticator.check(code, pending.secret);
+ const isValid = verifySync({ secret: pending.secret, token: code }).valid;
if (!isValid) {
return { success: false, error: "The verification code was invalid." };
}
@@ -138,7 +138,7 @@ export function disableMfa(userId: string, code: string) {
}
const secret = decryptSecret(settings.encryptedSecret);
- const isValid = authenticator.check(code, secret);
+ const isValid = verifySync({ secret: secret, token: code }).valid;
if (!isValid) {
return { success: false, error: "The verification code was invalid." };
}
@@ -175,7 +175,7 @@ export function verifyMfaCode(userId: string, code: string) {
try {
const secret = decryptSecret(settings.encryptedSecret);
- const isValid = authenticator.check(code, secret);
+ const isValid = verifySync({ secret: secret, token: code }).valid;
if (!isValid) {
const nextAttempts = (settings.failedAttempts || 0) + 1;
const lockedUntil = nextAttempts >= MAX_FAILURES ? now + LOCKOUT_MS : undefined;
diff --git a/src/lib/stellar.ts b/src/lib/stellar.ts
index 4e9a04d..1da42f5 100644
--- a/src/lib/stellar.ts
+++ b/src/lib/stellar.ts
@@ -161,20 +161,31 @@ export async function payMilestone(params: {
milestoneId: string;
}): Promise<{ txHash: string }> {
const client = getSplitClient();
- const { TransactionBuilder, Networks, BASE_FEE, Memo, nativeToScVal, SorobanRpc } = await import("@stellar/stellar-sdk");
+ const { TransactionBuilder, BASE_FEE, Memo, nativeToScVal, rpc } = await import("@stellar/stellar-sdk");
const { signWithFreighter } = await import("./freighter");
+ // The published @stellar-split/sdk keeps `contract`, `server` and `config`
+ // as private fields with no public accessors. Milestone payments need a
+ // custom memo, which the SDK's typed API does not support, so we reach the
+ // underlying internals here (object properties — still accessible at
+ // runtime despite the `private` TypeScript modifier).
+ const internals = client as unknown as {
+ contract: { call: (...args: any[]) => any };
+ server: any;
+ config: { networkPassphrase: string };
+ };
+
const memoText = `INV:${params.invoiceId}:M:${params.milestoneId}`.slice(0, 28);
- const operation = client.contract.call(
+ const operation = internals.contract.call(
"pay",
nativeToScVal(params.payer, { type: "address" }),
nativeToScVal(BigInt(params.invoiceId), { type: "u64" }),
nativeToScVal(params.amount, { type: "i128" })
);
- const sourceAccount = await client.server.getAccount(params.payer);
- const networkPassphrase = client.config.networkPassphrase;
+ const sourceAccount = await internals.server.getAccount(params.payer);
+ const networkPassphrase = internals.config.networkPassphrase;
const tx = new TransactionBuilder(sourceAccount, {
fee: BASE_FEE,
@@ -185,29 +196,29 @@ export async function payMilestone(params: {
.setTimeout(30)
.build();
- const simResult = await client.server.simulateTransaction(tx);
- if (SorobanRpc.Api.isSimulationError(simResult)) {
+ const simResult = await internals.server.simulateTransaction(tx);
+ if (rpc.Api.isSimulationError(simResult)) {
throw new Error(`Simulation failed: ${simResult.error}`);
}
- const preparedTx = SorobanRpc.assembleTransaction(tx, simResult).build();
- const signedXdr = await signWithFreighter(preparedTx.toXDR(), networkPassphrase);
+ const preparedTx = rpc.assembleTransaction(tx, simResult).build();
+ const signedXdr = await signWithFreighter(preparedTx.toXDR());
const signedTx = TransactionBuilder.fromXDR(signedXdr, networkPassphrase);
- const sendResult = await client.server.sendTransaction(signedTx);
+ const sendResult = await internals.server.sendTransaction(signedTx);
if (sendResult.status === "ERROR") {
throw new Error(`Transaction failed: ${JSON.stringify(sendResult.errorResult)}`);
}
- let getResult = await client.server.getTransaction(sendResult.hash);
+ let getResult = await internals.server.getTransaction(sendResult.hash);
let attempts = 0;
- while (getResult.status === SorobanRpc.Api.GetTransactionStatus.NOT_FOUND && attempts < 20) {
+ while (getResult.status === rpc.Api.GetTransactionStatus.NOT_FOUND && attempts < 20) {
await new Promise((r) => setTimeout(r, 1500));
- getResult = await client.server.getTransaction(sendResult.hash);
+ getResult = await internals.server.getTransaction(sendResult.hash);
attempts++;
}
- if (getResult.status !== SorobanRpc.Api.GetTransactionStatus.SUCCESS) {
+ if (getResult.status !== rpc.Api.GetTransactionStatus.SUCCESS) {
throw new Error(`Transaction not confirmed: ${getResult.status}`);
}
@@ -276,8 +287,8 @@ export async function fetchUsdcBalance(
*/
export async function resolveFederationAddress(federationAddress: string): Promise {
try {
- const { FederationServer } = await import("@stellar/stellar-sdk");
- const result = await FederationServer.resolveAddress(federationAddress);
+ const { Federation } = await import("@stellar/stellar-sdk");
+ const result = await Federation.Server.resolve(federationAddress);
return result.account_id;
} catch {
return null;
@@ -299,7 +310,13 @@ export async function validateFederationAddress(address: string): Promise<{
const balances = account.balances;
const isFunded = balances.length > 0;
- const requiresMemo = account.flags?.require_auth_memoized_flag || false;
+ // Horizon's standard account flags don't expose a memo-required flag in
+ // current SDK typings — some Horizon deployments include a non-standard
+ // `require_auth_memoized_flag`, so read it defensively.
+ const flags = account.flags as
+ | (typeof account.flags & { require_auth_memoized_flag?: boolean })
+ | undefined;
+ const requiresMemo = flags?.require_auth_memoized_flag || false;
return { isFunded, requiresMemo };
} catch (error) {