nolo-cli 0.1.31 → 0.1.32

package/server/payments/crypto/cryptoUsdcBaseScanner.ts

@@ -1,272 +0,0 @@
-import { rechargeUserBalance } from "../../../auth/server/recharge";
-import { getServerAuthorityStore } from "../../../database/server/db";
-import {
-  getCryptoUsdcBaseConfig,
-  parseUsdcUnitsToCredits,
-  toAddressTopic,
-  type CryptoUsdcBaseConfig,
-} from "./cryptoUsdcBaseConfig";
-
-export const TRANSFER_TOPIC =
-  "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef";
-
-type EvmLog = {
-  address: string;
-  blockNumber: string;
-  transactionHash: string;
-  logIndex: string;
-  topics: string[];
-  data: string;
-};
-
-type DepositAddressAssignment = {
-  userId: string;
-  address: string;
-};
-
-type ProcessedDepositEvent = {
-  eventId: string;
-  userId: string;
-  fromAddress: string;
-  toAddress: string;
-  txHash: string;
-  logIndex: number;
-  blockNumber: number;
-  usdcUnits: string;
-  credits: number;
-  status: "credited" | "ignored_below_min" | "failed";
-  error?: string;
-  createdAt: number;
-};
-
-type ProcessCryptoUsdcBaseLogsOptions = {
-  logs: EvmLog[];
-  config: Pick<
-    CryptoUsdcBaseConfig,
-    "chainId" | "tokenContract" | "creditsPerUsdc" | "minCredits"
-  >;
-  loadAssignmentByAddress: (
-    address: string
-  ) => Promise<DepositAddressAssignment | null>;
-  hasProcessedEvent: (eventId: string) => Promise<boolean>;
-  recordProcessedEvent: (event: ProcessedDepositEvent) => Promise<void>;
-  creditUser: (event: ProcessedDepositEvent) => Promise<{
-    success: boolean;
-    error?: string;
-    txId?: string;
-  }>;
-};
-
-type ScanStats = {
-  scanned: number;
-  matched: number;
-  credited: number;
-  ignoredBelowMinimum: number;
-  skippedDuplicate: number;
-  skippedUnassigned: number;
-  failed: number;
-};
-
-const emptyStats = (): ScanStats => ({
-  scanned: 0,
-  matched: 0,
-  credited: 0,
-  ignoredBelowMinimum: 0,
-  skippedDuplicate: 0,
-  skippedUnassigned: 0,
-  failed: 0,
-});
-
-const decodeAddressTopic = (topic: string) => {
-  const value = topic.toLowerCase();
-  if (!/^0x[0-9a-f]{64}$/.test(value)) return "";
-  return `0x${value.slice(26)}`;
-};
-
-const hexToBigInt = (value: string) => BigInt(value || "0x0");
-
-const hexToNumber = (value: string) => Number(hexToBigInt(value));
-
-const eventIdForLog = (chainId: number, txHash: string, logIndex: number) =>
-  `crypto_usdc_base_${chainId}_${txHash.toLowerCase()}_${logIndex}`;
-
-export const processCryptoUsdcBaseLogs = async (
-  options: ProcessCryptoUsdcBaseLogsOptions
-) => {
-  const stats = emptyStats();
-  const tokenContract = options.config.tokenContract.toLowerCase();
-
-  for (const log of options.logs) {
-    stats.scanned += 1;
-    if (log.address.toLowerCase() !== tokenContract) continue;
-    if (log.topics[0]?.toLowerCase() !== TRANSFER_TOPIC) continue;
-    if (!log.topics[1] || !log.topics[2]) continue;
-
-    stats.matched += 1;
-    const fromAddress = decodeAddressTopic(log.topics[1]);
-    const toAddress = decodeAddressTopic(log.topics[2]);
-    const assignment = await options.loadAssignmentByAddress(toAddress);
-    if (!assignment) {
-      stats.skippedUnassigned += 1;
-      continue;
-    }
-
-    const logIndex = hexToNumber(log.logIndex);
-    const eventId = eventIdForLog(
-      options.config.chainId,
-      log.transactionHash,
-      logIndex
-    );
-    if (await options.hasProcessedEvent(eventId)) {
-      stats.skippedDuplicate += 1;
-      continue;
-    }
-
-    const usdcUnits = hexToBigInt(log.data);
-    const credits = parseUsdcUnitsToCredits(
-      usdcUnits,
-      options.config.creditsPerUsdc
-    );
-    const event: ProcessedDepositEvent = {
-      eventId,
-      userId: assignment.userId,
-      fromAddress,
-      toAddress,
-      txHash: log.transactionHash.toLowerCase(),
-      logIndex,
-      blockNumber: hexToNumber(log.blockNumber),
-      usdcUnits: usdcUnits.toString(),
-      credits,
-      status: credits >= options.config.minCredits ? "credited" : "ignored_below_min",
-      createdAt: Date.now(),
-    };
-
-    if (event.status === "ignored_below_min") {
-      await options.recordProcessedEvent(event);
-      stats.ignoredBelowMinimum += 1;
-      continue;
-    }
-
-    const recharge = await options.creditUser(event);
-    if (recharge.success || recharge.error === "Duplicate transaction") {
-      await options.recordProcessedEvent(event);
-      stats.credited += 1;
-      continue;
-    }
-
-    await options.recordProcessedEvent({
-      ...event,
-      status: "failed",
-      error: recharge.error || "Recharge failed",
-    });
-    stats.failed += 1;
-  }
-
-  return stats;
-};
-
-const addressAssignmentKey = (address: string) =>
-  `crypto-usdc-base-address-${address.toLowerCase()}`;
-const processedEventKey = (eventId: string) =>
-  `crypto-usdc-base-event-${eventId}`;
-const checkpointKey = "crypto-usdc-base-checkpoint";
-
-const getCryptoUsdcBaseScannerStore = () => getServerAuthorityStore();
-
-const rpcCall = async <T>(
-  rpcUrl: string,
-  method: string,
-  params: unknown[]
-): Promise<T> => {
-  const response = await fetch(rpcUrl, {
-    method: "POST",
-    headers: { "Content-Type": "application/json" },
-    body: JSON.stringify({ jsonrpc: "2.0", id: Date.now(), method, params }),
-  });
-  const payload = await response.json();
-  if (payload?.error) {
-    throw new Error(payload.error.message || `RPC ${method} failed`);
-  }
-  return payload.result as T;
-};
-
-const getAssignedDepositAddresses = async () => {
-  const assignments: DepositAddressAssignment[] = [];
-  const iter = getCryptoUsdcBaseScannerStore().iterator({
-    gte: "crypto-usdc-base-address-",
-    lt: "crypto-usdc-base-address-\xff",
-  });
-  for await (const [, value] of iter) {
-    assignments.push(value as DepositAddressAssignment);
-  }
-  return assignments;
-};
-
-export const scanCryptoUsdcBaseDeposits = async () => {
-  const config = getCryptoUsdcBaseConfig();
-  if (!config.configured) return { configured: false, ...emptyStats() };
-
-  const assignments = await getAssignedDepositAddresses();
-  if (assignments.length === 0) {
-    return { configured: true, fromBlock: null, toBlock: null, ...emptyStats() };
-  }
-
-  const currentBlockHex = await rpcCall<string>(
-    config.rpcUrl,
-    "eth_blockNumber",
-    []
-  );
-  const currentBlock = hexToNumber(currentBlockHex);
-  const toBlock = currentBlock - config.confirmations;
-  if (toBlock <= 0) return { configured: true, fromBlock: null, toBlock, ...emptyStats() };
-
-  const checkpoint = (await getCryptoUsdcBaseScannerStore().get(checkpointKey).catch(() => null)) as
-    | { lastScannedBlock?: number }
-    | null;
-  const fromBlock = checkpoint
-    ? Math.max(0, Number(checkpoint.lastScannedBlock || 0) + 1)
-    : Math.max(0, config.startBlock ?? toBlock);
-  if (fromBlock > toBlock) {
-    return { configured: true, fromBlock, toBlock, ...emptyStats() };
-  }
-
-  const logs = await rpcCall<EvmLog[]>(config.rpcUrl, "eth_getLogs", [
-    {
-      fromBlock: `0x${fromBlock.toString(16)}`,
-      toBlock: `0x${toBlock.toString(16)}`,
-      address: config.tokenContract,
-      topics: [
-        TRANSFER_TOPIC,
-        null,
-        assignments.map((assignment) => toAddressTopic(assignment.address)),
-      ],
-    },
-  ]);
-
-  const stats = await processCryptoUsdcBaseLogs({
-    logs,
-    config,
-    loadAssignmentByAddress: async (address) =>
-      ((await getCryptoUsdcBaseScannerStore().get(addressAssignmentKey(address)).catch(() => null)) as
-        | DepositAddressAssignment
-        | null),
-    hasProcessedEvent: async (eventId) =>
-      Boolean(await getCryptoUsdcBaseScannerStore().get(processedEventKey(eventId)).catch(() => null)),
-    recordProcessedEvent: async (event) => {
-      await getCryptoUsdcBaseScannerStore().put(processedEventKey(event.eventId), event);
-    },
-    creditUser: async (event) =>
-      rechargeUserBalance(
-        event.userId,
-        event.credits,
-        "crypto_usdc_base_recharge",
-        event.eventId
-      ),
-  });
-
-  await getCryptoUsdcBaseScannerStore().put(checkpointKey, {
-    lastScannedBlock: toBlock,
-    updatedAt: Date.now(),
-  });
-  return { configured: true, fromBlock, toBlock, ...stats };
-};

package/server/payments/crypto/cryptoUsdcBaseWatcher.ts

@@ -1,40 +0,0 @@
-import { getCryptoUsdcBaseConfig } from "./cryptoUsdcBaseConfig";
-import { scanCryptoUsdcBaseDeposits } from "./cryptoUsdcBaseScanner";
-
-let scanTimer: ReturnType<typeof setInterval> | null = null;
-let scanRunning = false;
-
-const runScan = async () => {
-  if (scanRunning) return;
-  scanRunning = true;
-  try {
-    await scanCryptoUsdcBaseDeposits();
-  } catch (error) {
-    console.error("[crypto-usdc-base] scan failed:", error);
-  } finally {
-    scanRunning = false;
-  }
-};
-
-export const startCryptoUsdcBaseWatcher = () => {
-  if (scanTimer) return;
-  const config = getCryptoUsdcBaseConfig();
-  if (!config.configured) {
-    console.log("[crypto-usdc-base] watcher disabled");
-    return;
-  }
-  void runScan();
-  scanTimer = setInterval(() => {
-    void runScan();
-  }, config.scanIntervalMs);
-  console.log(
-    `[crypto-usdc-base] watcher started (interval: ${config.scanIntervalMs}ms)`
-  );
-};
-
-export const stopCryptoUsdcBaseWatcher = () => {
-  if (!scanTimer) return;
-  clearInterval(scanTimer);
-  scanTimer = null;
-  console.log("[crypto-usdc-base] watcher stopped");
-};

package/server/payments/crypto/cryptoUsdtTronAddressPool.ts

@@ -1,49 +0,0 @@
-export type CryptoUsdtTronAddressAssignment = {
-  userId: string;
-  address: string;
-  assignedAt: number;
-};
-
-type AddressPoolStore = {
-  get: (key: string) => Promise<unknown | null>;
-  put: (key: string, value: unknown) => Promise<void>;
-};
-
-type AssignAddressOptions = {
-  userId: string;
-  addressPool: string[];
-} & AddressPoolStore;
-
-export const cryptoUsdtTronUserAddressKey = (userId: string) =>
-  `crypto-usdt-tron-user-address-${userId}`;
-
-export const cryptoUsdtTronAddressKey = (address: string) =>
-  `crypto-usdt-tron-address-${address}`;
-
-export const assignCryptoUsdtTronAddress = async (
-  options: AssignAddressOptions
-):
-  | Promise<{ ok: true; assignment: CryptoUsdtTronAddressAssignment }>
-  | Promise<{ ok: false; code: "CRYPTO_ADDRESS_POOL_EXHAUSTED" }> => {
-  const existing = (await options.get(
-    cryptoUsdtTronUserAddressKey(options.userId)
-  )) as CryptoUsdtTronAddressAssignment | null;
-  if (existing?.address) return { ok: true, assignment: existing };
-
-  for (const address of options.addressPool) {
-    const addressKey = cryptoUsdtTronAddressKey(address);
-    const current = await options.get(addressKey);
-    if (current) continue;
-
-    const assignment: CryptoUsdtTronAddressAssignment = {
-      userId: options.userId,
-      address,
-      assignedAt: Date.now(),
-    };
-    await options.put(cryptoUsdtTronUserAddressKey(options.userId), assignment);
-    await options.put(addressKey, assignment);
-    return { ok: true, assignment };
-  }
-
-  return { ok: false, code: "CRYPTO_ADDRESS_POOL_EXHAUSTED" };
-};

package/server/payments/crypto/cryptoUsdtTronConfig.ts

@@ -1,120 +0,0 @@
-export const TRON_NETWORK_NAME = "TRON";
-export const TRON_USDT_CONTRACT = "TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t";
-export const USDT_DECIMALS = 6;
-
-type CryptoUsdtTronEnv = Pick<
-  NodeJS.ProcessEnv,
-  | "CRYPTO_USDT_TRON_ENABLED"
-  | "CRYPTO_USDT_TRON_API_URL"
-  | "CRYPTO_USDT_TRON_API_KEY"
-  | "CRYPTO_USDT_TRON_DEPOSIT_ADDRESSES"
-  | "CRYPTO_USDT_TRON_CONFIRMATIONS"
-  | "CRYPTO_USDT_TRON_MIN_CREDITS"
-  | "CRYPTO_USDT_TRON_CREDITS_PER_USDT"
-  | "CRYPTO_USDT_TRON_SCAN_INTERVAL_MS"
-  | "CRYPTO_USDT_TRON_SCAN_SECRET"
-  | "CRYPTO_USDT_TRON_START_TIMESTAMP"
-  | "CRYPTO_USDT_TRON_TOKEN_CONTRACT"
->;
-
-export type CryptoUsdtTronConfig = {
-  configured: boolean;
-  enabled: boolean;
-  network: typeof TRON_NETWORK_NAME;
-  token: "USDT";
-  tokenContract: string;
-  apiUrl: string;
-  apiKey?: string;
-  depositAddresses: string[];
-  confirmations: number;
-  minCredits: number;
-  creditsPerUsdt: number;
-  scanIntervalMs: number;
-  scanSecret?: string;
-  startTimestamp?: number;
-};
-
-const parsePositiveNumber = (value: string | undefined, fallback: number) => {
-  const parsed = Number(value);
-  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
-};
-
-const parsePositiveInteger = (value: string | undefined, fallback: number) => {
-  const parsed = Number(value);
-  return Number.isInteger(parsed) && parsed > 0 ? parsed : fallback;
-};
-
-const parseNonNegativeInteger = (value: string | undefined) => {
-  const parsed = Number(value);
-  return Number.isInteger(parsed) && parsed >= 0 ? parsed : undefined;
-};
-
-export const normalizeTronAddress = (value: string) => {
-  const address = value.trim();
-  if (!/^T[1-9A-HJ-NP-Za-km-z]{33}$/.test(address)) {
-    throw new Error(`Invalid TRON address: ${value}`);
-  }
-  return address;
-};
-
-const parseAddressList = (value: string | undefined) => {
-  if (!value?.trim()) return [];
-  const seen = new Set<string>();
-  return value
-    .split(",")
-    .map((entry) => normalizeTronAddress(entry))
-    .filter((address) => {
-      if (seen.has(address)) return false;
-      seen.add(address);
-      return true;
-    });
-};
-
-export const parseUsdtUnitsToCredits = (
-  units: bigint,
-  creditsPerUsdt: number
-) =>
-  Math.round((Number(units) / 10 ** USDT_DECIMALS) * creditsPerUsdt * 1e8) /
-  1e8;
-
-export const getCryptoUsdtTronConfig = (
-  env: CryptoUsdtTronEnv = process.env
-): CryptoUsdtTronConfig => {
-  const enabled = env.CRYPTO_USDT_TRON_ENABLED === "1";
-  const apiUrl = (
-    env.CRYPTO_USDT_TRON_API_URL?.trim() || "https://api.trongrid.io"
-  ).replace(/\/+$/, "");
-  const depositAddresses = parseAddressList(
-    env.CRYPTO_USDT_TRON_DEPOSIT_ADDRESSES
-  );
-  const tokenContract = normalizeTronAddress(
-    env.CRYPTO_USDT_TRON_TOKEN_CONTRACT || TRON_USDT_CONTRACT
-  );
-  return {
-    configured: enabled && Boolean(apiUrl) && depositAddresses.length > 0,
-    enabled,
-    network: TRON_NETWORK_NAME,
-    token: "USDT",
-    tokenContract,
-    apiUrl,
-    apiKey: env.CRYPTO_USDT_TRON_API_KEY?.trim() || undefined,
-    depositAddresses,
-    confirmations: parsePositiveInteger(
-      env.CRYPTO_USDT_TRON_CONFIRMATIONS,
-      20
-    ),
-    minCredits: parsePositiveNumber(env.CRYPTO_USDT_TRON_MIN_CREDITS, 1),
-    creditsPerUsdt: parsePositiveNumber(
-      env.CRYPTO_USDT_TRON_CREDITS_PER_USDT,
-      5
-    ),
-    scanIntervalMs: parsePositiveInteger(
-      env.CRYPTO_USDT_TRON_SCAN_INTERVAL_MS,
-      60_000
-    ),
-    scanSecret: env.CRYPTO_USDT_TRON_SCAN_SECRET?.trim() || undefined,
-    startTimestamp: parseNonNegativeInteger(
-      env.CRYPTO_USDT_TRON_START_TIMESTAMP
-    ),
-  };
-};

package/server/payments/crypto/cryptoUsdtTronPaymentProvider.ts

@@ -1,135 +0,0 @@
-import { CORS_HEADERS_AUTH } from "../../../auth/utils";
-import { readUserFromRequest } from "../../../auth/server/token";
-import { isProduction } from "../../../app/utils/env";
-import { getServerAuthorityStore } from "../../../database/server/db";
-import type { PaymentProvider } from "../paymentProvider";
-import {
-  assignCryptoUsdtTronAddress,
-  cryptoUsdtTronAddressKey,
-  cryptoUsdtTronUserAddressKey,
-} from "./cryptoUsdtTronAddressPool";
-import { getCryptoUsdtTronConfig } from "./cryptoUsdtTronConfig";
-import { scanCryptoUsdtTronDeposits } from "./cryptoUsdtTronScanner";
-
-const jsonResponse = (body: unknown, status = 200, headers?: HeadersInit) =>
-  new Response(JSON.stringify(body), {
-    status,
-    headers: {
-      "Content-Type": "application/json",
-      ...CORS_HEADERS_AUTH,
-      ...headers,
-    },
-  });
-
-const jsonError = (
-  status: number,
-  message: string,
-  code: string,
-  details?: unknown
-) => jsonResponse({ error: { message, code, details } }, status);
-
-const getCryptoUsdtTronStore = () => getServerAuthorityStore();
-
-const readDb = async (key: string) => getCryptoUsdtTronStore().get(key).catch(() => null);
-
-export const handleCryptoUsdtTronConfig = async () => {
-  const config = getCryptoUsdtTronConfig();
-  return jsonResponse({
-    configured: config.configured,
-    enabled: config.enabled,
-    provider: "crypto_usdt_tron",
-    network: config.network,
-    token: config.token,
-    tokenContract: config.tokenContract,
-    confirmations: config.confirmations,
-    minCredits: config.minCredits,
-    creditsPerUsdt: config.creditsPerUsdt,
-    depositAddressPoolSize: config.depositAddresses.length,
-    apiUrlConfigured: Boolean(config.apiUrl),
-  });
-};
-
-export const handleCreateCryptoUsdtTronOrder = async (req: Request) => {
-  const config = getCryptoUsdtTronConfig();
-  if (!config.configured) {
-    return jsonError(
-      503,
-      "TRON USDT payment is not configured.",
-      "CRYPTO_USDT_TRON_NOT_CONFIGURED",
-      {
-        needs: [
-          "CRYPTO_USDT_TRON_ENABLED=1",
-          "CRYPTO_USDT_TRON_API_URL",
-          "CRYPTO_USDT_TRON_DEPOSIT_ADDRESSES",
-        ],
-      }
-    );
-  }
-
-  const authResult = await readUserFromRequest(req);
-  const userId = String(authResult?.userId || "");
-  if (!userId) {
-    return jsonError(401, "Authentication required.", "AUTH_REQUIRED");
-  }
-
-  const assignment = await assignCryptoUsdtTronAddress({
-    userId,
-    addressPool: config.depositAddresses,
-    get: readDb,
-    put: async (key, value) => {
-      await getCryptoUsdtTronStore().put(key, value);
-    },
-  });
-  if (!assignment.ok) {
-    return jsonError(
-      503,
-      "No TRON USDT deposit address is available.",
-      assignment.code
-    );
-  }
-
-  return jsonResponse({
-    success: true,
-    provider: "crypto_usdt_tron",
-    network: config.network,
-    token: config.token,
-    tokenContract: config.tokenContract,
-    depositAddress: assignment.assignment.address,
-    minCredits: config.minCredits,
-    creditsPerUsdt: config.creditsPerUsdt,
-    confirmations: config.confirmations,
-    amountMode: "actual_received",
-  });
-};
-
-export const handleCryptoUsdtTronWebhook = async (req: Request) => {
-  const config = getCryptoUsdtTronConfig();
-  if (config.scanSecret) {
-    const secret = req.headers.get("x-crypto-scan-secret");
-    if (secret !== config.scanSecret) {
-      return new Response("Invalid scan secret", {
-        status: 401,
-        headers: CORS_HEADERS_AUTH,
-      });
-    }
-  } else if (isProduction) {
-    return new Response("Scan secret is required in production", {
-      status: 403,
-      headers: CORS_HEADERS_AUTH,
-    });
-  }
-  const result = await scanCryptoUsdtTronDeposits();
-  return jsonResponse(result);
-};
-
-export const cryptoUsdtTronPaymentProvider: PaymentProvider = {
-  path: "crypto-usdt-tron",
-  handleConfig: handleCryptoUsdtTronConfig,
-  handleCreateCheckout: handleCreateCryptoUsdtTronOrder,
-  handleWebhook: handleCryptoUsdtTronWebhook,
-};
-
-export const __cryptoUsdtTronKeysForTest = {
-  cryptoUsdtTronUserAddressKey,
-  cryptoUsdtTronAddressKey,
-};