Create new production release

apps/api/src/api/controllers/alfredpay.controller.ts

@@ -547,6 +547,34 @@ export class AlfredpayController {
     }
   }
 
+  static async findKybCustomerAndBusiness(req: Request, res: Response) {
+    try {
+      const { country } = req.query as { country: string };
+      const userId = req.userId!;
+
+      const alfredPayCustomer = await AlfredPayCustomer.findOne({
+        where: { country: country as AlfredPayCountry, type: AlfredpayCustomerType.BUSINESS, userId }
+      });
+
+      if (!alfredPayCustomer) {
+        return res.status(404).json({ error: "Alfredpay business customer not found" });
+      }
+
+      const alfredpayService = AlfredpayApiService.getInstance();
+      const details = await alfredpayService.getKybBusinessDetails(alfredPayCustomer.alfredPayId);
+
+      const minimized = details.map(business => ({
+        relatedPersons: (business.relatedPersons ?? []).map(person => ({ idRelatedPerson: person.idRelatedPerson }))
+      }));
+
+      res.json(minimized);
+    } catch (error) {
+      logger.error("Error finding Alfredpay KYB customer and business:", error);
+      const message = error instanceof Error ? error.message : "Internal server error";
+      res.status(500).json({ error: message });
+    }
+  }
+
   static async submitKybFile(req: Request, res: Response) {
     try {
       const { country, submissionId, fileType } = req.body as { country: string; submissionId: string; fileType: string };
@@ -582,6 +610,7 @@ export class AlfredpayController {
   }
 
   static async submitKybRelatedPersonFile(req: Request, res: Response) {
+    let pennyCustomerId: string | undefined;
     try {
       const { country, relatedPersonId, fileType } = req.body as {
         country: string;
@@ -602,6 +631,8 @@ export class AlfredpayController {
         return res.status(404).json({ error: "Alfredpay business customer not found" });
       }
 
+      pennyCustomerId = alfredPayCustomer.alfredPayId;
+
       const fileBlob = new File([new Uint8Array(req.file.buffer)], req.file.originalname, { type: req.file.mimetype });
       const alfredpayService = AlfredpayApiService.getInstance();
       await alfredpayService.submitKybRelatedPersonFiles(
@@ -613,7 +644,11 @@ export class AlfredpayController {
 
       res.json({ success: true });
     } catch (error) {
-      logger.error("Error submitting KYB related person file:", error);
+      const body = req.body as { country?: string; relatedPersonId?: string; fileType?: string };
+      const errSummary = error instanceof Error ? error.message : String(error);
+      logger.error(
+        `[submitKybRelatedPersonFile] ${errSummary} | customerIdPenny=${pennyCustomerId ?? "n/a"} relatedPersonId=${body.relatedPersonId ?? "n/a"} userId=${req.userId ?? "n/a"}`
+      );
       const message = error instanceof Error ? error.message : "Internal server error";
       res.status(500).json({ error: message });
     }

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

@@ -571,7 +571,7 @@ export const newKyc = async (
  * @throws 500 - For any server-side errors during processing
  */
 export const initiateKybLevel1 = async (
-  req: Request<unknown, unknown, unknown, { subAccountId?: string }>,
+  req: Request<unknown, { redirectUrl: string }, unknown, { subAccountId?: string }>,
   res: Response<KybLevel1Response | BrlaErrorResponse>
 ): Promise<void> => {
   try {

apps/api/src/api/routes/v1/alfredpay.route.ts

@@ -25,6 +25,7 @@ router.post("/sendKycSubmission", requireAuth, validateResultCountry, AlfredpayC
 // Business API-based KYB
 router.post("/submitKybInformation", requireAuth, validateResultCountry, AlfredpayController.submitKybInformation);
 router.post("/submitKybFile", requireAuth, upload.single("file"), validateResultCountry, AlfredpayController.submitKybFile);
+router.get("/findKybCustomerAndBusiness", requireAuth, validateResultCountry, AlfredpayController.findKybCustomerAndBusiness);
 router.post(
   "/submitKybRelatedPersonFile",
   requireAuth,

apps/api/src/api/services/phases/handlers/brla-onramp-mint-handler.ts

@@ -6,8 +6,10 @@ import {
   BrlaApiService,
   BrlaCurrency,
   checkEvmBalancePeriodically,
-  FiatToken,
-  getAnyFiatTokenDetailsMoonbeam,
+  EvmAddress,
+  EvmToken,
+  evmTokenConfig,
+  getEvmTokenBalance,
   Networks,
   RampPhase,
   waitUntilTrueWithTimeout
@@ -28,7 +30,7 @@ import { StateMetadata } from "../meta-state-types";
 const PAYMENT_TIMEOUT_MS = 30 * 60 * 1000; // 30 minutes
 const EVM_BALANCE_CHECK_TIMEOUT_MS = 5 * 60 * 1000; // 5 minutes
 
-// Phase description: wait for the tokens to arrive at the Moonbeam ephemeral address.
+// Phase description: wait for the tokens to arrive at the Base ephemeral address.
 // If the timeout is reached, we assume the user has NOT made the payment and we cancel the ramp.
 export class BrlaOnrampMintHandler extends BasePhaseHandler {
   public getPhaseName(): RampPhase {
@@ -63,6 +65,24 @@ export class BrlaOnrampMintHandler extends BasePhaseHandler {
       });
     }
 
+    const tokenDetails = evmTokenConfig[Networks.Base][EvmToken.BRLA];
+    if (!tokenDetails) {
+      throw new Error("BRLA token details not found for Base network");
+    }
+
+    const expectedAmountReceived = quote.metadata.aveniaTransfer.outputAmountRaw;
+
+    // Recovery shortcut: a previous run may have already minted on Avenia and
+    // transferred to the ephemeral. If the ephemeral already holds the expected
+    // amount, skip the Avenia balance wait and the (idempotent-but-wasteful)
+    // pay-out ticket creation.
+    if (await this.ephemeralAlreadyFunded(tokenDetails.erc20AddressSourceChain, evmEphemeralAddress, expectedAmountReceived)) {
+      logger.info(
+        `BrlaOnrampMintHandler: Ephemeral ${evmEphemeralAddress} already holds the expected ${expectedAmountReceived} BRLA. Skipping mint flow.`
+      );
+      return this.transitionToNextPhase(state, "fundEphemeral");
+    }
+
     const brlaApiService = BrlaApiService.getInstance();
     try {
       logger.info(
@@ -106,7 +126,7 @@ export class BrlaOnrampMintHandler extends BasePhaseHandler {
       inputPaymentMethod: AveniaPaymentMethod.INTERNAL,
       inputThirdParty: false,
       outputCurrency: BrlaCurrency.BRLA,
-      outputPaymentMethod: AveniaPaymentMethod.MOONBEAM,
+      outputPaymentMethod: AveniaPaymentMethod.BASE,
       outputThirdParty: false,
       subAccountId: taxIdRecord.subAccountId
     });
@@ -118,29 +138,26 @@ export class BrlaOnrampMintHandler extends BasePhaseHandler {
         quoteToken: aveniaQuote.quoteToken,
         ticketBlockchainOutput: {
           walletAddress: state.state.evmEphemeralAddress,
-          walletChain: AveniaPaymentMethod.MOONBEAM
+          walletChain: AveniaPaymentMethod.BASE
         }
       },
       taxIdRecord.subAccountId
     );
 
-    const expectedAmountReceived = quote.metadata.aveniaTransfer?.outputAmountRaw;
-
     logger.info(
-      `BrlaOnrampMintHandler: Created Avenia transfer ticket with id ${aveniaTicket.id} to transfer ${quote.metadata.aveniaTransfer.outputAmountDecimal} BRLA to Moonbeam address ${state.state.evmEphemeralAddress}`
+      `BrlaOnrampMintHandler: Created Avenia transfer ticket with id ${aveniaTicket.id} to transfer ${quote.metadata.aveniaTransfer.outputAmountDecimal} BRLA to Base address ${state.state.evmEphemeralAddress}`
     );
 
     try {
       const pollingTimeMs = 1000;
-      const tokenDetails = getAnyFiatTokenDetailsMoonbeam(FiatToken.BRL);
 
       await checkEvmBalancePeriodically(
-        tokenDetails.moonbeamErc20Address,
+        tokenDetails.erc20AddressSourceChain,
         evmEphemeralAddress,
         expectedAmountReceived,
         pollingTimeMs,
         EVM_BALANCE_CHECK_TIMEOUT_MS,
-        Networks.Moonbeam
+        Networks.Base
       );
     } catch (error) {
       if (!(error instanceof BalanceCheckError)) throw error;
@@ -153,12 +170,34 @@ export class BrlaOnrampMintHandler extends BasePhaseHandler {
 
       throw isCheckTimeout
         ? this.createRecoverableError(`BrlaOnrampMintHandler: phase timeout reached with error: ${error}`)
-        : new Error(`Error checking Moonbeam balance: ${error}`);
+        : new Error(`Error checking Base balance: ${error}`);
     }
 
     return this.transitionToNextPhase(state, "fundEphemeral");
   }
 
+  private async ephemeralAlreadyFunded(
+    tokenAddress: string,
+    ownerAddress: string,
+    expectedAmountRaw: string
+  ): Promise<boolean> {
+    try {
+      const balance = await getEvmTokenBalance({
+        chain: Networks.Base,
+        ownerAddress: ownerAddress as EvmAddress,
+        tokenAddress: tokenAddress as EvmAddress
+      });
+      return balance.gte(new Big(expectedAmountRaw));
+    } catch (error) {
+      // Treat read failures as "not funded" so we fall through to the regular
+      // flow rather than aborting the phase on a transient RPC error.
+      logger.warn(
+        `BrlaOnrampMintHandler: ephemeral balance pre-check failed for ${ownerAddress}, falling back to Avenia flow: ${error}`
+      );
+      return false;
+    }
+  }
+
   protected isPaymentTimeoutReached(state: RampState): boolean {
     const thisPhaseEntry = state.phaseHistory.find(phaseHistoryEntry => phaseHistoryEntry.phase === this.getPhaseName());
     if (!thisPhaseEntry) {