Merge pull request #631 from pendulum-chain/add-reference-label-check

Improve pix onramp payment handling

Author: gianfra-t

api/src/api/controllers/brla.controller.ts

@@ -332,7 +332,7 @@ export const fetchSubaccountKycStatus = async (
     if (!lastInteraction) {
       res.status(404).json({ error: `No KYC process started for ${taxId}` });
     }
-    if (lastInteraction && lastEventCached.createdAt <= (lastInteraction - 60000)) {
+    if (lastInteraction && lastEventCached.createdAt <= lastInteraction - 60000) {
       // If the last event is older than 1 minute from the last interaction, we assume it's not a new event.
       // So it is ignored.
       console.log('Last kyc interaction', lastInteraction);
@@ -351,57 +351,6 @@ export const fetchSubaccountKycStatus = async (
   }
 };
 
-/**
- * Retrieves a a BR Code that can be used to onramp into BRLA
- *
- * Fetches a user's subaccount information from the BRLA API service.
- * It validates that the user exists and has completed a KYC verification.
- * It returns the corresponding BR Code given the amount and reference label, if any.
- *
- * @returns  Sends JSON response with brCode on success.
- *
- * @throws 400 - If subaccount's KYC is invalid, or the amount exceeds KYC limits.
- * @throws 404 - If the subaccount cannot be found
- * @throws 500 - For any server-side errors during processing
- */
-export const getPayInCode = async (
-  req: Request<unknown, unknown, unknown, PayInCodeQuery>,
-  res: Response<BrlaEndpoints.GetPayInCodeResponse | BrlaEndpoints.BrlaErrorResponse>,
-): Promise<void> => {
-  try {
-    const { taxId, amount, receiverAddress } = req.query as PayInCodeQuery;
-
-    const brlaApiService = BrlaApiService.getInstance();
-    const subaccount = await brlaApiService.getSubaccount(taxId);
-    if (!subaccount) {
-      res.status(httpStatus.NOT_FOUND).json({ error: 'Subaccount not found' });
-      return;
-    }
-
-    if (subaccount.kyc.level < 1) {
-      res.status(httpStatus.BAD_REQUEST).json({ error: 'KYC invalid' });
-      return;
-    }
-
-    const { limitMint } = subaccount.kyc.limits;
-
-    if (Number(amount) > limitMint) {
-      res.status(httpStatus.BAD_REQUEST).json({ error: 'Amount exceeds limit' });
-      return;
-    }
-
-    const brCode = await brlaApiService.generateBrCode({
-      subaccountId: subaccount.id,
-      amount: String(amount),
-      referenceLabel: generateReferenceLabel(receiverAddress),
-    });
-
-    res.status(httpStatus.OK).json(brCode);
-  } catch (error) {
-    handleApiError(error, res, 'triggerOnramp');
-  }
-};
-
 /**
  * Validates a pix key
  *

api/src/api/middlewares/validators.ts

@@ -404,29 +404,6 @@ export const validataSubaccountCreation: RequestHandler = (req, res, next) => {
   next();
 };
 
-export const validateGetPayInCode: RequestHandler = (req, res, next) => {
-  const { taxId, receiverAddress, amount } = req.query as PayInCodeQuery;
-
-  if (!taxId) {
-    res.status(httpStatus.BAD_REQUEST).json({ error: 'Missing taxId parameter' });
-    return;
-  }
-
-  if (!amount || isNaN(Number(amount))) {
-    res.status(httpStatus.BAD_REQUEST).json({ error: 'Missing or invalid amount parameter' });
-    return;
-  }
-
-  if (!receiverAddress || !(receiverAddress as string).startsWith('0x')) {
-    res.status(httpStatus.BAD_REQUEST).json({
-      error: 'Missing or invalid receiverAddress parameter. receiverAddress must be a valid Evm address',
-    });
-    return;
-  }
-
-  next();
-};
-
 export const validateStartKyc2: RequestHandler = (req, res, next) => {
   const { taxId, documentType } = req.body as BrlaEndpoints.StartKYC2Request;
 

api/src/api/routes/v1/brla.route.ts

@@ -3,7 +3,6 @@ import * as brlaController from '../../controllers/brla.controller';
 import {
   validateBrlaTriggerOfframpInput,
   validataSubaccountCreation,
-  validateGetPayInCode,
   validateStartKyc2,
 } from '../../middlewares/validators';
 
@@ -19,8 +18,6 @@ router.route('/getKycStatus').get(brlaController.fetchSubaccountKycStatus);
 
 router.route('/validatePixKey').get(brlaController.validatePixKey);
 
-router.route('/payIn').get(validateGetPayInCode, brlaController.getPayInCode);
-
 router.route('/triggerOfframp').post(validateBrlaTriggerOfframpInput, brlaController.triggerBrlaOfframp);
 
 router.route('/createSubaccount').post(validataSubaccountCreation, brlaController.createSubaccount);

api/src/api/services/brla/brlaTeleportService.ts

@@ -21,7 +21,7 @@ type Teleport = {
   dateRequested: string;
   status: TeleportStatus;
   receiverAddress: EvmAddress;
-  memo?: string;
+  memo: string;
   id?: string;
 };
 
@@ -34,6 +34,7 @@ export class BrlaTeleportService {
 
   private intervalMs = 10000;
 
+  // Key is a composite of subaccountId and memo: `${subaccountId}:${memo}`
   private teleports: Map<string, Teleport> = new Map();
 
   private completedTeleports: Map<string, Teleport> = new Map();
@@ -53,32 +54,73 @@ export class BrlaTeleportService {
     return BrlaTeleportService.teleportService;
   }
 
-  public async requestTeleport(subaccountId: string, amount: number, receiverAddress: EvmAddress): Promise<void> {
+  private getCompositeKey(subaccountId: string, memo: string): string {
+    const safeMemo = typeof memo === 'string' ? memo : '';
+    return `${subaccountId}:${safeMemo}`;
+  }
+
+  public async requestTeleport(
+    subaccountId: string,
+    amount: number,
+    receiverAddress: EvmAddress,
+    memo: string,
+  ): Promise<void> {
+    const compositeKey = this.getCompositeKey(subaccountId, memo);
+    const existing = this.teleports.get(compositeKey);
+
+    if (
+      existing &&
+      existing.amount === amount &&
+      existing.receiverAddress === receiverAddress &&
+      (existing.status === 'claimed' || existing.status === 'started')
+    ) {
+      logger.info(
+        `Skipping duplicate teleport request for subaccount ${subaccountId}, memo "${memo}" ` +
+          `(amount=${amount}, receiver=${receiverAddress}). Current status: ${existing.status}.`,
+      );
+      return;
+    }
+
     const teleport: Teleport = {
       amount,
       subaccountId,
       dateRequested: new Date().toISOString(),
       status: 'claimed',
       receiverAddress,
+      memo,
     };
-    logger.info('Requesting teleport:', teleport);
-    this.teleports.set(subaccountId, teleport);
+    logger.info(`Requesting teleport "${compositeKey}":`, teleport);
+    this.teleports.set(compositeKey, teleport);
     this.maybeStartPeriodicChecks();
   }
 
-  private async startTeleport(subaccountId: string): Promise<void> {
-    const teleport = this.teleports.get(subaccountId);
+  public cancelPendingTeleport(subaccountId: string, memo: string): void {
+    const compositeKey = this.getCompositeKey(subaccountId, memo);
+    const pending = this.teleports.get(compositeKey);
+    if (pending) {
+      this.teleports.delete(compositeKey);
+      logger.info(`Cancelled pending teleport for key "${compositeKey}" (subaccount ${subaccountId}, memo "${memo}").`);
+    } else {
+      logger.info(
+        `No pending teleport found to cancel for key "${compositeKey}" (subaccount ${subaccountId}, memo "${memo}").`,
+      );
+    }
+  }
+
+  private async startTeleport(compositeKey: string): Promise<void> {
+    const teleport = this.teleports.get(compositeKey);
 
-    // Ignore operation
     if (teleport === undefined) {
-      throw new Error('Teleport not found. This cannot not happen.');
+      logger.error(`Teleport not found for key "${compositeKey}" at startTeleport. This should not happen.`);
+      return;
     }
 
     if (teleport.status !== 'arrived') {
-      throw new Error('Teleport not in arrived state.');
+      logger.warn(`Teleport "${compositeKey}" not in 'arrived' state.`);
+      return;
     }
 
-    logger.info('Starting teleport:', teleport);
+    logger.info(`Starting teleport "${compositeKey}":`, teleport);
     const fastQuoteParams: FastQuoteQueryParams = {
       subaccountId: teleport.subaccountId,
       operation: 'swap',
@@ -91,31 +133,35 @@ export class BrlaTeleportService {
 
     try {
       const { token: quoteToken } = await this.brlaApiService.createFastQuote(fastQuoteParams);
-      this.teleports.set(subaccountId, { ...teleport, status: 'quoted' });
+      const quotedTeleportState: Teleport = { ...teleport, status: 'quoted' };
+      this.teleports.set(compositeKey, quotedTeleportState);
+      logger.info(`Teleport ${compositeKey} status: quoted`);
 
-      // Execute the actual swap operation
       const { id } = await this.brlaApiService.swapRequest({
         token: quoteToken,
-        receiverAddress: teleport.receiverAddress,
+        receiverAddress: quotedTeleportState.receiverAddress,
       });
-      this.teleports.set(subaccountId, { ...teleport, status: 'started', id });
+
+      const startedTeleportState: Teleport = { ...quotedTeleportState, status: 'started', id };
+      this.teleports.set(compositeKey, startedTeleportState);
+      logger.info(`Teleport ${compositeKey} status: started, API operationId: ${id}`);
 
       this.maybeStartPeriodicChecks();
     } catch (e) {
-      logger.error('Error starting teleport:', e);
-      this.teleports.set(subaccountId, { ...teleport, status: 'failed' });
+      logger.error(`Error starting teleport "${compositeKey}":`, e);
+      this.teleports.set(compositeKey, { ...teleport, status: 'failed' });
     }
   }
 
   private maybeStartPeriodicChecks(): void {
-    const pendingTeleports = [...this.teleports.entries()].filter(
-      (entry) => entry[1].status === 'claimed' || entry[1].status === 'started',
+    const pendingTeleports = [...this.teleports.values()].filter(
+      (teleport) => teleport.status === 'claimed' || teleport.status === 'started',
     ).length;
 
     if (this.checkInterval === null && pendingTeleports > 0) {
       this.checkInterval = setInterval(() => {
         this.checkPendingTeleports().catch((err) => {
-          console.error('Error in periodic teleport check:', err);
+          logger.error('Error in periodic teleport check:', err);
         });
       }, this.intervalMs);
     }
@@ -125,55 +171,72 @@ export class BrlaTeleportService {
     if (this.teleports.size === 0 && this.checkInterval !== null) {
       clearInterval(this.checkInterval);
       this.checkInterval = null;
+      return;
     }
 
-    this.teleports.forEach(async (teleport, subaccountId) => {
+    // Process 'started' teleports first
+    for (const [compositeKey, teleport] of this.teleports) {
       if (teleport.status === 'started') {
-        const onChainOuts = await this.brlaApiService.getOnChainHistoryOut(subaccountId);
-        const relevantOut = onChainOuts.find((out: OnchainLog) => out.id === teleport.id);
-
-        if (!relevantOut) {
-          return;
-        }
-
-        // We are interested in the last contract op for this operation being
-        // a mint one. smartContractOps are ordered descending by timestamp.
-        const lastContractOp = relevantOut.smartContractOps[0];
-
-        if (lastContractOp.operationName === SmartContractOperationType.MINT && lastContractOp.executed === true) {
-          this.completedTeleports.set(subaccountId, { ...teleport, status: 'completed' });
-          logger.info('Teleport completed:', teleport);
-          this.teleports.delete(subaccountId);
+        try {
+          const onChainOuts = await this.brlaApiService.getOnChainHistoryOut(teleport.subaccountId);
+          const relevantOut = onChainOuts.find((out: OnchainLog) => out.id === teleport.id);
+
+          if (!relevantOut) {
+            return;
+          }
+
+          // We are interested in the last contract op for this operation being
+          // a mint one. smartContractOps are ordered descending by timestamp.
+          const lastContractOp = relevantOut.smartContractOps[0];
+
+          if (
+            lastContractOp &&
+            lastContractOp.operationName === SmartContractOperationType.MINT &&
+            lastContractOp.executed === true
+          ) {
+            const completedTeleport = { ...teleport, status: 'completed' as TeleportStatus };
+            this.completedTeleports.set(compositeKey, completedTeleport);
+            logger.info(`Teleport completed "${compositeKey}":`, completedTeleport);
+            this.teleports.delete(compositeKey);
+          }
+        } catch (error) {
+          logger.error(`Error checking 'started' teleport ${compositeKey}:`, error);
         }
       }
-    });
+    }
 
-    this.teleports.forEach(async (teleport, subaccountId) => {
-      // For claimed teleports, we need to wait for funds to arrive, only then it makes sense to
-      // start the actual transfer process.
+    // Process 'claimed' teleports
+    for (const [compositeKey, teleport] of this.teleports) {
       if (teleport.status === 'claimed') {
-        const payIns = await this.brlaApiService.getPayInHistory(subaccountId);
-        // TODO we also need to check actual balance, which has to be gte what is requested.
-        if (payIns.length === 0) {
-          return;
-        }
-
-        // Must be the last one, if any.
-        const lastPayIn = payIns[0];
-        // Check the referceLabel to match the address requested, and amount.
-        // Last mintOp should match the amount.
-        if (
-          verifyReferenceLabel(lastPayIn.referenceLabel, teleport.receiverAddress) // TODO testing && lastPayIn.mintOps[0].amount === teleport.amount
-        ) {
-          this.teleports.set(subaccountId, { ...teleport, status: 'arrived' });
-          this.startTeleport(subaccountId);
-        }
-
-        // delete teleports that have been waiting for more than 15 minutes
-        if (teleport.status === 'claimed' && Date.now() - new Date(teleport.dateRequested).getTime() > 15 * 60 * 1000) {
-          this.teleports.delete(subaccountId);
+        try {
+          const payIns = await this.brlaApiService.getPayInHistory(teleport.subaccountId);
+          if (payIns.length === 0) {
+            return;
+          }
+
+          // Must be the last one, if any.
+          const matchingPayIn = payIns.find(
+            (payIn) =>
+              verifyReferenceLabel(payIn.referenceLabel, teleport.memo) &&
+              Number(payIn.amount) >= Number(teleport.amount),
+          );
+
+          if (matchingPayIn) {
+            logger.info(`Matching PayIn found for teleport "${compositeKey}". Status changing to 'arrived'.`);
+            this.teleports.set(compositeKey, { ...teleport, status: 'arrived' });
+            // Intentionally not awaiting startTeleport to allow checkPendingTeleports to complete its iteration.
+            // startTeleport is async and will handle its own errors.
+            this.startTeleport(compositeKey).catch((err) => {
+              logger.error(
+                `Error occurred during startTeleport called for ${compositeKey} from checkPendingTeleports:`,
+                err,
+              );
+            });
+          } // Deletion of teleports is handled by the phase processor.
+        } catch (error) {
+          logger.error(`Error checking 'claimed' teleport ${compositeKey}:`, error);
         }
       }
-    });
+    }
   }
 }

api/src/api/services/brla/helpers.ts

@@ -1,12 +1,16 @@
 import { sha256 } from 'ethers';
 import { EvmAddress } from './brlaTeleportService';
+import QuoteTicket from '../../../models/quoteTicket.model';
 
-export function verifyReferenceLabel(referenceLabel: string, receiverAddress: EvmAddress): boolean {
-  return true; // TODO ONRAMP testing, remove.
-  const referenceLabelClaimed = sha256(receiverAddress).toString().slice(0, 18);
-  return referenceLabel === referenceLabelClaimed;
+export function verifyReferenceLabel(referenceLabel: string, memo: string): boolean {
+  return referenceLabel === memo;
 }
 
-export function generateReferenceLabel(receiverAddress: EvmAddress): string {
-  return sha256(receiverAddress).toString().slice(0, 18);
+type QuoteId = string;
+
+export function generateReferenceLabel(quote: QuoteTicket | QuoteId): string {
+  if (typeof quote === 'string') {
+    return quote.slice(0, 8);
+  }
+  return quote.id.slice(0, 8);
 }