Add additional signed data checks

packages/api/src/handlers.test.ts

@@ -100,12 +100,84 @@ describe(batchInsertData.name, () => {
       statusCode: 201,
     });
     expect(logger.debug).toHaveBeenCalledWith(
-      'Not storing signed data because signed data with the same timestamp already exists.',
+      'Not storing signed data because the signed data is not newer than what we already have.',
       expect.any(Object)
     );
     expect(cacheModule.getCache()[storedSignedData.airnode]![storedSignedData.templateId]!).toHaveLength(1);
   });
 
+  it('skips signed data if newer data is available from the store', async () => {
+    const airnodeWallet = generateRandomWallet();
+    const storedSignedData = await createSignedData({ airnodeWallet });
+    cacheModule.setCache({
+      [storedSignedData.airnode]: {
+        [storedSignedData.templateId]: [storedSignedData],
+      },
+    });
+    const batchData = [
+      await createSignedData({
+        airnodeWallet,
+        templateId: storedSignedData.templateId,
+        timestamp: (Number.parseInt(storedSignedData.timestamp, 10) - 10).toString(),
+      }),
+      await createSignedData(),
+    ];
+    jest.spyOn(logger, 'debug');
+
+    const result = await batchInsertData(batchData);
+
+    expect(result).toStrictEqual({
+      body: JSON.stringify({ count: 1, skipped: 1 }),
+      headers: {
+        'access-control-allow-methods': '*',
+        'access-control-allow-origin': '*',
+        'content-type': 'application/json',
+      },
+      statusCode: 201,
+    });
+    expect(logger.debug).toHaveBeenCalledWith(
+      'Not storing signed data because the signed data is not newer than what we already have.',
+      expect.any(Object)
+    );
+    expect(cacheModule.getCache()[storedSignedData.airnode]![storedSignedData.templateId]!).toHaveLength(1);
+  });
+
+  it('skips signed data if the data is older than an hour', async () => {
+    const airnodeWallet = generateRandomWallet();
+    const storedSignedData = await createSignedData({ airnodeWallet });
+    cacheModule.setCache({
+      [storedSignedData.airnode]: {
+        [storedSignedData.templateId]: [],
+      },
+    });
+    const batchData = [
+      await createSignedData({
+        airnodeWallet,
+        templateId: storedSignedData.templateId,
+        timestamp: (Number.parseInt(storedSignedData.timestamp, 10) - 60 * 61).toString(),
+      }),
+      await createSignedData(),
+    ];
+    jest.spyOn(logger, 'debug');
+
+    const result = await batchInsertData(batchData);
+
+    expect(result).toStrictEqual({
+      body: JSON.stringify({ count: 1, skipped: 1 }),
+      headers: {
+        'access-control-allow-methods': '*',
+        'access-control-allow-origin': '*',
+        'content-type': 'application/json',
+      },
+      statusCode: 201,
+    });
+    expect(logger.debug).toHaveBeenCalledWith(
+      'Not storing signed data because the timestamp is older than one hour.',
+      expect.any(Object)
+    );
+    expect(cacheModule.getCache()[storedSignedData.airnode]![storedSignedData.templateId]!).toHaveLength(0);
+  });
+
   it('rejects a batch if there is a beacon with timestamp too far in the future', async () => {
     const batchData = [await createSignedData({ timestamp: (Math.floor(Date.now() / 1000) + 60 * 60 * 2).toString() })];
 

packages/api/src/handlers.ts

@@ -84,9 +84,17 @@ export const batchInsertData = async (requestBody: unknown): Promise<ApiResponse
   // is acceptable, but we only want to store one data for each timestamp.
   for (const signedData of batchSignedData) {
     const requestTimestamp = Number.parseInt(signedData.timestamp, 10);
-    const goReadDb = await go(async () => get(signedData.airnode, signedData.templateId, requestTimestamp));
-    if (goReadDb.data && requestTimestamp === Number.parseInt(goReadDb.data.timestamp, 10)) {
-      logger.debug('Not storing signed data because signed data with the same timestamp already exists.', {
+    const goReadDb = await go(async () => get(signedData.airnode, signedData.templateId));
+
+    if (goReadDb.data && requestTimestamp <= Number.parseInt(goReadDb.data.timestamp, 10)) {
+      logger.debug('Not storing signed data because the signed data is not newer than what we already have.', {
+        signedData,
+      });
+      continue;
+    }
+
+    if (Date.now() / 1000 - requestTimestamp > 60 * 60) {
+      logger.debug('Not storing signed data because the timestamp is older than one hour.', {
         signedData,
       });
       continue;

packages/api/src/in-memory-cache.ts

@@ -9,8 +9,12 @@ export const ignoreTooFreshData = (signedDatas: SignedData[], ignoreAfterTimesta
   signedDatas.filter((data) => !isIgnored(data, ignoreAfterTimestamp));
 
 // The API is deliberately asynchronous to mimic a database call.
-// eslint-disable-next-line @typescript-eslint/require-await
-export const get = async (airnodeAddress: string, templateId: string, ignoreAfterTimestamp: number) => {
+export const get = async (
+  airnodeAddress: string,
+  templateId: string,
+  ignoreAfterTimestamp = Number.MAX_SAFE_INTEGER
+  // eslint-disable-next-line @typescript-eslint/require-await
+) => {
   logger.debug('Getting signed data.', { airnodeAddress, templateId, ignoreAfterTimestamp });
 
   const signedDataCache = getCache();