2569718930@qq.com
2395 lines
69 KiB
TypeScript
2395 lines
69 KiB
TypeScript
"use client";
|
|
|
|
import { useCallback, useEffect, useMemo, useState } from "react";
|
|
import type { User } from "@supabase/supabase-js";
|
|
import { getSupabaseBrowserClient } from "@/lib/supabase/client";
|
|
import {
|
|
getAllowedPaymentHosts,
|
|
getCurrentPaymentHost,
|
|
isPaymentHostAllowed,
|
|
} from "@/lib/payment-host";
|
|
import {
|
|
assertExpectedPaymentReceiver,
|
|
EXPECTED_PAYMENT_RECEIVER_ADDRESS,
|
|
} from "@/lib/payment-receiver";
|
|
import { trackAppEvent } from "@/lib/app-analytics";
|
|
|
|
import type {
|
|
AuthMeResponse,
|
|
BoundWallet,
|
|
ConnectBindOptions,
|
|
CreatedIntent,
|
|
Eip6963ProviderDetail,
|
|
EvmProvider,
|
|
InjectedProviderOption,
|
|
IntentStatusResponse,
|
|
PaymentConfig,
|
|
PaymentTokenOption,
|
|
PaymentRecoveryState,
|
|
ProviderMode,
|
|
ProviderSelection,
|
|
TelegramPricing,
|
|
} from "./types";
|
|
import {
|
|
PAYMENT_RECOVERY_STORAGE_KEY,
|
|
PAYMENT_RECOVERY_TTL_MS,
|
|
WALLETCONNECT_POLYGON_RPC_URL,
|
|
WALLET_TRANSACTION_REQUEST_TIMEOUT_MS,
|
|
} from "./constants";
|
|
import { clearStoredPaymentRecovery, shortAddress } from "./formatters";
|
|
import {
|
|
buildAllowanceCalldata,
|
|
buildApproveCalldata,
|
|
buildBalanceOfCalldata,
|
|
formatTokenUnits,
|
|
normalizePaymentError,
|
|
requestWalletWithTimeout,
|
|
} from "./payment-utils";
|
|
import { usePaymentState } from "./usePaymentState";
|
|
import {
|
|
eip6963Providers,
|
|
getEvmProvider,
|
|
getEvmWalletLabel,
|
|
getWalletConnectProvider,
|
|
isWalletConnectResetError,
|
|
listInjectedProviders,
|
|
resetWalletConnectProvider,
|
|
} from "./wallet";
|
|
|
|
// ============================================================
|
|
export interface UseAccountPaymentParams {
|
|
isEn: boolean;
|
|
supabaseReady: boolean;
|
|
walletConnectEnabled: boolean;
|
|
copy: Record<string, string>;
|
|
backend: AuthMeResponse | null;
|
|
user: User | null;
|
|
setUser: (user: User | null) => void;
|
|
setBackend: (backend: AuthMeResponse | null) => void;
|
|
setErrorText: (text: string) => void;
|
|
setUpdatedAt: (text: string) => void;
|
|
showOverlay: boolean;
|
|
setShowOverlay: (v: boolean) => void;
|
|
usePoints: boolean;
|
|
setUsePoints: (v: boolean) => void;
|
|
}
|
|
|
|
// ============================================================
|
|
export function useAccountPayment(params: UseAccountPaymentParams) {
|
|
const {
|
|
isEn,
|
|
supabaseReady,
|
|
walletConnectEnabled,
|
|
copy,
|
|
backend,
|
|
user,
|
|
setUser,
|
|
setBackend,
|
|
setErrorText,
|
|
setUpdatedAt,
|
|
showOverlay,
|
|
setShowOverlay,
|
|
usePoints,
|
|
setUsePoints,
|
|
} = params;
|
|
|
|
// ── Base payment state (from usePaymentState) ──────────────
|
|
const {
|
|
paymentBusy,
|
|
setPaymentBusy,
|
|
paymentInfo,
|
|
setPaymentInfo,
|
|
paymentError,
|
|
setPaymentError,
|
|
lastIntentId,
|
|
setLastIntentId,
|
|
lastTxHash,
|
|
setLastTxHash,
|
|
telegramBindOpening,
|
|
setTelegramBindOpening,
|
|
manualPayment,
|
|
setManualPayment,
|
|
manualTxHash,
|
|
setManualTxHash,
|
|
txValidation,
|
|
setTxValidation,
|
|
paymentMethodTab,
|
|
setPaymentMethodTab,
|
|
lastPaymentStartedAt,
|
|
setLastPaymentStartedAt,
|
|
clearPaymentMessages,
|
|
clearPaymentState,
|
|
} = usePaymentState();
|
|
|
|
// ── Additional payment/wallet state ──────────────────────
|
|
const [paymentConfig, setPaymentConfig] = useState<PaymentConfig | null>(
|
|
null,
|
|
);
|
|
const [boundWallets, setBoundWallets] = useState<BoundWallet[]>([]);
|
|
const [walletAddress, setWalletAddress] = useState("");
|
|
const [selectedPlanCode, setSelectedPlanCode] = useState("pro_monthly");
|
|
const [selectedTokenAddress, setSelectedTokenAddress] = useState("");
|
|
const [selectedWallet, setSelectedWallet] = useState("");
|
|
const [providerMode, setProviderMode] = useState<ProviderMode>("auto");
|
|
const [injectedProviderOptions, setInjectedProviderOptions] = useState<
|
|
InjectedProviderOption[]
|
|
>([]);
|
|
const [selectedInjectedProviderKey, setSelectedInjectedProviderKey] =
|
|
useState("");
|
|
const [reconcileBusy, setReconcileBusy] = useState(false);
|
|
const [telegramBindUrl, setTelegramBindUrl] = useState("");
|
|
|
|
// ── Derived values ──────────────────────────────────────
|
|
const authUserId = backend?.user_id || user?.id || "";
|
|
const authIsAuthenticated = Boolean(authUserId);
|
|
const paymentReadyForRecovery = Boolean(
|
|
paymentConfig?.enabled && paymentConfig?.configured,
|
|
);
|
|
const hasRecentPaymentRecovery =
|
|
Boolean(
|
|
lastIntentId && lastTxHash && authUserId && lastPaymentStartedAt,
|
|
) &&
|
|
Date.now() - lastPaymentStartedAt <= PAYMENT_RECOVERY_TTL_MS;
|
|
const allowedPaymentHosts = useMemo(() => getAllowedPaymentHosts(), []);
|
|
const currentPaymentHost = useMemo(() => getCurrentPaymentHost(), []);
|
|
const paymentHostAllowed = useMemo(
|
|
() => isPaymentHostAllowed(currentPaymentHost),
|
|
[currentPaymentHost],
|
|
);
|
|
|
|
// ── EIP-6963 Provider sync ──────────────────────────────
|
|
useEffect(() => {
|
|
const syncProviders = () => {
|
|
const nextOptions = listInjectedProviders();
|
|
setInjectedProviderOptions(nextOptions);
|
|
setSelectedInjectedProviderKey((current) => {
|
|
if (current && nextOptions.some((row) => row.key === current)) {
|
|
return current;
|
|
}
|
|
return nextOptions[0]?.key || "";
|
|
});
|
|
};
|
|
|
|
const handleAnnounce = (event: Event) => {
|
|
const customEvent = event as CustomEvent<Eip6963ProviderDetail>;
|
|
const detail = customEvent.detail;
|
|
if (
|
|
!detail?.provider ||
|
|
typeof detail.provider.request !== "function"
|
|
) {
|
|
return;
|
|
}
|
|
const uuid = String(detail.info?.uuid || "").trim();
|
|
const fallbackKey = `${String(detail.info?.rdns || "wallet").toLowerCase()}:${String(
|
|
detail.info?.name || "wallet",
|
|
).toLowerCase()}`;
|
|
eip6963Providers.set(uuid || fallbackKey, detail);
|
|
syncProviders();
|
|
};
|
|
|
|
syncProviders();
|
|
if (typeof window === "undefined") return;
|
|
window.addEventListener(
|
|
"eip6963:announceProvider",
|
|
handleAnnounce as EventListener,
|
|
);
|
|
window.dispatchEvent(new Event("eip6963:requestProvider"));
|
|
window.addEventListener(
|
|
"ethereum#initialized",
|
|
syncProviders as EventListener,
|
|
{ once: false },
|
|
);
|
|
return () => {
|
|
window.removeEventListener(
|
|
"eip6963:announceProvider",
|
|
handleAnnounce as EventListener,
|
|
);
|
|
window.removeEventListener(
|
|
"ethereum#initialized",
|
|
syncProviders as EventListener,
|
|
);
|
|
};
|
|
}, []);
|
|
|
|
// ── getValidAccessToken ──────────────────────────────────
|
|
const getValidAccessToken = useCallback(async (): Promise<string> => {
|
|
if (!supabaseReady)
|
|
throw new Error(
|
|
isEn
|
|
? "Supabase is not configured. Unable to get auth token."
|
|
: "Supabase 未配置，无法获取登录凭证。",
|
|
);
|
|
const client = getSupabaseBrowserClient();
|
|
const {
|
|
data: { session: cached },
|
|
} = await client.auth.getSession();
|
|
const cachedToken = String(cached?.access_token || "").trim();
|
|
const expiresAtSec = Number(cached?.expires_at || 0);
|
|
const nowSec = Math.floor(Date.now() / 1000);
|
|
const refreshLeadSec = 90;
|
|
if (
|
|
cachedToken &&
|
|
Number.isFinite(expiresAtSec) &&
|
|
expiresAtSec > nowSec + refreshLeadSec
|
|
) {
|
|
return cachedToken;
|
|
}
|
|
if (
|
|
cachedToken &&
|
|
(!Number.isFinite(expiresAtSec) || expiresAtSec <= 0)
|
|
) {
|
|
return cachedToken;
|
|
}
|
|
const {
|
|
data: { session: refreshed },
|
|
error,
|
|
} = await client.auth.refreshSession();
|
|
const refreshedToken = String(refreshed?.access_token || "").trim();
|
|
if (refreshedToken) return refreshedToken;
|
|
if (
|
|
cachedToken &&
|
|
Number.isFinite(expiresAtSec) &&
|
|
expiresAtSec > nowSec
|
|
) {
|
|
return cachedToken;
|
|
}
|
|
throw new Error(
|
|
error?.message
|
|
? isEn
|
|
? `Session expired (${error.message}). Please sign out and sign in again.`
|
|
: `登录会话已失效 (${error.message})，请退出后重新登录。`
|
|
: isEn
|
|
? "Session expired. Please sign out and sign in again."
|
|
: "登录会话已失效，请退出后重新登录。",
|
|
);
|
|
}, [isEn, supabaseReady]);
|
|
|
|
// ── buildAuthedHeaders ──────────────────────────────────
|
|
const buildAuthedHeaders = useCallback(
|
|
async (
|
|
withJson = false,
|
|
requireAuth = false,
|
|
): Promise<Record<string, string>> => {
|
|
const headers: Record<string, string> = {};
|
|
if (withJson) headers["Content-Type"] = "application/json";
|
|
if (!supabaseReady) return headers;
|
|
try {
|
|
const token = await getValidAccessToken();
|
|
headers.Authorization = `Bearer ${token}`;
|
|
} catch (error) {
|
|
if (requireAuth) throw error;
|
|
try {
|
|
const {
|
|
data: { session },
|
|
} = await getSupabaseBrowserClient().auth.getSession();
|
|
const fallbackToken = String(session?.access_token || "").trim();
|
|
if (fallbackToken) {
|
|
headers.Authorization = `Bearer ${fallbackToken}`;
|
|
}
|
|
} catch {
|
|
// Non-authenticated page load — silently skip.
|
|
}
|
|
}
|
|
return headers;
|
|
},
|
|
[supabaseReady, getValidAccessToken],
|
|
);
|
|
|
|
// ── resolvePaymentProvider ──────────────────────────────
|
|
const resolvePaymentProvider = useCallback(
|
|
async (
|
|
mode: ProviderMode = "auto",
|
|
preferredInjectedKey = "",
|
|
): Promise<ProviderSelection> => {
|
|
const targetChainId = Number(paymentConfig?.chain_id || 137);
|
|
if (mode !== "walletconnect") {
|
|
const injectedOptions = listInjectedProviders();
|
|
const injected =
|
|
injectedOptions.find((row) => row.key === preferredInjectedKey)
|
|
?.provider || getEvmProvider();
|
|
const label =
|
|
injectedOptions.find((row) => row.key === preferredInjectedKey)
|
|
?.label || getEvmWalletLabel(injected);
|
|
if (injected) {
|
|
return { provider: injected, label, mode: "auto" };
|
|
}
|
|
}
|
|
if (!walletConnectEnabled) {
|
|
throw new Error(
|
|
"未检测到浏览器扩展钱包，且 WalletConnect 未启用。请配置 NEXT_PUBLIC_WALLETCONNECT_PROJECT_ID 或安装 EVM 钱包扩展。",
|
|
);
|
|
}
|
|
const wcProvider = await getWalletConnectProvider(
|
|
targetChainId,
|
|
WALLETCONNECT_POLYGON_RPC_URL,
|
|
);
|
|
const existingAccounts = (await wcProvider
|
|
.request({ method: "eth_accounts" })
|
|
.catch(() => [])) as string[];
|
|
if (
|
|
!Array.isArray(existingAccounts) ||
|
|
existingAccounts.length === 0
|
|
) {
|
|
if (typeof wcProvider.connect === "function") {
|
|
try {
|
|
await wcProvider.connect({ chains: [targetChainId] });
|
|
} catch (err) {
|
|
if (!isWalletConnectResetError(err)) throw err;
|
|
await resetWalletConnectProvider();
|
|
const freshProvider = await getWalletConnectProvider(
|
|
targetChainId,
|
|
WALLETCONNECT_POLYGON_RPC_URL,
|
|
);
|
|
if (typeof freshProvider.connect === "function") {
|
|
await freshProvider.connect({ chains: [targetChainId] });
|
|
}
|
|
return {
|
|
provider: freshProvider,
|
|
label: "WalletConnect",
|
|
mode: "walletconnect",
|
|
};
|
|
}
|
|
}
|
|
}
|
|
return {
|
|
provider: wcProvider,
|
|
label: "WalletConnect",
|
|
mode: "walletconnect",
|
|
};
|
|
},
|
|
[paymentConfig?.chain_id, walletConnectEnabled],
|
|
);
|
|
|
|
// ── loadPaymentSnapshot ──────────────────────────────────
|
|
const loadPaymentSnapshot = useCallback(async () => {
|
|
if (!backend?.authenticated) {
|
|
setPaymentConfig(null);
|
|
setBoundWallets([]);
|
|
return;
|
|
}
|
|
try {
|
|
const authHeadersPromise = buildAuthedHeaders(false);
|
|
const [configRes, walletsRes] = await Promise.all([
|
|
authHeadersPromise.then((headers) =>
|
|
fetch("/api/payments/config", { cache: "no-store", headers }),
|
|
),
|
|
authHeadersPromise.then((headers) =>
|
|
fetch("/api/payments/wallets", { cache: "no-store", headers }),
|
|
),
|
|
]);
|
|
if (configRes.ok) {
|
|
const configJson = (await configRes.json()) as PaymentConfig;
|
|
setPaymentConfig(configJson);
|
|
if (!selectedPlanCode && configJson.plans?.length) {
|
|
setSelectedPlanCode(configJson.plans[0].plan_code);
|
|
}
|
|
const tokenOptions = Array.isArray(configJson.tokens)
|
|
? configJson.tokens.filter(
|
|
(row) =>
|
|
typeof row?.address === "string" &&
|
|
String(row.address).startsWith("0x"),
|
|
)
|
|
: [];
|
|
const defaultTokenAddress = String(
|
|
configJson.default_token_address ||
|
|
tokenOptions.find((row) => row.is_default)?.address ||
|
|
tokenOptions[0]?.address ||
|
|
configJson.token_address ||
|
|
"",
|
|
).toLowerCase();
|
|
if (defaultTokenAddress) {
|
|
setSelectedTokenAddress(
|
|
(prev) => prev || defaultTokenAddress,
|
|
);
|
|
}
|
|
}
|
|
if (walletsRes.ok) {
|
|
const walletsJson = (await walletsRes.json()) as {
|
|
wallets?: BoundWallet[];
|
|
};
|
|
const wallets = (
|
|
Array.isArray(walletsJson.wallets) ? walletsJson.wallets : []
|
|
)
|
|
.filter((row) => {
|
|
const status = String(row?.status || "active").toLowerCase();
|
|
const address = String(row?.address || "");
|
|
return status === "active" && address.startsWith("0x");
|
|
})
|
|
.map((row) => ({
|
|
...row,
|
|
address: String(row.address || "").toLowerCase(),
|
|
}));
|
|
setBoundWallets(wallets);
|
|
if (wallets.length) {
|
|
const currentSelected = String(
|
|
selectedWallet || "",
|
|
).toLowerCase();
|
|
const hasCurrent = wallets.some(
|
|
(row) =>
|
|
String(row.address || "").toLowerCase() === currentSelected,
|
|
);
|
|
const fallback =
|
|
wallets.find((row) => Boolean(row.is_primary))?.address ||
|
|
wallets[0].address;
|
|
if (!currentSelected || !hasCurrent) {
|
|
setSelectedWallet(fallback);
|
|
}
|
|
const currentWalletAddress = String(
|
|
walletAddress || "",
|
|
).toLowerCase();
|
|
const hasWalletAddress = wallets.some(
|
|
(row) =>
|
|
String(row.address || "").toLowerCase() ===
|
|
currentWalletAddress,
|
|
);
|
|
if (!currentWalletAddress || !hasWalletAddress) {
|
|
setWalletAddress(fallback);
|
|
}
|
|
} else {
|
|
setSelectedWallet("");
|
|
setWalletAddress("");
|
|
}
|
|
}
|
|
} catch {
|
|
// ignore
|
|
}
|
|
}, [
|
|
backend?.authenticated,
|
|
buildAuthedHeaders,
|
|
selectedPlanCode,
|
|
selectedWallet,
|
|
walletAddress,
|
|
]);
|
|
|
|
// ── fetchLatestPaymentConfig ────────────────────────────
|
|
const fetchLatestPaymentConfig = useCallback(
|
|
async (
|
|
authHeaders?: Record<string, string>,
|
|
syncState = true,
|
|
): Promise<PaymentConfig> => {
|
|
const headers = authHeaders || (await buildAuthedHeaders(false));
|
|
const configRes = await fetch("/api/payments/config", {
|
|
cache: "no-store",
|
|
headers,
|
|
});
|
|
if (!configRes.ok) {
|
|
const raw = (await configRes.text()).slice(0, 350);
|
|
throw new Error(copy.loadConfigFailed.replace("{raw}", raw));
|
|
}
|
|
const configJson = (await configRes.json()) as PaymentConfig;
|
|
if (syncState) {
|
|
setPaymentConfig(configJson);
|
|
if (!selectedPlanCode && configJson.plans?.length) {
|
|
setSelectedPlanCode(configJson.plans[0].plan_code);
|
|
}
|
|
const tokenOptions = Array.isArray(configJson.tokens)
|
|
? configJson.tokens.filter(
|
|
(row) =>
|
|
typeof row?.address === "string" &&
|
|
String(row.address).startsWith("0x"),
|
|
)
|
|
: [];
|
|
const defaultTokenAddress = String(
|
|
configJson.default_token_address ||
|
|
tokenOptions.find((row) => row.is_default)?.address ||
|
|
tokenOptions[0]?.address ||
|
|
configJson.token_address ||
|
|
"",
|
|
).toLowerCase();
|
|
if (defaultTokenAddress) {
|
|
setSelectedTokenAddress(
|
|
(prev) => prev || defaultTokenAddress,
|
|
);
|
|
}
|
|
}
|
|
return configJson;
|
|
},
|
|
[buildAuthedHeaders, selectedPlanCode],
|
|
);
|
|
|
|
// ── loadSnapshot ──────────────────────────────────────────
|
|
const loadSnapshot = useCallback(async () => {
|
|
setErrorText("");
|
|
const attempt = async (retry: boolean): Promise<void> => {
|
|
const userPromise = supabaseReady
|
|
? getSupabaseBrowserClient().auth.getUser()
|
|
: Promise.resolve({ data: { user: null as User | null } });
|
|
const authHeadersPromise = buildAuthedHeaders(false);
|
|
const backendPromise = authHeadersPromise.then((headers) =>
|
|
fetch("/api/auth/me", {
|
|
cache: "no-store",
|
|
headers,
|
|
}),
|
|
);
|
|
const [userResult, backendResult] = await Promise.all([
|
|
userPromise,
|
|
backendPromise,
|
|
]);
|
|
setUser(userResult.data?.user ?? null);
|
|
if (!backendResult.ok) {
|
|
if (retry && backendResult.status === 401) {
|
|
await new Promise((r) => setTimeout(r, 1200));
|
|
return attempt(false);
|
|
}
|
|
const raw = (await backendResult.text()).slice(0, 260);
|
|
throw new Error(
|
|
copy.httpError
|
|
.replace("{status}", String(backendResult.status))
|
|
.replace("{raw}", raw),
|
|
);
|
|
}
|
|
const backendJson =
|
|
(await backendResult.json()) as AuthMeResponse;
|
|
setBackend(backendJson);
|
|
setUpdatedAt(new Date().toISOString());
|
|
};
|
|
try {
|
|
await attempt(true);
|
|
} catch (error) {
|
|
setErrorText(String(error));
|
|
}
|
|
}, [buildAuthedHeaders, supabaseReady, copy.httpError]);
|
|
|
|
// ── loadPaymentSnapshot effect ────────────────────────────
|
|
useEffect(() => {
|
|
void loadPaymentSnapshot();
|
|
}, [loadPaymentSnapshot]);
|
|
|
|
// ── Recovery save effect ────────────────────────────────
|
|
useEffect(() => {
|
|
if (typeof window === "undefined") return;
|
|
if (
|
|
!(
|
|
lastIntentId &&
|
|
lastTxHash &&
|
|
authUserId &&
|
|
lastPaymentStartedAt
|
|
)
|
|
) {
|
|
clearStoredPaymentRecovery();
|
|
return;
|
|
}
|
|
const payload: PaymentRecoveryState = {
|
|
intentId: lastIntentId,
|
|
txHash: lastTxHash,
|
|
userId: authUserId,
|
|
createdAt: lastPaymentStartedAt,
|
|
};
|
|
window.sessionStorage.setItem(
|
|
PAYMENT_RECOVERY_STORAGE_KEY,
|
|
JSON.stringify(payload),
|
|
);
|
|
}, [authUserId, lastIntentId, lastPaymentStartedAt, lastTxHash]);
|
|
|
|
// ── Recovery restore effect ──────────────────────────────
|
|
useEffect(() => {
|
|
if (typeof window === "undefined") return;
|
|
if (!authUserId) return;
|
|
if (lastIntentId && lastTxHash && lastPaymentStartedAt) return;
|
|
const raw =
|
|
window.sessionStorage.getItem(PAYMENT_RECOVERY_STORAGE_KEY);
|
|
if (!raw) return;
|
|
try {
|
|
const parsed = JSON.parse(raw) as PaymentRecoveryState;
|
|
const userId = String(parsed?.userId || "").trim();
|
|
const intentId = String(parsed?.intentId || "").trim();
|
|
const txHash = String(parsed?.txHash || "")
|
|
.trim()
|
|
.toLowerCase();
|
|
const createdAt = Number(parsed?.createdAt || 0);
|
|
const expired =
|
|
!createdAt ||
|
|
Date.now() - createdAt > PAYMENT_RECOVERY_TTL_MS;
|
|
if (
|
|
expired ||
|
|
!intentId ||
|
|
!txHash ||
|
|
!userId ||
|
|
userId !== authUserId
|
|
) {
|
|
clearStoredPaymentRecovery();
|
|
return;
|
|
}
|
|
setLastIntentId(intentId);
|
|
setLastTxHash(txHash);
|
|
setLastPaymentStartedAt(createdAt);
|
|
} catch {
|
|
clearStoredPaymentRecovery();
|
|
}
|
|
}, [authUserId, lastIntentId, lastPaymentStartedAt, lastTxHash]);
|
|
|
|
// ── Subscription cleanup effect ──────────────────────────
|
|
useEffect(() => {
|
|
if (!backend?.subscription_active) return;
|
|
clearPaymentState();
|
|
clearStoredPaymentRecovery();
|
|
}, [backend?.subscription_active]);
|
|
|
|
// ── Derived payment values ──────────────────────────────
|
|
const planList = paymentConfig?.plans || [];
|
|
const monthlyPlanList = planList.filter(
|
|
(plan) =>
|
|
String(plan.plan_code || "")
|
|
.trim()
|
|
.toLowerCase() === "pro_monthly",
|
|
);
|
|
const effectivePlanList = monthlyPlanList.length
|
|
? monthlyPlanList
|
|
: planList;
|
|
const selectedPlan =
|
|
effectivePlanList.find(
|
|
(plan) => plan.plan_code === selectedPlanCode,
|
|
) || effectivePlanList[0];
|
|
|
|
const availableTokenList: PaymentTokenOption[] = useMemo(() => {
|
|
const configured = Array.isArray(paymentConfig?.tokens)
|
|
? paymentConfig?.tokens || []
|
|
: [];
|
|
const clean = configured
|
|
.filter(
|
|
(row) =>
|
|
row &&
|
|
typeof row.address === "string" &&
|
|
row.address.startsWith("0x"),
|
|
)
|
|
.map((row) => ({
|
|
...row,
|
|
address: String(row.address).toLowerCase(),
|
|
symbol: String(row.symbol || "USDC"),
|
|
name: String(row.name || row.symbol || "USDC"),
|
|
code: String(row.code || "usdc"),
|
|
decimals: Number.isFinite(Number(row.decimals))
|
|
? Number(row.decimals)
|
|
: Number(paymentConfig?.token_decimals ?? 6),
|
|
}));
|
|
if (clean.length) return clean;
|
|
const fallbackAddress = String(
|
|
paymentConfig?.token_address || "",
|
|
).toLowerCase();
|
|
if (!fallbackAddress.startsWith("0x")) return [];
|
|
return [
|
|
{
|
|
code: "usdc",
|
|
symbol: "USDC",
|
|
name: "USDC",
|
|
address: fallbackAddress,
|
|
decimals: Number(paymentConfig?.token_decimals ?? 6),
|
|
receiver_contract: paymentConfig?.receiver_contract,
|
|
is_default: true,
|
|
},
|
|
];
|
|
}, [paymentConfig]);
|
|
|
|
const resolvedSelectedTokenAddress = String(
|
|
selectedTokenAddress ||
|
|
paymentConfig?.default_token_address ||
|
|
availableTokenList.find((row) => row.is_default)?.address ||
|
|
availableTokenList[0]?.address ||
|
|
paymentConfig?.token_address ||
|
|
"",
|
|
).toLowerCase();
|
|
|
|
const selectedPaymentToken =
|
|
availableTokenList.find(
|
|
(row) => row.address === resolvedSelectedTokenAddress,
|
|
) || availableTokenList[0];
|
|
|
|
const selectedTokenLabel =
|
|
selectedPaymentToken?.symbol ||
|
|
(resolvedSelectedTokenAddress.startsWith("0x")
|
|
? shortAddress(resolvedSelectedTokenAddress)
|
|
: "USDC");
|
|
|
|
const paymentReceiverAddress = EXPECTED_PAYMENT_RECEIVER_ADDRESS;
|
|
|
|
const paymentWalletLabel = String(
|
|
selectedWallet ||
|
|
walletAddress ||
|
|
boundWallets.find((row) => row.is_primary)?.address ||
|
|
boundWallets[0]?.address ||
|
|
"",
|
|
).toLowerCase();
|
|
|
|
const hasPayingWallet = Boolean(
|
|
String(
|
|
selectedWallet || walletAddress || boundWallets[0]?.address || "",
|
|
).trim(),
|
|
);
|
|
|
|
// ── Points computation ──────────────────────────────────
|
|
const backendPointsRaw = Number(backend?.points);
|
|
const metadataPointsRaw = Number(
|
|
user?.user_metadata?.points ??
|
|
user?.user_metadata?.total_points ??
|
|
0,
|
|
);
|
|
const metadataPointsSafe = Number.isFinite(metadataPointsRaw)
|
|
? metadataPointsRaw
|
|
: 0;
|
|
const pointsRaw = Number.isFinite(backendPointsRaw)
|
|
? Math.max(backendPointsRaw, metadataPointsSafe)
|
|
: metadataPointsSafe;
|
|
const totalPoints = Number.isFinite(pointsRaw)
|
|
? Math.max(0, pointsRaw)
|
|
: 0;
|
|
|
|
// ── Billing ──────────────────────────────────────────────
|
|
const billing = useMemo(() => {
|
|
const parsedPlanAmount = Number(
|
|
backend?.telegram_pricing?.amount_usdc ??
|
|
selectedPlan?.amount_usdc ??
|
|
10,
|
|
);
|
|
const planAmount =
|
|
Number.isFinite(parsedPlanAmount) && parsedPlanAmount > 0
|
|
? parsedPlanAmount
|
|
: 10;
|
|
|
|
const pointsCfg = paymentConfig?.points_redemption || {};
|
|
const pointsEnabled = pointsCfg.enabled !== false;
|
|
const pointsPerUsdcRaw = Number(pointsCfg.points_per_usdc ?? 500);
|
|
const pointsPerUsdc =
|
|
Number.isFinite(pointsPerUsdcRaw) && pointsPerUsdcRaw > 0
|
|
? Math.floor(pointsPerUsdcRaw)
|
|
: 500;
|
|
|
|
const maxDiscountRaw = Number(pointsCfg.max_discount_usdc ?? 3);
|
|
const maxDiscountUsdc = Math.max(
|
|
0,
|
|
Math.min(
|
|
Math.floor(Number.isFinite(maxDiscountRaw) ? maxDiscountRaw : 3),
|
|
Math.floor(planAmount),
|
|
),
|
|
);
|
|
|
|
const maxRedeemablePoints = pointsPerUsdc * maxDiscountUsdc;
|
|
const actualRedeem = pointsEnabled
|
|
? Math.min(totalPoints, maxRedeemablePoints)
|
|
: 0;
|
|
const discountUnits = Math.floor(actualRedeem / pointsPerUsdc);
|
|
const pointsUsed = discountUnits * pointsPerUsdc;
|
|
const canRedeem =
|
|
pointsEnabled &&
|
|
maxDiscountUsdc > 0 &&
|
|
totalPoints >= pointsPerUsdc;
|
|
const applyDiscount = usePoints && canRedeem && pointsUsed > 0;
|
|
|
|
return {
|
|
planAmount,
|
|
pointsEnabled,
|
|
pointsPerUsdc,
|
|
maxDiscountUsdc,
|
|
pointsUsed,
|
|
discountAmount: discountUnits,
|
|
payAmount: planAmount - (applyDiscount ? discountUnits : 0),
|
|
canRedeem,
|
|
};
|
|
}, [
|
|
paymentConfig?.points_redemption,
|
|
backend?.telegram_pricing?.amount_usdc,
|
|
selectedPlan?.amount_usdc,
|
|
totalPoints,
|
|
usePoints,
|
|
]);
|
|
|
|
// ── reconcileLatestPayment ──────────────────────────────
|
|
const reconcileLatestPayment = useCallback(async () => {
|
|
if (!authIsAuthenticated || reconcileBusy) return false;
|
|
setReconcileBusy(true);
|
|
try {
|
|
const headers = await buildAuthedHeaders(true, true);
|
|
const res = await fetch("/api/payments/reconcile-latest", {
|
|
method: "POST",
|
|
headers,
|
|
});
|
|
if (!res.ok) return false;
|
|
const json = (await res.json()) as {
|
|
ok?: boolean;
|
|
action?: string;
|
|
subscription?: { plan_code?: string | null } | null;
|
|
};
|
|
if (json.ok) {
|
|
setPaymentInfo(copy.walletRecoveryDone);
|
|
setPaymentError("");
|
|
await loadSnapshot();
|
|
await loadPaymentSnapshot();
|
|
return true;
|
|
}
|
|
return false;
|
|
} catch {
|
|
return false;
|
|
} finally {
|
|
setReconcileBusy(false);
|
|
}
|
|
}, [
|
|
authIsAuthenticated,
|
|
buildAuthedHeaders,
|
|
copy.walletRecoveryDone,
|
|
loadPaymentSnapshot,
|
|
loadSnapshot,
|
|
reconcileBusy,
|
|
]);
|
|
|
|
// ── handleSubmit409 ────────────────────────────────────
|
|
const handleSubmit409 = useCallback(
|
|
async (intentId: string, txHashNorm: string, raw: string) => {
|
|
const lowerRaw = raw.toLowerCase();
|
|
if (
|
|
lowerRaw.includes("已支付") ||
|
|
lowerRaw.includes("already confirmed") ||
|
|
lowerRaw.includes("already paid")
|
|
) {
|
|
const ok = await reconcileLatestPayment();
|
|
if (ok) return;
|
|
setPaymentInfo(copy.orderAlreadyPaid);
|
|
await loadSnapshot();
|
|
await loadPaymentSnapshot();
|
|
return;
|
|
}
|
|
if (lowerRaw.includes("expired")) {
|
|
throw new Error(copy.orderExpired);
|
|
}
|
|
try {
|
|
const headers = await buildAuthedHeaders(true, false);
|
|
const intentRes = await fetch(
|
|
`/api/payments/intents/${intentId}`,
|
|
{
|
|
headers,
|
|
cache: "no-store",
|
|
},
|
|
);
|
|
if (intentRes.ok) {
|
|
const intentJson = (await intentRes.json()) as {
|
|
intent?: { status?: string; tx_hash?: string };
|
|
};
|
|
const status = intentJson.intent?.status;
|
|
if (status === "confirmed") {
|
|
await reconcileLatestPayment();
|
|
const txHash =
|
|
intentJson.intent?.tx_hash || txHashNorm;
|
|
setPaymentInfo(
|
|
`支付已确认，交易: ${shortAddress(txHash)}`,
|
|
);
|
|
setPaymentError("");
|
|
await loadSnapshot();
|
|
await loadPaymentSnapshot();
|
|
return;
|
|
}
|
|
if (status === "expired") {
|
|
throw new Error(copy.orderExpired);
|
|
}
|
|
}
|
|
} catch (e) {
|
|
if (e instanceof Error && e.message !== raw) throw e;
|
|
}
|
|
throw new Error(
|
|
copy.submitTxFailed.replace("{raw}", raw),
|
|
);
|
|
},
|
|
[
|
|
buildAuthedHeaders,
|
|
copy.orderAlreadyPaid,
|
|
copy.orderExpired,
|
|
copy.submitTxFailed,
|
|
loadPaymentSnapshot,
|
|
loadSnapshot,
|
|
reconcileLatestPayment,
|
|
],
|
|
);
|
|
|
|
// ── Auto-reconcile effect ──────────────────────────────
|
|
useEffect(() => {
|
|
if (!authIsAuthenticated) return;
|
|
if (backend?.subscription_active) return;
|
|
if (!paymentReadyForRecovery) return;
|
|
if (!hasRecentPaymentRecovery) return;
|
|
let cancelled = false;
|
|
const run = async () => {
|
|
setPaymentInfo(copy.walletRecoveryBusy);
|
|
const repaired = await reconcileLatestPayment();
|
|
if (cancelled) return;
|
|
if (!repaired && !backend?.subscription_active) {
|
|
setPaymentInfo("");
|
|
setPaymentError(copy.walletRecoveryFailed);
|
|
}
|
|
};
|
|
void run();
|
|
return () => {
|
|
cancelled = true;
|
|
};
|
|
}, [
|
|
backend?.subscription_active,
|
|
authIsAuthenticated,
|
|
copy.walletRecoveryBusy,
|
|
copy.walletRecoveryFailed,
|
|
hasRecentPaymentRecovery,
|
|
paymentReadyForRecovery,
|
|
reconcileLatestPayment,
|
|
]);
|
|
|
|
// ── Low-level helpers ──────────────────────────────────
|
|
const waitForReceipt = async (
|
|
txHash: string,
|
|
provider?: EvmProvider,
|
|
timeoutMs = 120000,
|
|
pollMs = 3000,
|
|
) => {
|
|
const eth = provider || getEvmProvider();
|
|
if (!eth) throw new Error(copy.noWalletProvider);
|
|
const started = Date.now();
|
|
while (Date.now() - started < timeoutMs) {
|
|
const receipt =
|
|
await requestWalletWithTimeout<{
|
|
status?: string;
|
|
} | null>(
|
|
eth,
|
|
{
|
|
method: "eth_getTransactionReceipt",
|
|
params: [txHash],
|
|
},
|
|
"查询授权交易确认",
|
|
15_000,
|
|
);
|
|
if (receipt && receipt.status) {
|
|
if (receipt.status === "0x1") return receipt;
|
|
throw new Error(
|
|
copy.txReverted.replace("{txHash}", txHash),
|
|
);
|
|
}
|
|
await new Promise((resolve) => setTimeout(resolve, pollMs));
|
|
}
|
|
throw new Error(
|
|
copy.txConfirmTimeout.replace("{txHash}", txHash),
|
|
);
|
|
};
|
|
|
|
const signBindMessage = async (
|
|
eth: EvmProvider,
|
|
address: string,
|
|
message: string,
|
|
): Promise<string> => {
|
|
try {
|
|
return (await eth.request({
|
|
method: "personal_sign",
|
|
params: [message, address],
|
|
})) as string;
|
|
} catch {
|
|
return (await eth.request({
|
|
method: "personal_sign",
|
|
params: [address, message],
|
|
})) as string;
|
|
}
|
|
};
|
|
|
|
const ensureTargetChain = async (
|
|
eth: EvmProvider,
|
|
targetChainId: number,
|
|
): Promise<void> => {
|
|
const currentChainIdHex = String(
|
|
(await requestWalletWithTimeout<string>(
|
|
eth,
|
|
{ method: "eth_chainId" },
|
|
copy.chainReadError,
|
|
)) || "",
|
|
);
|
|
const targetChainHex = `0x${targetChainId.toString(16)}`;
|
|
if (
|
|
currentChainIdHex.toLowerCase() === targetChainHex.toLowerCase()
|
|
)
|
|
return;
|
|
try {
|
|
await requestWalletWithTimeout(
|
|
eth,
|
|
{
|
|
method: "wallet_switchEthereumChain",
|
|
params: [{ chainId: targetChainHex }],
|
|
},
|
|
copy.chainSwitchError,
|
|
);
|
|
} catch (err: any) {
|
|
const code = Number(err?.code);
|
|
|
|
if (code === 4902 || targetChainId === 137) {
|
|
try {
|
|
await requestWalletWithTimeout(
|
|
eth,
|
|
{
|
|
method: "wallet_addEthereumChain",
|
|
params: [
|
|
{
|
|
chainId: "0x89",
|
|
chainName: "Polygon Mainnet",
|
|
nativeCurrency: {
|
|
name: "POL",
|
|
symbol: "POL",
|
|
decimals: 18,
|
|
},
|
|
rpcUrls: ["https://polygon-rpc.com"],
|
|
blockExplorerUrls: ["https://polygonscan.com"],
|
|
},
|
|
],
|
|
},
|
|
copy.chainAddPolygon,
|
|
);
|
|
return;
|
|
} catch (addErr: any) {
|
|
err = addErr;
|
|
}
|
|
}
|
|
throw new Error(
|
|
`${copy.chainSwitchPrompt} (${err?.message || (isEn ? "Network switch failed" : "网络切换失败")})`,
|
|
);
|
|
}
|
|
};
|
|
|
|
// ── pollIntentUntilConfirmed ────────────────────────────
|
|
const pollIntentUntilConfirmed = useCallback(
|
|
async (
|
|
intentId: string,
|
|
authHeaders: Record<string, string>,
|
|
txHashHint = "",
|
|
timeoutMs = 180000,
|
|
pollMs = 5000,
|
|
) => {
|
|
const startedAt = Date.now();
|
|
const shortTx = shortAddress(txHashHint);
|
|
while (Date.now() - startedAt < timeoutMs) {
|
|
const statusRes = await fetch(
|
|
`/api/payments/intents/${intentId}`,
|
|
{
|
|
method: "GET",
|
|
headers: authHeaders,
|
|
cache: "no-store",
|
|
},
|
|
);
|
|
if (!statusRes.ok) {
|
|
if (statusRes.status >= 500 || statusRes.status === 429) {
|
|
await new Promise((resolve) =>
|
|
setTimeout(resolve, pollMs),
|
|
);
|
|
continue;
|
|
}
|
|
const raw = (await statusRes.text()).slice(0, 260);
|
|
throw new Error(
|
|
copy.queryIntentFailed.replace("{raw}", raw),
|
|
);
|
|
}
|
|
|
|
const statusJson =
|
|
(await statusRes.json()) as IntentStatusResponse;
|
|
const intent = statusJson.intent || {};
|
|
const status = String(intent.status || "").toLowerCase();
|
|
const txHash = String(
|
|
intent.tx_hash || txHashHint || "",
|
|
).toLowerCase();
|
|
if (status === "confirmed") {
|
|
setPaymentError("");
|
|
setPaymentInfo(
|
|
copy.paymentConfirmed.replace(
|
|
"{txHash}",
|
|
shortAddress(txHash),
|
|
),
|
|
);
|
|
trackAppEvent("checkout_succeeded", {
|
|
entry: "account_center",
|
|
plan_code: selectedPlan?.plan_code || "pro_monthly",
|
|
intent_id: intentId,
|
|
tx_hash: txHash || null,
|
|
});
|
|
await loadSnapshot();
|
|
await loadPaymentSnapshot();
|
|
return;
|
|
}
|
|
if (
|
|
status === "failed" ||
|
|
status === "cancelled" ||
|
|
status === "expired"
|
|
) {
|
|
throw new Error(
|
|
copy.paymentStatus.replace("{status}", status),
|
|
);
|
|
}
|
|
setPaymentInfo(
|
|
copy.txSubmitted
|
|
.replace("{txHash}", shortTx)
|
|
.replace("{status}", status || "submitted"),
|
|
);
|
|
await new Promise((resolve) =>
|
|
setTimeout(resolve, pollMs),
|
|
);
|
|
}
|
|
throw new Error(copy.paymentPendingTimeout);
|
|
},
|
|
[
|
|
loadPaymentSnapshot,
|
|
loadSnapshot,
|
|
selectedPlan?.plan_code,
|
|
],
|
|
);
|
|
|
|
// ── connectAndBindWallet ────────────────────────────────
|
|
const connectAndBindWallet = async (
|
|
mode: ProviderMode = "auto",
|
|
options: ConnectBindOptions = {},
|
|
): Promise<boolean> => {
|
|
clearPaymentMessages();
|
|
if (!paymentHostAllowed) {
|
|
setPaymentError(
|
|
copy.paymentHostBlocked.replace(
|
|
"{host}",
|
|
allowedPaymentHosts[0] ||
|
|
"polyweather-pro.vercel.app",
|
|
),
|
|
);
|
|
return false;
|
|
}
|
|
if (!authIsAuthenticated) {
|
|
setPaymentError(copy.loginBeforeBind);
|
|
return false;
|
|
}
|
|
|
|
setPaymentBusy(true);
|
|
try {
|
|
const providerSelection = await resolvePaymentProvider(
|
|
mode,
|
|
selectedInjectedProviderKey,
|
|
);
|
|
const eth = providerSelection.provider;
|
|
const walletLabel = providerSelection.label;
|
|
const binanceBindHint = walletLabel
|
|
.toLowerCase()
|
|
.includes("binance")
|
|
? copy.binanceBindHint
|
|
: "";
|
|
|
|
let accessToken: string;
|
|
try {
|
|
accessToken = await getValidAccessToken();
|
|
} catch (tokenErr) {
|
|
setPaymentError(normalizePaymentError(tokenErr).message);
|
|
setPaymentBusy(false);
|
|
return false;
|
|
}
|
|
const authHeaders: Record<string, string> = {
|
|
"Content-Type": "application/json",
|
|
Authorization: `Bearer ${accessToken}`,
|
|
};
|
|
|
|
const accounts = await requestWalletWithTimeout<string[]>(
|
|
eth,
|
|
{ method: "eth_requestAccounts" },
|
|
"连接绑定钱包",
|
|
);
|
|
const address = String(accounts?.[0] || "").toLowerCase();
|
|
if (!address)
|
|
throw new Error(
|
|
isEn
|
|
? "Wallet account is empty."
|
|
: "钱包账户为空",
|
|
);
|
|
|
|
const existingWallet = boundWallets.find(
|
|
(w) =>
|
|
String(w.address || "").toLowerCase() === address,
|
|
);
|
|
if (existingWallet) {
|
|
setWalletAddress(address);
|
|
setSelectedWallet(address);
|
|
setPaymentInfo(
|
|
`${walletLabel} 已绑定: ${shortAddress(address)}。${binanceBindHint || "现在可点击“立即订阅并激活服务”。"}`,
|
|
);
|
|
await Promise.all([
|
|
loadSnapshot(),
|
|
loadPaymentSnapshot(),
|
|
]);
|
|
if (options.openOverlayAfterBind) setShowOverlay(true);
|
|
setPaymentBusy(false);
|
|
return true;
|
|
}
|
|
|
|
setWalletAddress(address);
|
|
const challengeRes = await fetch(
|
|
"/api/payments/wallets/challenge",
|
|
{
|
|
method: "POST",
|
|
headers: authHeaders,
|
|
body: JSON.stringify({ address }),
|
|
},
|
|
);
|
|
if (!challengeRes.ok) {
|
|
const raw = (await challengeRes.text()).slice(0, 300);
|
|
throw new Error(
|
|
copy.challengeFailed.replace("{raw}", raw),
|
|
);
|
|
}
|
|
|
|
const challengeJson = (await challengeRes.json()) as {
|
|
nonce?: string;
|
|
message?: string;
|
|
};
|
|
const message = String(challengeJson.message || "");
|
|
const nonce = String(challengeJson.nonce || "");
|
|
if (!message || !nonce)
|
|
throw new Error(copy.challengeInvalid);
|
|
|
|
const signature = await signBindMessage(
|
|
eth,
|
|
address,
|
|
message,
|
|
);
|
|
const verifyRes = await fetch(
|
|
"/api/payments/wallets/verify",
|
|
{
|
|
method: "POST",
|
|
headers: authHeaders,
|
|
body: JSON.stringify({
|
|
address,
|
|
nonce,
|
|
signature,
|
|
}),
|
|
},
|
|
);
|
|
if (!verifyRes.ok) {
|
|
const raw = (await verifyRes.text()).slice(0, 300);
|
|
throw new Error(
|
|
copy.verifyFailedRaw.replace("{raw}", raw),
|
|
);
|
|
}
|
|
|
|
setPaymentInfo(
|
|
`${walletLabel} 绑定成功: ${shortAddress(address)}。${binanceBindHint || "现在可点击“立即订阅并激活服务”。"}`,
|
|
);
|
|
setProviderMode(providerSelection.mode);
|
|
if (options.openOverlayAfterBind) setShowOverlay(true);
|
|
await Promise.all([
|
|
loadSnapshot(),
|
|
loadPaymentSnapshot(),
|
|
]);
|
|
return true;
|
|
} catch (error) {
|
|
setPaymentInfo("");
|
|
setPaymentError(
|
|
normalizePaymentError(error).message,
|
|
);
|
|
return false;
|
|
} finally {
|
|
setPaymentBusy(false);
|
|
}
|
|
};
|
|
|
|
// ── handleUnbindWallet ──────────────────────────────────
|
|
const handleUnbindWallet = async (address: string) => {
|
|
const target = String(address || "").toLowerCase();
|
|
if (!target) return;
|
|
if (!authIsAuthenticated) {
|
|
setPaymentError(copy.loginBeforeBind);
|
|
return;
|
|
}
|
|
const confirmed = window.confirm(
|
|
copy.unbindConfirm.replace(
|
|
"{address}",
|
|
shortAddress(target),
|
|
),
|
|
);
|
|
if (!confirmed) return;
|
|
|
|
setPaymentBusy(true);
|
|
clearPaymentMessages();
|
|
try {
|
|
const headers = await buildAuthedHeaders(true, false);
|
|
const res = await fetch("/api/payments/wallets", {
|
|
method: "DELETE",
|
|
headers,
|
|
body: JSON.stringify({ address: target }),
|
|
});
|
|
const raw = await res.text();
|
|
if (!res.ok) {
|
|
let detail = raw;
|
|
try {
|
|
const parsed = JSON.parse(raw);
|
|
detail = String(
|
|
parsed?.detail || parsed?.error || raw,
|
|
);
|
|
if (detail.trim().startsWith("{")) {
|
|
try {
|
|
const nested = JSON.parse(detail);
|
|
detail = String(
|
|
nested?.detail ||
|
|
nested?.error ||
|
|
detail,
|
|
);
|
|
} catch {
|
|
// ignore nested parse failure
|
|
}
|
|
}
|
|
} catch {
|
|
// ignore
|
|
}
|
|
throw new Error(
|
|
detail ||
|
|
copy.httpError
|
|
.replace("{status}", String(res.status))
|
|
.replace("{raw}", ""),
|
|
);
|
|
}
|
|
|
|
let data: Record<string, unknown> = {};
|
|
try {
|
|
data = raw
|
|
? (JSON.parse(raw) as Record<string, unknown>)
|
|
: {};
|
|
} catch {
|
|
data = {};
|
|
}
|
|
const newPrimary = String(
|
|
data?.new_primary || "",
|
|
).toLowerCase();
|
|
const selectedWalletNorm = String(
|
|
selectedWallet || "",
|
|
).toLowerCase();
|
|
const walletAddressNorm = String(
|
|
walletAddress || "",
|
|
).toLowerCase();
|
|
if (selectedWalletNorm === target) {
|
|
setSelectedWallet(newPrimary || "");
|
|
}
|
|
if (walletAddressNorm === target) {
|
|
setWalletAddress(newPrimary || "");
|
|
}
|
|
setBoundWallets((prev) =>
|
|
prev.filter(
|
|
(row) =>
|
|
String(row.address || "").toLowerCase() !==
|
|
String(target),
|
|
),
|
|
);
|
|
await loadPaymentSnapshot();
|
|
setPaymentInfo(
|
|
newPrimary
|
|
? copy.unbindDonePrimary.replace(
|
|
"{address}",
|
|
shortAddress(newPrimary),
|
|
)
|
|
: copy.unbindDone,
|
|
);
|
|
} catch (error) {
|
|
const message = normalizePaymentError(error)
|
|
.message;
|
|
const lower = String(message || "").toLowerCase();
|
|
if (
|
|
lower.includes("unauthorized") ||
|
|
lower.includes("session required") ||
|
|
lower.includes("401")
|
|
) {
|
|
setPaymentError(
|
|
`${copy.unbindFailed}: ${copy.authExpired}`,
|
|
);
|
|
return;
|
|
}
|
|
setPaymentError(
|
|
`${copy.unbindFailed}: ${message}`,
|
|
);
|
|
} finally {
|
|
setPaymentBusy(false);
|
|
}
|
|
};
|
|
|
|
// ── createIntentAndPay ──────────────────────────────────
|
|
const createIntentAndPay = async () => {
|
|
clearPaymentMessages();
|
|
clearPaymentState();
|
|
clearStoredPaymentRecovery();
|
|
if (!paymentHostAllowed) {
|
|
setPaymentError(
|
|
copy.paymentHostBlocked.replace(
|
|
"{host}",
|
|
allowedPaymentHosts[0] ||
|
|
"polyweather-pro.vercel.app",
|
|
),
|
|
);
|
|
return;
|
|
}
|
|
if (!authIsAuthenticated) {
|
|
setPaymentError(copy.loginBeforePay);
|
|
return;
|
|
}
|
|
if (!paymentConfig?.configured) {
|
|
setPaymentError(copy.payNotReady);
|
|
return;
|
|
}
|
|
|
|
const fallbackWallet = String(
|
|
selectedWallet ||
|
|
walletAddress ||
|
|
boundWallets[0]?.address ||
|
|
"",
|
|
).toLowerCase();
|
|
if (!fallbackWallet) {
|
|
setPaymentError(copy.bindFirstBeforePay);
|
|
return;
|
|
}
|
|
|
|
setPaymentBusy(true);
|
|
let approvedInThisRun = false;
|
|
try {
|
|
const providerSelection = await resolvePaymentProvider(
|
|
providerMode,
|
|
selectedInjectedProviderKey,
|
|
);
|
|
const eth = providerSelection.provider;
|
|
const activeAccounts =
|
|
await requestWalletWithTimeout<string[]>(
|
|
eth,
|
|
{ method: "eth_requestAccounts" },
|
|
"连接付款钱包",
|
|
);
|
|
const activeAddress = String(
|
|
activeAccounts?.[0] || "",
|
|
).toLowerCase();
|
|
if (!activeAddress)
|
|
throw new Error(
|
|
isEn
|
|
? "Wallet account is empty."
|
|
: "钱包账户为空",
|
|
);
|
|
|
|
const boundAddrSet = new Set(
|
|
boundWallets.map((row) =>
|
|
String(row.address || "").toLowerCase(),
|
|
),
|
|
);
|
|
if (
|
|
boundAddrSet.size > 0 &&
|
|
!boundAddrSet.has(activeAddress)
|
|
) {
|
|
throw new Error(
|
|
`当前连接钱包 ${shortAddress(activeAddress)} 未绑定，请先绑定该地址后支付。`,
|
|
);
|
|
}
|
|
const payingWallet = boundAddrSet.has(activeAddress)
|
|
? activeAddress
|
|
: fallbackWallet;
|
|
|
|
setSelectedWallet(payingWallet);
|
|
setProviderMode(providerSelection.mode);
|
|
|
|
let accessToken: string;
|
|
try {
|
|
accessToken = await getValidAccessToken();
|
|
} catch (tokenErr) {
|
|
setPaymentError(
|
|
normalizePaymentError(tokenErr).message,
|
|
);
|
|
setPaymentBusy(false);
|
|
return;
|
|
}
|
|
const authHeaders: Record<string, string> = {
|
|
"Content-Type": "application/json",
|
|
Authorization: `Bearer ${accessToken}`,
|
|
};
|
|
|
|
const latestConfig = await fetchLatestPaymentConfig(
|
|
authHeaders,
|
|
true,
|
|
);
|
|
if (!latestConfig?.enabled || !latestConfig?.configured) {
|
|
throw new Error(copy.payNotReady);
|
|
}
|
|
const expectedReceiver = String(
|
|
latestConfig.receiver_contract || "",
|
|
).toLowerCase();
|
|
assertExpectedPaymentReceiver(
|
|
expectedReceiver,
|
|
"payment receiver contract",
|
|
);
|
|
if (
|
|
paymentConfig?.receiver_contract &&
|
|
String(paymentConfig.receiver_contract).toLowerCase() !==
|
|
expectedReceiver
|
|
) {
|
|
setPaymentInfo(
|
|
copy.paymentConfigUpdated.replace(
|
|
"{address}",
|
|
shortAddress(expectedReceiver),
|
|
),
|
|
);
|
|
} else {
|
|
setPaymentInfo(
|
|
copy.currentReceiver.replace(
|
|
"{address}",
|
|
shortAddress(expectedReceiver),
|
|
),
|
|
);
|
|
}
|
|
|
|
const targetChainId = Number(
|
|
latestConfig.chain_id || 137,
|
|
);
|
|
await ensureTargetChain(eth, targetChainId);
|
|
|
|
const createRes = await fetch(
|
|
"/api/payments/intents",
|
|
{
|
|
method: "POST",
|
|
headers: authHeaders,
|
|
body: JSON.stringify({
|
|
plan_code:
|
|
selectedPlan?.plan_code || "pro_monthly",
|
|
payment_mode: "strict",
|
|
allowed_wallet: payingWallet,
|
|
token_address:
|
|
resolvedSelectedTokenAddress || undefined,
|
|
use_points: billing.canRedeem && usePoints,
|
|
points_to_consume:
|
|
billing.canRedeem && usePoints
|
|
? billing.pointsUsed
|
|
: 0,
|
|
metadata: {
|
|
source: "account_center",
|
|
frontend_host:
|
|
currentPaymentHost || null,
|
|
account_email: backend?.email || null,
|
|
},
|
|
}),
|
|
},
|
|
);
|
|
if (!createRes.ok) {
|
|
const raw = (await createRes.text()).slice(0, 350);
|
|
throw new Error(
|
|
copy.createIntentFailed.replace(
|
|
"{raw}",
|
|
raw,
|
|
),
|
|
);
|
|
}
|
|
|
|
const created =
|
|
(await createRes.json()) as CreatedIntent;
|
|
const intentId = String(
|
|
created.intent?.intent_id || "",
|
|
);
|
|
const txPayload = created.tx_payload;
|
|
if (!intentId || !txPayload?.to || !txPayload?.data)
|
|
throw new Error(copy.intentPayloadInvalid);
|
|
trackAppEvent("checkout_started", {
|
|
entry: "account_center",
|
|
plan_code:
|
|
selectedPlan?.plan_code || "pro_monthly",
|
|
intent_id: intentId,
|
|
use_points: billing.canRedeem && usePoints,
|
|
pay_amount_usd: billing.payAmount,
|
|
});
|
|
const intentReceiver = String(
|
|
txPayload.to || "",
|
|
).toLowerCase();
|
|
if (intentReceiver !== expectedReceiver) {
|
|
throw new Error(
|
|
`payment receiver changed: expected ${expectedReceiver}, got ${intentReceiver}. 请刷新页面后重试。`,
|
|
);
|
|
}
|
|
setLastIntentId(intentId);
|
|
|
|
const tokenAddress = String(
|
|
txPayload.token_address || "",
|
|
).toLowerCase();
|
|
const amountUnits = BigInt(
|
|
String(txPayload.amount_units || "0"),
|
|
);
|
|
if (!tokenAddress.startsWith("0x") || amountUnits <= 0n)
|
|
throw new Error(copy.intentTokenInvalid);
|
|
const tokenSymbol = String(
|
|
txPayload.token_symbol ||
|
|
selectedPaymentToken?.symbol ||
|
|
selectedTokenLabel ||
|
|
"USDC",
|
|
);
|
|
const tokenDecimals = Number(
|
|
txPayload.token_decimals ??
|
|
selectedPaymentToken?.decimals ??
|
|
latestConfig?.token_decimals ??
|
|
6,
|
|
);
|
|
|
|
const balanceHex =
|
|
await requestWalletWithTimeout<string>(
|
|
eth,
|
|
{
|
|
method: "eth_call",
|
|
params: [
|
|
{
|
|
to: tokenAddress,
|
|
data: buildBalanceOfCalldata(
|
|
payingWallet,
|
|
),
|
|
},
|
|
"latest",
|
|
],
|
|
},
|
|
`读取 ${tokenSymbol} 余额`,
|
|
);
|
|
const tokenBalance = BigInt(
|
|
String(balanceHex || "0x0"),
|
|
);
|
|
if (tokenBalance < amountUnits) {
|
|
const need = formatTokenUnits(
|
|
amountUnits,
|
|
tokenDecimals,
|
|
);
|
|
const have = formatTokenUnits(
|
|
tokenBalance,
|
|
tokenDecimals,
|
|
);
|
|
throw new Error(
|
|
`支付代币余额不足：需要 ${need} ${tokenSymbol}，当前 ${have} ${tokenSymbol}。请确认你钱包里持有该支付币种。`,
|
|
);
|
|
}
|
|
|
|
const allowanceHex =
|
|
await requestWalletWithTimeout<string>(
|
|
eth,
|
|
{
|
|
method: "eth_call",
|
|
params: [
|
|
{
|
|
to: tokenAddress,
|
|
data: buildAllowanceCalldata(
|
|
payingWallet,
|
|
txPayload.to,
|
|
),
|
|
},
|
|
"latest",
|
|
],
|
|
},
|
|
`读取 ${tokenSymbol} 授权额度`,
|
|
);
|
|
const allowance = BigInt(
|
|
String(allowanceHex || "0x0"),
|
|
);
|
|
|
|
if (allowance < amountUnits) {
|
|
setPaymentInfo(
|
|
copy.approvalDetected.replace(
|
|
"{symbol}",
|
|
tokenSymbol,
|
|
),
|
|
);
|
|
const approveParams: Record<string, any> = {
|
|
from: payingWallet,
|
|
to: tokenAddress,
|
|
data: buildApproveCalldata(
|
|
txPayload.to,
|
|
amountUnits,
|
|
),
|
|
};
|
|
const approveHash =
|
|
await requestWalletWithTimeout<string>(
|
|
eth,
|
|
{
|
|
method: "eth_sendTransaction",
|
|
params: [approveParams],
|
|
},
|
|
`发起 ${tokenSymbol} 授权`,
|
|
WALLET_TRANSACTION_REQUEST_TIMEOUT_MS,
|
|
);
|
|
await waitForReceipt(
|
|
String(approveHash || ""),
|
|
eth,
|
|
);
|
|
approvedInThisRun = true;
|
|
setPaymentInfo(
|
|
copy.approvalDone.replace(
|
|
"{symbol}",
|
|
tokenSymbol,
|
|
),
|
|
);
|
|
} else {
|
|
setPaymentInfo(copy.approvalSufficient);
|
|
}
|
|
|
|
const payParams: Record<string, any> = {
|
|
from: payingWallet,
|
|
to: txPayload.to,
|
|
data: txPayload.data,
|
|
};
|
|
if (
|
|
txPayload.value &&
|
|
txPayload.value !== "0x0" &&
|
|
txPayload.value !== "0"
|
|
) {
|
|
payParams.value = txPayload.value;
|
|
}
|
|
|
|
const txHash =
|
|
await requestWalletWithTimeout<string>(
|
|
eth,
|
|
{
|
|
method: "eth_sendTransaction",
|
|
params: [payParams],
|
|
},
|
|
"发起支付交易",
|
|
WALLET_TRANSACTION_REQUEST_TIMEOUT_MS,
|
|
);
|
|
const txHashNorm = String(
|
|
txHash || "",
|
|
).toLowerCase();
|
|
setLastTxHash(txHashNorm);
|
|
setLastPaymentStartedAt(Date.now());
|
|
|
|
const submitRes = await fetch(
|
|
`/api/payments/intents/${intentId}/submit`,
|
|
{
|
|
method: "POST",
|
|
headers: authHeaders,
|
|
body: JSON.stringify({
|
|
tx_hash: txHashNorm,
|
|
from_address: payingWallet,
|
|
}),
|
|
},
|
|
);
|
|
if (!submitRes.ok) {
|
|
const raw = (await submitRes.text()).slice(
|
|
0,
|
|
350,
|
|
);
|
|
if (submitRes.status === 409) {
|
|
await handleSubmit409(
|
|
intentId,
|
|
txHashNorm,
|
|
raw,
|
|
);
|
|
return;
|
|
}
|
|
throw new Error(
|
|
copy.submitTxFailed.replace(
|
|
"{raw}",
|
|
raw,
|
|
),
|
|
);
|
|
}
|
|
|
|
const confirmRes = await fetch(
|
|
`/api/payments/intents/${intentId}/confirm`,
|
|
{
|
|
method: "POST",
|
|
headers: authHeaders,
|
|
body: JSON.stringify({
|
|
tx_hash: txHashNorm,
|
|
}),
|
|
},
|
|
);
|
|
if (!confirmRes.ok) {
|
|
const raw = (await confirmRes.text()).slice(
|
|
0,
|
|
350,
|
|
);
|
|
const lowerRaw = raw.toLowerCase();
|
|
const maybePending =
|
|
(confirmRes.status === 404 &&
|
|
!lowerRaw.includes(
|
|
"payment intent not found",
|
|
)) ||
|
|
confirmRes.status === 408 ||
|
|
(confirmRes.status === 409 &&
|
|
(lowerRaw.includes(
|
|
"confirmations not enough",
|
|
) ||
|
|
lowerRaw.includes(
|
|
"tx indexed partially",
|
|
)));
|
|
if (maybePending) {
|
|
setPaymentInfo(
|
|
`交易已提交: ${shortAddress(txHashNorm)}，等待链上确认中...`,
|
|
);
|
|
await pollIntentUntilConfirmed(
|
|
intentId,
|
|
authHeaders,
|
|
txHashNorm,
|
|
);
|
|
return;
|
|
}
|
|
throw new Error(
|
|
copy.confirmFailed.replace("{raw}", raw),
|
|
);
|
|
}
|
|
|
|
setPaymentInfo(
|
|
copy.paymentConfirmed.replace(
|
|
"{txHash}",
|
|
shortAddress(txHashNorm),
|
|
),
|
|
);
|
|
trackAppEvent("checkout_succeeded", {
|
|
entry: "account_center",
|
|
plan_code:
|
|
selectedPlan?.plan_code || "pro_monthly",
|
|
intent_id: intentId,
|
|
tx_hash: txHashNorm,
|
|
});
|
|
await loadSnapshot();
|
|
await loadPaymentSnapshot();
|
|
} catch (error) {
|
|
const normalized =
|
|
normalizePaymentError(error);
|
|
if (normalized.pending) {
|
|
setPaymentError(normalized.message);
|
|
} else if (normalized.userRejected) {
|
|
setPaymentInfo(
|
|
approvedInThisRun
|
|
? `${selectedTokenLabel} 授权已完成，本次支付已取消，可直接再次点击支付。`
|
|
: "",
|
|
);
|
|
setPaymentError(normalized.message);
|
|
} else {
|
|
setPaymentInfo(
|
|
approvedInThisRun
|
|
? `${selectedTokenLabel} 授权已完成，但支付未完成，请重试。`
|
|
: "",
|
|
);
|
|
setPaymentError(normalized.message);
|
|
}
|
|
} finally {
|
|
setPaymentBusy(false);
|
|
}
|
|
};
|
|
|
|
// ── createManualPaymentIntent ────────────────────────────
|
|
const createManualPaymentIntent = async () => {
|
|
clearPaymentMessages();
|
|
setManualPayment(null);
|
|
setManualTxHash("");
|
|
setLastIntentId("");
|
|
setLastTxHash("");
|
|
if (!paymentHostAllowed) {
|
|
setPaymentError(
|
|
copy.paymentHostBlocked.replace(
|
|
"{host}",
|
|
allowedPaymentHosts[0] ||
|
|
"polyweather-pro.vercel.app",
|
|
),
|
|
);
|
|
return;
|
|
}
|
|
if (!authIsAuthenticated) {
|
|
setPaymentError(copy.loginBeforePay);
|
|
return;
|
|
}
|
|
if (!paymentConfig?.configured) {
|
|
setPaymentError(copy.payNotReady);
|
|
return;
|
|
}
|
|
|
|
setPaymentBusy(true);
|
|
try {
|
|
const authHeaders = await buildAuthedHeaders(
|
|
true,
|
|
false,
|
|
);
|
|
const createRes = await fetch(
|
|
"/api/payments/intents",
|
|
{
|
|
method: "POST",
|
|
headers: authHeaders,
|
|
body: JSON.stringify({
|
|
plan_code:
|
|
selectedPlan?.plan_code || "pro_monthly",
|
|
payment_mode: "direct",
|
|
token_address:
|
|
resolvedSelectedTokenAddress ||
|
|
undefined,
|
|
use_points: billing.canRedeem && usePoints,
|
|
points_to_consume:
|
|
billing.canRedeem && usePoints
|
|
? billing.pointsUsed
|
|
: 0,
|
|
metadata: {
|
|
source:
|
|
"account_center_manual_transfer",
|
|
frontend_host:
|
|
currentPaymentHost || null,
|
|
account_email: backend?.email || null,
|
|
},
|
|
}),
|
|
},
|
|
);
|
|
if (!createRes.ok) {
|
|
const raw = (await createRes.text()).slice(
|
|
0,
|
|
350,
|
|
);
|
|
throw new Error(
|
|
copy.createManualIntentFailed.replace(
|
|
"{raw}",
|
|
raw,
|
|
),
|
|
);
|
|
}
|
|
const created =
|
|
(await createRes.json()) as CreatedIntent;
|
|
const direct = created.direct_payment;
|
|
const intentId = String(
|
|
created.intent?.intent_id ||
|
|
direct?.intent_id ||
|
|
"",
|
|
);
|
|
if (
|
|
!intentId ||
|
|
!direct?.receiver_address ||
|
|
!direct?.amount_usdc
|
|
) {
|
|
throw new Error(copy.manualPaymentInvalid);
|
|
}
|
|
assertExpectedPaymentReceiver(
|
|
direct.receiver_address,
|
|
"manual payment receiver",
|
|
);
|
|
setLastIntentId(intentId);
|
|
setManualPayment(direct);
|
|
setPaymentMethodTab("manual");
|
|
setShowOverlay(false);
|
|
setPaymentInfo(
|
|
`手动转账订单已创建：请在 Polygon 网络转 ${direct.amount_usdc} ${direct.token_symbol || selectedTokenLabel} 到 ${direct.receiver_address}，请在下方【手动转账】面板中查看详情并复制地址，完成后提交 tx hash。`,
|
|
);
|
|
trackAppEvent("checkout_started", {
|
|
entry: "account_center_manual_transfer",
|
|
plan_code:
|
|
selectedPlan?.plan_code || "pro_monthly",
|
|
intent_id: intentId,
|
|
payment_mode: "direct",
|
|
use_points: billing.canRedeem && usePoints,
|
|
pay_amount_usd: billing.payAmount,
|
|
});
|
|
} catch (error) {
|
|
setPaymentError(
|
|
normalizePaymentError(error).message,
|
|
);
|
|
} finally {
|
|
setPaymentBusy(false);
|
|
}
|
|
};
|
|
|
|
// ── submitManualPaymentTx ──────────────────────────────
|
|
const submitManualPaymentTx = async () => {
|
|
const txHashNorm = String(manualTxHash || "")
|
|
.trim()
|
|
.toLowerCase();
|
|
const intentId = String(
|
|
lastIntentId || manualPayment?.intent_id || "",
|
|
).trim();
|
|
if (!intentId || !manualPayment) {
|
|
setPaymentError(copy.manualOrderRequired);
|
|
return;
|
|
}
|
|
if (
|
|
!txHashNorm.startsWith("0x") ||
|
|
txHashNorm.length !== 66
|
|
) {
|
|
setPaymentError(copy.txHashRequired);
|
|
return;
|
|
}
|
|
setPaymentBusy(true);
|
|
setPaymentError("");
|
|
try {
|
|
const authHeaders = await buildAuthedHeaders(
|
|
true,
|
|
false,
|
|
);
|
|
const submitRes = await fetch(
|
|
`/api/payments/intents/${intentId}/submit`,
|
|
{
|
|
method: "POST",
|
|
headers: authHeaders,
|
|
body: JSON.stringify({
|
|
tx_hash: txHashNorm,
|
|
}),
|
|
},
|
|
);
|
|
if (!submitRes.ok) {
|
|
const raw = (await submitRes.text()).slice(
|
|
0,
|
|
350,
|
|
);
|
|
if (submitRes.status === 409) {
|
|
await handleSubmit409(
|
|
intentId,
|
|
txHashNorm,
|
|
raw,
|
|
);
|
|
return;
|
|
}
|
|
throw new Error(
|
|
copy.submitTxFailed.replace(
|
|
"{raw}",
|
|
raw,
|
|
),
|
|
);
|
|
}
|
|
const confirmRes = await fetch(
|
|
`/api/payments/intents/${intentId}/confirm`,
|
|
{
|
|
method: "POST",
|
|
headers: authHeaders,
|
|
body: JSON.stringify({
|
|
tx_hash: txHashNorm,
|
|
}),
|
|
},
|
|
);
|
|
if (!confirmRes.ok) {
|
|
const raw = (await confirmRes.text()).slice(
|
|
0,
|
|
350,
|
|
);
|
|
const lowerRaw = raw.toLowerCase();
|
|
const maybePending =
|
|
confirmRes.status === 408 ||
|
|
(confirmRes.status === 409 &&
|
|
(lowerRaw.includes(
|
|
"confirmations not enough",
|
|
) ||
|
|
lowerRaw.includes(
|
|
"tx indexed partially",
|
|
)));
|
|
if (maybePending) {
|
|
setPaymentInfo(
|
|
`交易已提交: ${shortAddress(txHashNorm)}，等待链上确认中...`,
|
|
);
|
|
await pollIntentUntilConfirmed(
|
|
intentId,
|
|
authHeaders,
|
|
txHashNorm,
|
|
);
|
|
return;
|
|
}
|
|
throw new Error(
|
|
copy.confirmFailed.replace(
|
|
"{raw}",
|
|
raw,
|
|
),
|
|
);
|
|
}
|
|
setLastTxHash(txHashNorm);
|
|
setPaymentInfo(
|
|
copy.paymentConfirmed.replace(
|
|
"{txHash}",
|
|
shortAddress(txHashNorm),
|
|
),
|
|
);
|
|
setManualPayment(null);
|
|
setManualTxHash("");
|
|
setTxValidation({
|
|
loading: false,
|
|
checked: false,
|
|
});
|
|
trackAppEvent("checkout_succeeded", {
|
|
entry:
|
|
"account_center_manual_transfer",
|
|
plan_code:
|
|
selectedPlan?.plan_code ||
|
|
"pro_monthly",
|
|
intent_id: intentId,
|
|
tx_hash: txHashNorm,
|
|
});
|
|
await loadSnapshot();
|
|
await loadPaymentSnapshot();
|
|
} catch (error) {
|
|
setPaymentError(
|
|
normalizePaymentError(error).message,
|
|
);
|
|
} finally {
|
|
setPaymentBusy(false);
|
|
}
|
|
};
|
|
|
|
// ── validateTxHash ────────────────────────────────────
|
|
const validateTxHash = useCallback(
|
|
async (intentId: string, hash: string) => {
|
|
const hashNorm = String(hash || "")
|
|
.trim()
|
|
.toLowerCase();
|
|
if (
|
|
!hashNorm.startsWith("0x") ||
|
|
hashNorm.length !== 66
|
|
) {
|
|
setTxValidation({
|
|
loading: false,
|
|
checked: false,
|
|
});
|
|
return;
|
|
}
|
|
setTxValidation({
|
|
loading: true,
|
|
checked: false,
|
|
});
|
|
try {
|
|
const headers = await buildAuthedHeaders(
|
|
true,
|
|
false,
|
|
);
|
|
const res = await fetch(
|
|
`/api/payments/intents/${intentId}/validate`,
|
|
{
|
|
method: "POST",
|
|
headers,
|
|
body: JSON.stringify({
|
|
tx_hash: hashNorm,
|
|
}),
|
|
},
|
|
);
|
|
const json = (await res.json()) as {
|
|
valid?: boolean;
|
|
reason?: string;
|
|
detail?: string;
|
|
checks?: Record<string, unknown>;
|
|
};
|
|
setTxValidation({
|
|
loading: false,
|
|
checked: true,
|
|
valid: Boolean(json.valid),
|
|
reason: json.reason,
|
|
detail: json.detail,
|
|
checks: json.checks,
|
|
});
|
|
} catch {
|
|
setTxValidation({
|
|
loading: false,
|
|
checked: false,
|
|
});
|
|
}
|
|
},
|
|
[buildAuthedHeaders],
|
|
);
|
|
|
|
// ── handleOverlayCheckout ──────────────────────────────
|
|
const handleOverlayCheckout = async () => {
|
|
if (!paymentHostAllowed) {
|
|
setPaymentError(
|
|
copy.paymentHostBlocked.replace(
|
|
"{host}",
|
|
allowedPaymentHosts[0] ||
|
|
"polyweather-pro.vercel.app",
|
|
),
|
|
);
|
|
return;
|
|
}
|
|
if (!authIsAuthenticated) {
|
|
setPaymentError(copy.loginBeforePay);
|
|
return;
|
|
}
|
|
if (!hasPayingWallet) {
|
|
setPaymentInfo(copy.openBindFlow);
|
|
const bound = await connectAndBindWallet(
|
|
providerMode,
|
|
{ openOverlayAfterBind: true },
|
|
);
|
|
if (!bound) return;
|
|
setPaymentInfo(copy.walletBoundCreatingOrder);
|
|
await createIntentAndPay();
|
|
return;
|
|
}
|
|
await createIntentAndPay();
|
|
};
|
|
|
|
// ── openTelegramBotBindLink ──────────────────────────────
|
|
const openTelegramBotBindLink = async () => {
|
|
setTelegramBindOpening(true);
|
|
setPaymentError("");
|
|
setTelegramBindUrl("");
|
|
const popup = window.open(
|
|
"about:blank",
|
|
"_blank",
|
|
"noopener,noreferrer",
|
|
);
|
|
try {
|
|
const authHeaders = await buildAuthedHeaders(
|
|
true,
|
|
false,
|
|
);
|
|
const res = await fetch(
|
|
"/api/auth/telegram/bot-bind-link",
|
|
{
|
|
method: "POST",
|
|
headers: authHeaders,
|
|
},
|
|
);
|
|
if (!res.ok) {
|
|
const raw = (await res.text()).slice(0, 300);
|
|
throw new Error(
|
|
raw || copy.telegramBindFailed,
|
|
);
|
|
}
|
|
const data = (await res.json()) as {
|
|
bot_url?: string;
|
|
};
|
|
const botUrl = String(data.bot_url || "").trim();
|
|
if (!botUrl)
|
|
throw new Error(copy.telegramBindLinkMissing);
|
|
if (popup && !popup.closed) {
|
|
popup.location.href = botUrl;
|
|
setPaymentInfo(copy.telegramBindClickHint);
|
|
} else {
|
|
setPaymentInfo(copy.telegramPopupBlocked);
|
|
setTelegramBindUrl(botUrl);
|
|
}
|
|
} catch (error) {
|
|
if (popup && !popup.closed) popup.close();
|
|
setPaymentError(
|
|
normalizePaymentError(error).message,
|
|
);
|
|
} finally {
|
|
setTelegramBindOpening(false);
|
|
}
|
|
};
|
|
|
|
// ── bind_token URL effect ──────────────────────────────
|
|
useEffect(() => {
|
|
if (!authIsAuthenticated) return;
|
|
const params = new URLSearchParams(
|
|
window.location.search,
|
|
);
|
|
const token = params.get("bind_token");
|
|
if (!token) return;
|
|
const url = new URL(window.location.href);
|
|
url.searchParams.delete("bind_token");
|
|
window.history.replaceState(
|
|
null,
|
|
"",
|
|
url.toString(),
|
|
);
|
|
(async () => {
|
|
setPaymentError("");
|
|
setPaymentInfo("");
|
|
try {
|
|
const authHeaders = await buildAuthedHeaders(
|
|
true,
|
|
false,
|
|
);
|
|
const res = await fetch(
|
|
"/api/auth/telegram/bind-by-token",
|
|
{
|
|
method: "POST",
|
|
headers: authHeaders,
|
|
body: JSON.stringify({ token }),
|
|
},
|
|
);
|
|
if (!res.ok) {
|
|
const raw = (await res.text()).slice(
|
|
0,
|
|
350,
|
|
);
|
|
throw new Error(
|
|
copy.bindFailed.replace("{raw}", raw),
|
|
);
|
|
}
|
|
const data = (await res.json()) as {
|
|
telegram_pricing?: TelegramPricing | null;
|
|
};
|
|
if (
|
|
data.telegram_pricing?.is_group_member
|
|
) {
|
|
const amount =
|
|
data.telegram_pricing.amount_usdc ||
|
|
"10";
|
|
setPaymentInfo(
|
|
copy.telegramVerifySuccess.replace(
|
|
"{amount}",
|
|
amount,
|
|
),
|
|
);
|
|
}
|
|
await loadSnapshot();
|
|
await loadPaymentSnapshot();
|
|
} catch (error) {
|
|
setPaymentError(
|
|
normalizePaymentError(error).message,
|
|
);
|
|
}
|
|
})();
|
|
}, [
|
|
authIsAuthenticated,
|
|
buildAuthedHeaders,
|
|
loadPaymentSnapshot,
|
|
loadSnapshot,
|
|
]);
|
|
|
|
// ==========================================================
|
|
return {
|
|
// State from usePaymentState
|
|
paymentBusy,
|
|
paymentInfo,
|
|
paymentError,
|
|
lastIntentId,
|
|
lastTxHash,
|
|
lastPaymentStartedAt,
|
|
telegramBindOpening,
|
|
telegramBindUrl,
|
|
manualPayment,
|
|
manualTxHash,
|
|
txValidation,
|
|
paymentMethodTab,
|
|
clearPaymentMessages,
|
|
clearPaymentState,
|
|
|
|
// Setters from usePaymentState (needed by component render)
|
|
setPaymentBusy,
|
|
setPaymentInfo,
|
|
setPaymentError,
|
|
setLastIntentId,
|
|
setLastTxHash,
|
|
setLastPaymentStartedAt,
|
|
setTelegramBindOpening,
|
|
setPaymentMethodTab,
|
|
setManualPayment,
|
|
setManualTxHash,
|
|
setTxValidation,
|
|
|
|
// Additional state
|
|
paymentConfig,
|
|
boundWallets,
|
|
walletAddress,
|
|
selectedPlanCode,
|
|
selectedTokenAddress,
|
|
selectedWallet,
|
|
providerMode,
|
|
injectedProviderOptions,
|
|
selectedInjectedProviderKey,
|
|
reconcileBusy,
|
|
|
|
// Setters for shared state
|
|
setSelectedTokenAddress,
|
|
setSelectedWallet,
|
|
setSelectedInjectedProviderKey,
|
|
setProviderMode,
|
|
|
|
// Derived values
|
|
authUserId,
|
|
authIsAuthenticated,
|
|
paymentReadyForRecovery,
|
|
hasRecentPaymentRecovery,
|
|
allowedPaymentHosts,
|
|
currentPaymentHost,
|
|
paymentHostAllowed,
|
|
selectedPlan,
|
|
selectedPaymentToken,
|
|
selectedTokenLabel,
|
|
availableTokenList,
|
|
effectivePlanList,
|
|
resolvedSelectedTokenAddress,
|
|
paymentReceiverAddress,
|
|
paymentWalletLabel,
|
|
hasPayingWallet,
|
|
totalPoints,
|
|
billing,
|
|
|
|
// Callbacks
|
|
loadSnapshot,
|
|
loadPaymentSnapshot,
|
|
connectAndBindWallet,
|
|
handleUnbindWallet,
|
|
createIntentAndPay,
|
|
createManualPaymentIntent,
|
|
submitManualPaymentTx,
|
|
validateTxHash,
|
|
handleOverlayCheckout,
|
|
openTelegramBotBindLink,
|
|
};
|
|
}
|