feat(backend): get_historical_balance endpoint

backend/src/db/schema.ts

@@ -15,6 +15,7 @@ export const usdcTransfer = pgTable('transfer_usdc', {
 });
 
 export const usdcBalance = pgTable('balance_usdc', {
+  balanceId: text('balance_id').primaryKey(),
   network: text('network'),
   blockNumber: bigint('block_number', { mode: 'number' }),
   blockTimestamp: timestamp('block_timestamp', { withTimezone: false }),

backend/src/routes/getHistoricalBalance.ts

@@ -0,0 +1,46 @@
+import { sql } from 'drizzle-orm';
+import type { FastifyInstance } from 'fastify';
+import { usdcBalance } from '../db/schema';
+
+const addressRegex = /^0x0[0-9a-fA-F]{63}$/;
+
+export function getHistoricalBalanceRoute(fastify: FastifyInstance) {
+  fastify.get('/get_historical_balance', async (request, reply) => {
+    const { address } = request.query as { address?: string };
+
+    if (!address) {
+      return reply.status(400).send({ error: 'Address is required' });
+    }
+
+    // Validate address format
+    if (!addressRegex.test(address)) {
+      return reply.status(400).send({ error: 'Invalid address format' });
+    }
+
+    try {
+      const historicalBalances = await fastify.db.execute(
+        sql`
+          SELECT balance, DATE(block_timestamp) AS date
+          FROM ${usdcBalance}
+          WHERE (address, block_timestamp) IN (
+            SELECT address, MAX(block_timestamp) AS max_timestamp
+            FROM ${usdcBalance}
+            WHERE address = ${address}
+            GROUP BY address, DATE(block_timestamp) 
+          )
+        `,
+      );
+
+      if (!historicalBalances) {
+        return reply.status(404).send({ error: 'Error while retrieving historical balance' });
+      }
+
+      return reply.send({
+        historicalBalances,
+      });
+    } catch (error) {
+      console.error(error);
+      return reply.status(500).send({ error: 'Internal server error' });
+    }
+  });
+}

backend/src/routes/index.ts

@@ -3,10 +3,12 @@ import { sql } from 'drizzle-orm';
 import type { FastifyInstance, FastifyReply, FastifyRequest } from 'fastify';
 
 import { getBalanceRoute } from './getBalance';
+import { getHistoricalBalanceRoute } from './getHistoricalBalance';
 
 export function declareRoutes(fastify: FastifyInstance) {
   getStatusRoute(fastify);
   getBalanceRoute(fastify);
+  getHistoricalBalanceRoute(fastify);
 }
 
 function getStatusRoute(fastify: FastifyInstance) {

backend/src/test/getHistoricalBalance.test.ts

@@ -0,0 +1,111 @@
+import { PostgreSqlContainer, type StartedPostgreSqlContainer } from '@testcontainers/postgresql';
+import type { FastifyInstance } from 'fastify';
+import { afterAll, beforeAll, describe, expect, test } from 'vitest';
+
+import { buildApp } from '@/app';
+import * as schema from '../db/schema';
+
+describe('GET /get_historical_balance route', () => {
+  let container: StartedPostgreSqlContainer;
+  let app: FastifyInstance;
+  const testAddress = '0x064a24243f2aabae8d2148fa878276e6e6e452e3941b417f3c33b1649ea83e11';
+
+  beforeAll(async () => {
+    container = await new PostgreSqlContainer().start();
+    const connectionUri = container.getConnectionUri();
+    app = buildApp({
+      database: {
+        connectionString: connectionUri,
+      },
+      app: {
+        port: 8080,
+      },
+    });
+
+    await app.ready();
+    await app.db.insert(schema.usdcBalance).values([
+      {
+        balanceId: 'YfuanNvdfMfcmmdeklWDJO',
+        address: testAddress,
+        blockTimestamp: new Date('2024-04-10 13:03:05'),
+        balance: '3.8AE83A109D0635A426BB',
+      },
+      {
+        balanceId: 'jNEhskffmfscvdmdnQMrsz',
+        address: testAddress,
+        blockTimestamp: new Date('2024-04-10 14:03:05'),
+        balance: '3.8AE83A109D0635A426BB',
+      },
+      {
+        balanceId: 'ZkNhudkvfcfKdkgmYfkRj',
+        address: testAddress,
+        blockTimestamp: new Date('2024-04-11 13:03:05'),
+        balance: '3.8AE83A109D0635A426BB',
+      },
+      {
+        balanceId: 'ObZldfvkfgckmflKpXvrd',
+        address: testAddress,
+        blockTimestamp: new Date('2024-04-11 14:03:05'),
+        balance: '3.8AE83A109D0635A426BB',
+      },
+    ]);
+  });
+
+  afterAll(async () => {
+    await app.close();
+    await container.stop();
+  });
+
+  test('should return the historical balances for a valid address', async () => {
+    const response = await app.inject({
+      method: 'GET',
+      url: `/get_historical_balance?address=${testAddress}`,
+    });
+
+    expect(response.statusCode).toBe(200);
+    expect(response.json()).toEqual({
+      historicalBalances: [
+        {
+          date: '2024-04-10',
+          balance: '3.8AE83A109D0635A426BB',
+        },
+        {
+          date: '2024-04-11',
+          balance: '3.8AE83A109D0635A426BB',
+        },
+      ],
+    });
+  });
+
+  test('should return error, invalid address format', async () => {
+    const invalidAddress = '0x0';
+    const response = await app.inject({
+      method: 'GET',
+      url: `/get_historical_balance?address=${invalidAddress}`,
+    });
+
+    expect(response.statusCode).toBe(400);
+    expect(response.json()).toHaveProperty('error', 'Invalid address format');
+  });
+
+  test('should return error, no address provided', async () => {
+    const response = await app.inject({
+      method: 'GET',
+      url: '/get_historical_balance',
+    });
+
+    expect(response.statusCode).toBe(400);
+    expect(response.json()).toHaveProperty('error', 'Address is required');
+  });
+
+  test('should return [], unknown address', async () => {
+    const unknownAddress = '0x064a24243f2aabae8d2148fa878276e6e6e452e3941b417f3c33b1649ea83e12';
+    const response = await app.inject({
+      method: 'GET',
+      url: `/get_historical_balance?address=${unknownAddress}`,
+    });
+
+    expect(response.statusCode).toBe(200);
+    expect(response.json()).toEqual({ historicalBalances: [] });
+  });
+});