Merge pull request #571 from everclearorg/ci/prod-to-staging-merge

ci: sync staging to prod

Author: otsybizov

packages/handler/src/processor/eventProcessor.ts

@@ -189,17 +189,6 @@ export class EventProcessor {
             minAmounts = {
               [earmark.designatedPurchaseChain.toString()]: minAmounts[earmark.designatedPurchaseChain.toString()],
             };
-
-            // Move READY → COMPLETED immediately after applying the chain constraint.
-            // This gives the earmark one shot at filling with the designated chain.
-            // If it fails, the earmark is already gone, so the next cycle can re-evaluate fresh.
-            await database.updateEarmarkStatus(earmark.id, EarmarkStatus.COMPLETED);
-            logger.info('Earmark marked COMPLETED after applying chain constraint', {
-              requestId,
-              invoiceId: event.id,
-              earmarkId: earmark.id,
-              designatedPurchaseChain: earmark.designatedPurchaseChain,
-            });
           } else {
             logger.warn('Earmarked invoice designated origin not available in minAmounts', {
               requestId,
@@ -418,6 +407,26 @@ export class EventProcessor {
           throw e;
         }
       } else {
+        // Purchase failed — mark earmark COMPLETED so the next cycle can re-evaluate
+        // fresh (e.g. pick a different chain or create a new earmark).
+        try {
+          const earmark = await database.getActiveEarmarkForInvoice(event.id);
+          if (earmark && earmark.status === EarmarkStatus.READY) {
+            await database.updateEarmarkStatus(earmark.id, EarmarkStatus.COMPLETED);
+            logger.info('Earmark marked COMPLETED after failed purchase attempt', {
+              requestId,
+              invoiceId: event.id,
+              earmarkId: earmark.id,
+            });
+          }
+        } catch (error) {
+          logger.error('Error cleaning up earmark after failed purchase', {
+            requestId,
+            invoiceId: event.id,
+            error: jsonifyError(error),
+          });
+        }
+
         logger.info('Method complete with 0 purchases', {
           requestId,
           invoiceId: event.id,

packages/handler/test/processor/eventProcessor.spec.ts

@@ -78,6 +78,7 @@ describe('EventProcessor', () => {
 
     mockDatabase = {
       getEarmarks: jest.fn(),
+      getActiveEarmarkForInvoice: jest.fn(),
       updateEarmarkStatus: jest.fn(),
     } as any;
 
@@ -618,7 +619,7 @@ describe('EventProcessor', () => {
       );
     });
 
-    it('should move READY earmark to COMPLETED after applying chain constraint', async () => {
+    it('should keep READY earmark during purchase and mark COMPLETED after failed attempt', async () => {
       const event = createInvoiceEvent('invoice-1');
       const invoice = createMockInvoice();
       const { processPendingEarmark, splitAndSendIntents } = require('#/helpers');
@@ -643,6 +644,12 @@ describe('EventProcessor', () => {
           designatedPurchaseChain: 2,
         },
       ]);
+      mockDatabase.getActiveEarmarkForInvoice.mockResolvedValue({
+        id: 'earmark-1',
+        invoiceId: 'invoice-1',
+        status: EarmarkStatus.READY,
+        designatedPurchaseChain: 2,
+      });
       mockDatabase.updateEarmarkStatus.mockResolvedValue(undefined);
       isValidInvoice.mockReturnValue(null);
       isXerc20Supported.mockResolvedValue(false);
@@ -657,18 +664,26 @@ describe('EventProcessor', () => {
       });
       splitAndSendIntents.mockResolvedValue([]);
 
-      await eventProcessor.processInvoiceEnqueued(event);
+      const result = await eventProcessor.processInvoiceEnqueued(event);
 
-      // Earmark should be marked COMPLETED immediately after applying chain constraint
+      // Earmark stays READY during purchase, then marked COMPLETED after 0 purchases
       expect(mockDatabase.updateEarmarkStatus).toHaveBeenCalledWith('earmark-1', EarmarkStatus.COMPLETED);
       expect(mockLogger.info).toHaveBeenCalledWith(
-        'Earmark marked COMPLETED after applying chain constraint',
+        'Applied earmark chain constraint, earmark stays READY during purchase',
         expect.objectContaining({
           invoiceId: 'invoice-1',
           earmarkId: 'earmark-1',
           designatedPurchaseChain: 2,
         }),
       );
+      expect(mockLogger.info).toHaveBeenCalledWith(
+        'Earmark marked COMPLETED after failed purchase attempt',
+        expect.objectContaining({
+          invoiceId: 'invoice-1',
+          earmarkId: 'earmark-1',
+        }),
+      );
+      expect(result.result).toBe(EventProcessingResultType.Failure);
     });
 
     it('should move READY earmark to COMPLETED and fail when designated chain not in minAmounts', async () => {

packages/poller/src/invoice/processInvoices.ts

@@ -667,11 +667,11 @@ export async function processInvoices(context: ProcessingContext, invoices: Invo
           // READY earmarks go into the processing map with chain constraint
           earmarkedInvoicesMap.set(invoiceId, designatedPurchaseChain);
 
-          // Move READY → COMPLETED immediately after capturing the chain constraint.
-          // This gives the earmark one shot at filling with the designated chain.
-          // If it fails, the earmark is already gone, so the next cycle can re-evaluate fresh.
-          await context.database.updateEarmarkStatus(earmark.id, EarmarkStatus.COMPLETED);
-          logger.info('Earmarked invoice ready for processing, marked COMPLETED', {
+          // Keep earmark in READY state during purchase processing so that
+          // getEarmarkedBalance() continues to protect these funds from the
+          // regular rebalancer. The earmark will be marked COMPLETED after the
+          // purchase attempt (success or failure).
+          logger.info('Earmarked invoice ready for processing', {
             requestId,
             invoiceId,
             earmarkId: earmark.id,
@@ -941,6 +941,32 @@ export async function processInvoices(context: ProcessingContext, invoices: Invo
     }
   }
 
+  // Mark COMPLETED earmarks for invoices that were NOT purchased.
+  // This prevents infinite retry loops when the purchase fails (e.g. insufficient balance)
+  // while keeping the earmark visible to getEarmarkedBalance() during the purchase window.
+  const purchasedIds = new Set(allPurchases.map((p) => p.target.intent_id));
+  for (const [invoiceId] of earmarkedInvoicesMap) {
+    if (!purchasedIds.has(invoiceId)) {
+      try {
+        const earmark = await context.database.getActiveEarmarkForInvoice(invoiceId);
+        if (earmark && earmark.status === EarmarkStatus.READY) {
+          await context.database.updateEarmarkStatus(earmark.id, EarmarkStatus.COMPLETED);
+          logger.info('Earmark marked COMPLETED after failed purchase attempt', {
+            requestId,
+            earmarkId: earmark.id,
+            invoiceId,
+          });
+        }
+      } catch (error) {
+        logger.error('Error cleaning up earmark after failed purchase', {
+          requestId,
+          invoiceId,
+          error: jsonifyError(error),
+        });
+      }
+    }
+  }
+
   // Store purchases in cache
   if (allPurchases.length > 0) {
     try {