fix(dapp): implement rate limiting to prevent 429 errors

- Add 1 second delay before each Telegram API call to respect rate limits
- Increase maxRetries to 10 for better error recovery
- Improve error handling: HTTP errors (non-429) fail immediately without retry
- Only retry on 429 rate limit errors and network errors
- Add unit and e2e tests for rate limiting behavior

Author: abbesBenayache

dapp/src/telegramService.js

@@ -3,28 +3,83 @@ async function sendTelegram({
   message,
   botToken,
   senderName = 'Web3Telegram Dapp',
+  maxRetries = 10,
+  initialDelay = 1000,
 }) {
   const messageToSend = `Message from: ${senderName}\n${message}`;
-  const response = await fetch(
-    `https://api.telegram.org/bot${botToken}/sendMessage`,
-    {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-      },
-      body: JSON.stringify({
-        chat_id: chatId,
-        text: messageToSend,
-        parse_mode: 'HTML',
-      }),
-    }
-  ).catch(() => {
-    throw new Error('Failed to reach Telegram bot API');
-  });
-  if (!response.ok) {
-    throw new Error(
-      `Failed to send Telegram message, bot API answered with status: ${response.status}`
+
+  const sendMessage = async () => {
+    // wait 1 second before each call to avoid rate limit
+    await new Promise((resolve) => setTimeout(resolve, 1000));
+
+    const response = await fetch(
+      `https://api.telegram.org/bot${botToken}/sendMessage`,
+      {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+          chat_id: chatId,
+          text: messageToSend,
+          parse_mode: 'HTML',
+        }),
+      }
     );
+
+    return response;
+  };
+
+  // retry logic with exponential backoff for handling rate limits (429) and network errors
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    try {
+      const response = await sendMessage();
+
+      if (response.ok) {
+        return;
+      }
+
+      if (response.status === 429) {
+        const retryAfter = response.headers.get('Retry-After');
+        const delay = retryAfter
+          ? parseInt(retryAfter) * 1000
+          : initialDelay * Math.pow(2, attempt);
+
+        if (attempt < maxRetries) {
+          await new Promise((resolve) => setTimeout(resolve, delay));
+          continue;
+        }
+
+        throw new Error(
+          `Failed to send Telegram message: Rate limit exceeded after ${
+            maxRetries + 1
+          } attempts`
+        );
+      }
+
+      // other HTTP errors - throw directly, no retry
+      throw new Error(
+        `Failed to send Telegram message, bot API answered with status: ${response.status}`
+      );
+    } catch (error) {
+      // if it's an HTTP error (404, 400, etc.) or rate limit error, re-throw immediately
+      if (
+        error.message.includes('Rate limit') ||
+        error.message.includes('Failed to send')
+      ) {
+        throw error;
+      }
+
+      // network errors - retry with exponential backoff
+      if (attempt < maxRetries) {
+        const delay = initialDelay * Math.pow(2, attempt);
+        await new Promise((resolve) => setTimeout(resolve, delay));
+        continue;
+      }
+
+      // max retries reached for network errors
+      throw new Error('Failed to reach Telegram bot API');
+    }
   }
 }
 

dapp/tests/e2e/app.test.js

@@ -206,7 +206,7 @@ describe('sendTelegram', () => {
     expect(computed).toStrictEqual({
       'deterministic-output-path': `${IEXEC_OUT}/result.json`,
     });
-  });
+  }, 10000);
 
   it('should send a telegram message successfully', async () => {
     await expect(start()).resolves.toBeUndefined();
@@ -220,6 +220,35 @@ describe('sendTelegram', () => {
     });
   });
 
+  describe('Rate Limiting', () => {
+    it('should handle multiple messages with 1 second delay between calls', async () => {
+      // Setup bulk processing with 5 messages to test rate limiting
+      process.env.IEXEC_BULK_SLICE_SIZE = '5';
+      for (let i = 1; i <= 5; i++) {
+        process.env[`IEXEC_DATASET_${i}_FILENAME`] = 'data-chatId.zip';
+      }
+
+      await expect(start()).resolves.toBeUndefined();
+
+      const { IEXEC_OUT } = process.env;
+      const { result, computed } = await readOutputs(IEXEC_OUT);
+
+      expect(result.success).toBe(true);
+      expect(result.totalCount).toBe(5);
+      expect(result.successCount).toBe(5);
+      expect(result.errorCount).toBe(0);
+
+      // Verify all messages were sent successfully
+      result.results.forEach((r) => {
+        expect(r.success).toBe(true);
+      });
+
+      expect(computed).toStrictEqual({
+        'deterministic-output-path': `${IEXEC_OUT}/result.json`,
+      });
+    }, 30000); // 30 seconds timeout for 5 messages with delays
+  });
+
   describe('Bulk Processing', () => {
     beforeEach(() => {
       // Setup bulk processing environment
@@ -294,4 +323,37 @@ describe('sendTelegram', () => {
       });
     });
   });
+
+  describe('Retry mechanism with rate limiting', () => {
+    it('should successfully send 10 Telegram messages with 1 second delay and handle retries', async () => {
+      // Setup bulk processing with 10 protected data to test rate limiting and retries
+      process.env.IEXEC_BULK_SLICE_SIZE = '10';
+
+      for (let i = 1; i <= 10; i++) {
+        process.env[`IEXEC_DATASET_${i}_FILENAME`] = 'data-chatId.zip';
+      }
+
+      await expect(start()).resolves.toBeUndefined();
+
+      const { IEXEC_OUT } = process.env;
+      const { result, computed } = await readOutputs(IEXEC_OUT);
+
+      expect(result.success).toBe(true);
+      expect(result.totalCount).toBe(10);
+      expect(result.successCount).toBe(10);
+      expect(result.errorCount).toBe(0);
+      expect(result.results).toHaveLength(10);
+
+      // Verify all messages were sent successfully
+      result.results.forEach((r, index) => {
+        expect(r.success).toBe(true);
+        expect(r.index).toBe(index + 1);
+        expect(r.protectedData).toBe('data-chatId.zip');
+      });
+
+      expect(computed).toStrictEqual({
+        'deterministic-output-path': `${IEXEC_OUT}/result.json`,
+      });
+    }, 60000); // 60 seconds timeout for 10 messages with delays and potential retries
+  });
 });