[RELEASE] fix batched USDC transactions

packages/app/server/src/handlers.ts

@@ -25,7 +25,8 @@ import { Decimal } from '@prisma/client/runtime/library';
 import logger from 'logger';
 import { Request, Response } from 'express';
 import { ProviderType } from 'providers/ProviderType';
-import { safeFundRepo } from 'services/fund-repo/fundRepoService';
+import { safeFundRepoIfWorthwhile } from 'services/fund-repo/fundRepoService';
+import { applyMaxCostMarkup } from 'services/PricingService';
 
 export async function refund(
   paymentAmountDecimal: Decimal,
@@ -116,16 +117,42 @@ export async function finalize(
   transaction: Transaction,
   payload: ExactEvmPayload
 ) {
+
+  const transactionCostWithMarkup = applyMaxCostMarkup(transaction.rawTransactionCost);
+
+  // rawTransactionCost is what we pay to OpenAI
+  // transactionCostWithMarkup is what we charge the user
+  // markup is the difference between the two, and is sent with fundRepo (not every time, just when it is worthwhile to send a payment)
+
+  // The user should be refunded paymentAmountDecimal - transactionCostWithMarkup\
+
+
   const refundAmount = calculateRefundAmount(
     paymentAmountDecimal,
-    transaction.rawTransactionCost
+    transactionCostWithMarkup
   );
+  logger.info(`Payment amount decimal: ${paymentAmountDecimal.toNumber()} USD`)
+  logger.info(`Refunding ${refundAmount.toNumber()} USD`)
+  logger.info(`Transaction cost with markup: ${transactionCostWithMarkup.toNumber()} USD`)
+  logger.info(`Transaction cost: ${transaction.rawTransactionCost.toNumber()} USD`)
+
 
   if (!refundAmount.equals(0) && refundAmount.greaterThan(0)) {
     const refundAmountUsdcBigInt = decimalToUsdcBigInt(refundAmount);
     const authPayload = payload.authorization;
     await transfer(authPayload.from as `0x${string}`, refundAmountUsdcBigInt);
   }
+
+  const markUpAmount = transactionCostWithMarkup.minus(transaction.rawTransactionCost);
+  if (markUpAmount.greaterThan(0)) {
+    logger.info(`PROFIT RECEIVED: ${markUpAmount.toNumber()} USD, checking for a repo send operation`);
+    try {
+      await safeFundRepoIfWorthwhile();
+    } catch (error) {
+      logger.error('Failed to fund repo', error);
+      // Don't re-throw - repo funding is not critical to the transaction
+    }
+  }
 }
 
 export async function handleX402Request({
@@ -181,7 +208,6 @@ export async function handleX402Request({
       payload
     );
 
-    await safeFundRepo(paymentAmountDecimal.toNumber());
   } catch (error) {
     await refund(paymentAmountDecimal, payload);
   }

packages/app/server/src/server.ts

@@ -28,7 +28,7 @@ import inFlightMonitorRouter from './routers/in-flight-monitor';
 import { buildX402Response, isApiRequest, isX402Request } from './utils';
 import { handleX402Request, handleApiKeyRequest } from './handlers';
 import { initializeProvider } from './services/ProviderInitializationService';
-import { getRequestMaxCost } from './services/PricingService';
+import { applyMaxCostMarkup, getRequestMaxCost } from './services/PricingService';
 import { Decimal } from '@prisma/client/runtime/library';
 import resourceRouter from './routers/resource';
 
@@ -108,13 +108,15 @@ app.all('*', async (req: EscrowRequest, res: Response, next: NextFunction) => {
       return buildX402Response(req, res, new Decimal(0));
     }
     const maxCost = getRequestMaxCost(req, provider, isPassthroughProxyRoute);
+    const maxCostWithMarkup = applyMaxCostMarkup(maxCost);
+
 
     if (
       !isApiRequest(headers) &&
       !isX402Request(headers) &&
       !isPassthroughProxyRoute
     ) {
-      return buildX402Response(req, res, maxCost);
+      return buildX402Response(req, res, maxCostWithMarkup);
     }
 
     if (isApiRequest(headers)) {
@@ -140,7 +142,7 @@ app.all('*', async (req: EscrowRequest, res: Response, next: NextFunction) => {
         req,
         res,
         headers,
-        maxCost,
+        maxCost: maxCostWithMarkup,
         isPassthroughProxyRoute,
         provider,
         isStream,

packages/app/server/src/services/PricingService.ts

@@ -15,6 +15,12 @@ import { ProviderType } from 'providers/ProviderType';
 import { Tool } from 'openai/resources/responses/responses';
 import { SupportedVideoModel } from '@merit-systems/echo-typescript-sdk';
 
+export function applyMaxCostMarkup(maxCost: Decimal): Decimal {
+  const markup = process.env.MAX_COST_MARKUP || '1.25';
+  return maxCost.mul(new Decimal(markup));
+}
+
+
 export function getRequestMaxCost(
   req: EscrowRequest,
   provider: BaseProvider,

packages/app/server/src/services/fund-repo/constants.ts

@@ -85,3 +85,4 @@ export const ERC3009_ABI = [
 export const MERIT_CONTRACT_ADDRESS = process.env
   .MERIT_CONTRACT_ADDRESS as `0x${string}`;
 export const USDC_ADDRESS = process.env.USDC_ADDRESS as `0x${string}`;
+export const ETH_ADDRESS = process.env.ETH_ADDRESS as `0x${string}`;

packages/app/server/src/services/fund-repo/fundRepoService.ts

@@ -1,11 +1,12 @@
-import { encodeFunctionData, Abi } from 'viem';
+import { encodeFunctionData, Abi, formatUnits, parseUnits } from 'viem';
 import {
   MERIT_ABI,
   MERIT_CONTRACT_ADDRESS,
   USDC_ADDRESS,
   ERC20_CONTRACT_ABI,
+  ETH_ADDRESS,
 } from './constants';
-import logger from '../../logger';
+import logger, { logMetric } from '../../logger';
 import { getSmartAccount } from 'utils';
 
 export interface FundRepoResult {
@@ -106,3 +107,73 @@ export async function safeFundRepo(amount: number): Promise<void> {
     );
   }
 }
+
+
+export async function safeFundRepoIfWorthwhile(): Promise<void> {
+  const repoId = process.env.MERIT_REPO_ID;
+  if (!repoId) {
+    throw new Error('Missing required environment variables');
+  }
+
+  // check balance of wallet. If it is > 100 USD, send all of the USD to the repo.
+
+  const { smartAccount } = await getSmartAccount();
+  const balances = await smartAccount.listTokenBalances({
+    network: 'base',
+  });
+  const baseUsdcBalance = balances.balances.find((balance) => balance.token.contractAddress === USDC_ADDRESS);
+
+
+  const ethereumBalance = balances.balances.find((balance) => balance.token.contractAddress === ETH_ADDRESS);
+
+  if (!ethereumBalance) {
+    logger.info('No Ethereum balance found, skipping fundRepo event');
+    return;
+  }
+
+  if (!baseUsdcBalance) {
+    logger.info('No base USDC balance found, skipping fundRepo event');
+    return;
+  }
+
+  const ethereumBalanceAmount = ethereumBalance.amount.amount;
+  const ethBalanceFormatted = formatUnits(ethereumBalanceAmount, ethereumBalance.amount.decimals);
+  logger.info(`Ethereum balance is ${ethBalanceFormatted} ETH`, {
+    amount: ethBalanceFormatted,
+    address: smartAccount.address,
+  });
+
+  const baseUsdcBalanceAmount = baseUsdcBalance.amount.amount;
+  const usdcBalanceFormatted = formatUnits(baseUsdcBalanceAmount, baseUsdcBalance.amount.decimals);
+  logger.info(`Base USDC balance is ${usdcBalanceFormatted} USD`, {
+    amount: usdcBalanceFormatted,
+    address: smartAccount.address,
+  });
+
+  const ETH_WARNING_THRESHOLD = parseUnits(
+    String(process.env.ETH_WARNING_THRESHOLD || '0.0001'), 
+    ethereumBalance.amount.decimals
+  );
+  const BASE_USDC_WARNING_THRESHOLD = parseUnits(
+    String(process.env.BASE_USDC_TRANSFER_THRESHOLD || '5'),
+    baseUsdcBalance.amount.decimals
+  );
+
+  if (ethereumBalanceAmount < ETH_WARNING_THRESHOLD) {
+    const readableEthWarningThreshold = formatUnits(ETH_WARNING_THRESHOLD, ethereumBalance.amount.decimals);
+    logger.error(`[Critical] Ethereum balance is less than ${readableEthWarningThreshold} ETH, skipping fundRepo event`);
+    logMetric('fund_repo.ethereum_balance_running_low', 1, {
+      amount: ethBalanceFormatted,
+      address: smartAccount.address,
+    });
+    return;
+  }
+
+  if (baseUsdcBalanceAmount < BASE_USDC_WARNING_THRESHOLD) {
+    logger.info('Base USDC balance is less than threshold, skipping fundRepo event');
+    return;
+  }
+  logger.info(`Base USDC balance is ${usdcBalanceFormatted} USD, funding repo`);
+
+  await safeFundRepo(Number(usdcBalanceFormatted));
+}