Merge branch 'main' into raw-prices-api

safe-global · Nov 8, 2024 · af62ce5 · af62ce5
1 parent 602051d
commit af62ce5
Show file tree

Hide file tree

Showing 33 changed files with 246 additions and 119 deletions.
diff --git a/src/app.module.e2e-spec.ts b/src/app.module.e2e-spec.ts
@@ -1,11 +1,28 @@
 import { Test } from '@nestjs/testing';
 import { AppModule } from '@/app.module';
+import { CacheKeyPrefix } from '@/datasources/cache/constants';
+import { TestPostgresDatabaseModule } from '@/datasources/db/__tests__/test.postgres-database.module';
+import { PostgresDatabaseModule } from '@/datasources/db/v1/postgres-database.module';
+import { PostgresDatabaseModuleV2 } from '@/datasources/db/v2/postgres-database.module';
+import { TestPostgresDatabaseModuleV2 } from '@/datasources/db/v2/test.postgres-database.module';
+import { TestQueuesApiModule } from '@/datasources/queues/__tests__/test.queues-api.module';
+import { QueuesApiModule } from '@/datasources/queues/queues-api.module';
 
 describe('Application bootstrap', () => {
   it('should init the app', async () => {
+    const cacheKeyPrefix = crypto.randomUUID();
     const moduleRef = await Test.createTestingModule({
       imports: [AppModule.register()],
-    }).compile();
+    })
+      .overrideProvider(CacheKeyPrefix)
+      .useValue(cacheKeyPrefix)
+      .overrideModule(PostgresDatabaseModule)
+      .useModule(TestPostgresDatabaseModule)
+      .overrideModule(PostgresDatabaseModuleV2)
+      .useModule(TestPostgresDatabaseModuleV2)
+      .overrideModule(QueuesApiModule)
+      .useModule(TestQueuesApiModule)
+      .compile();
 
     const app = moduleRef.createNestApplication();
     await app.init();

diff --git a/src/datasources/balances-api/balances-api.manager.spec.ts b/src/datasources/balances-api/balances-api.manager.spec.ts
@@ -156,7 +156,7 @@ describe('Balances API Manager Tests', () => {
         else if (key === 'features.counterfactualBalances') return true;
         throw new Error(`Unexpected key: ${key}`);
       });
-      configApiMock.getChain.mockResolvedValue(chain);
+      configApiMock.getChain.mockResolvedValue(rawify(chain));
       dataSourceMock.get.mockResolvedValue([]);
       coingeckoApiMock.getTokenPrices.mockResolvedValue(rawify([]));
       const balancesApiManager = new BalancesApiManager(

diff --git a/src/datasources/balances-api/balances-api.manager.ts b/src/datasources/balances-api/balances-api.manager.ts
@@ -16,6 +16,7 @@ import { intersection } from 'lodash';
 import { ITransactionApiManager } from '@/domain/interfaces/transaction-api.manager.interface';
 import { z } from 'zod';
 import { type Raw, rawify } from '@/validation/entities/raw.entity';
+import { ChainSchema } from '@/domain/chains/entities/schemas/chain.schema';
 
 @Injectable()
 export class BalancesApiManager implements IBalancesApiManager {
@@ -85,7 +86,9 @@ export class BalancesApiManager implements IBalancesApiManager {
     const safeBalancesApi = this.safeBalancesApiMap[chainId];
     if (safeBalancesApi !== undefined) return safeBalancesApi;
 
-    const chain = await this.configApi.getChain(chainId);
+    const chain = await this.configApi
+      .getChain(chainId)
+      .then(ChainSchema.parse);
     this.safeBalancesApiMap[chainId] = new SafeBalancesApi(
       chainId,
       this.useVpcUrl ? chain.vpcTransactionService : chain.transactionService,

diff --git a/src/datasources/blockchain/blockchain-api.manager.spec.ts b/src/datasources/blockchain/blockchain-api.manager.spec.ts
@@ -6,6 +6,7 @@ import { chainBuilder } from '@/domain/chains/entities/__tests__/chain.builder';
 import { rpcUriBuilder } from '@/domain/chains/entities/__tests__/rpc-uri.builder';
 import { RpcUriAuthentication } from '@/domain/chains/entities/rpc-uri-authentication.entity';
 import type { IConfigApi } from '@/domain/interfaces/config-api.interface';
+import { rawify } from '@/validation/entities/raw.entity';
 import { faker } from '@faker-js/faker';
 import { hexToNumber, toHex } from 'viem';
 
@@ -39,7 +40,7 @@ describe('BlockchainApiManager', () => {
   describe('getApi', () => {
     it('caches the API', async () => {
       const chain = chainBuilder().build();
-      configApiMock.getChain.mockResolvedValue(chain);
+      configApiMock.getChain.mockResolvedValue(rawify(chain));
 
       const api = await target.getApi(chain.chainId);
       const cachedApi = await target.getApi(chain.chainId);
@@ -58,7 +59,7 @@ describe('BlockchainApiManager', () => {
             .build(),
         )
         .build();
-      configApiMock.getChain.mockResolvedValue(chain);
+      configApiMock.getChain.mockResolvedValue(rawify(chain));
 
       const api = await target.getApi(chain.chainId);
 
@@ -70,7 +71,7 @@ describe('BlockchainApiManager', () => {
       const chain = chainBuilder()
         .with('rpcUri', rpcUriBuilder().with('value', rpcUriValue).build())
         .build();
-      configApiMock.getChain.mockResolvedValue(chain);
+      configApiMock.getChain.mockResolvedValue(rawify(chain));
 
       const api = await target.getApi(chain.chainId);
 
@@ -79,7 +80,7 @@ describe('BlockchainApiManager', () => {
 
     it('should not include the INFURA_API_KEY in the RPC URI for a RPC provider different from Infura', async () => {
       const chain = chainBuilder().build();
-      configApiMock.getChain.mockResolvedValue(chain);
+      configApiMock.getChain.mockResolvedValue(rawify(chain));
 
       const api = await target.getApi(chain.chainId);
 
@@ -90,7 +91,7 @@ describe('BlockchainApiManager', () => {
   describe('destroyApi', () => {
     it('clears the API', async () => {
       const chain = chainBuilder().build();
-      configApiMock.getChain.mockResolvedValue(chain);
+      configApiMock.getChain.mockResolvedValue(rawify(chain));
 
       const api = await target.getApi(chain.chainId);
       target.destroyApi(chain.chainId);

diff --git a/src/datasources/blockchain/blockchain-api.manager.ts b/src/datasources/blockchain/blockchain-api.manager.ts
@@ -6,6 +6,7 @@ import {
 } from '@/datasources/cache/cache.service.interface';
 import { Chain as DomainChain } from '@/domain/chains/entities/chain.entity';
 import { RpcUriAuthentication } from '@/domain/chains/entities/rpc-uri-authentication.entity';
+import { ChainSchema } from '@/domain/chains/entities/schemas/chain.schema';
 import { IBlockchainApiManager } from '@/domain/interfaces/blockchain-api.manager.interface';
 import { IConfigApi } from '@/domain/interfaces/config-api.interface';
 import { Inject, Injectable } from '@nestjs/common';
@@ -46,7 +47,9 @@ export class BlockchainApiManager implements IBlockchainApiManager {
       return blockchainApi;
     }
 
-    const chain = await this.configApi.getChain(chainId);
+    const chain = await this.configApi
+      .getChain(chainId)
+      .then(ChainSchema.parse);
     this.blockchainApiMap[chainId] = this._createCachedRpcClient(chain);
 
     return this.blockchainApiMap[chainId];

diff --git a/src/datasources/config-api/config-api.service.ts b/src/datasources/config-api/config-api.service.ts
@@ -11,8 +11,13 @@ import { Page } from '@/domain/entities/page.entity';
 import { IConfigApi } from '@/domain/interfaces/config-api.interface';
 import { SafeApp } from '@/domain/safe-apps/entities/safe-app.entity';
 import { ILoggingService, LoggingService } from '@/logging/logging.interface';
+import { Raw } from '@/validation/entities/raw.entity';
 import { Inject, Injectable } from '@nestjs/common';
 
+/**
+ * TODO: Move all usage of Raw to CacheFirstDataSource after fully migrated
+ * to "Raw" type implementation.
+ */
 @Injectable()
 export class ConfigApi implements IConfigApi {
   private readonly baseUri: string;
@@ -47,12 +52,12 @@ export class ConfigApi implements IConfigApi {
   async getChains(args: {
     limit?: number;
     offset?: number;
-  }): Promise<Page<Chain>> {
+  }): Promise<Raw<Page<Chain>>> {
     try {
       const url = `${this.baseUri}/api/v1/chains`;
       const params = { limit: args.limit, offset: args.offset };
       const cacheDir = CacheRouter.getChainsCacheDir(args);
-      return await this.dataSource.get({
+      return await this.dataSource.get<Raw<Chain>>({
         cacheDir,
         url,
         notFoundExpireTimeSeconds: this.defaultNotFoundExpirationTimeSeconds,
@@ -64,11 +69,11 @@ export class ConfigApi implements IConfigApi {
     }
   }
 
-  async getChain(chainId: string): Promise<Chain> {
+  async getChain(chainId: string): Promise<Raw<Chain>> {
     try {
       const url = `${this.baseUri}/api/v1/chains/${chainId}`;
       const cacheDir = CacheRouter.getChainCacheDir(chainId);
-      return await this.dataSource.get({
+      return await this.dataSource.get<Raw<Chain>>({
         cacheDir,
         url,
         notFoundExpireTimeSeconds: this.defaultNotFoundExpirationTimeSeconds,
@@ -98,7 +103,7 @@ export class ConfigApi implements IConfigApi {
     clientUrl?: string;
     onlyListed?: boolean;
     url?: string;
-  }): Promise<SafeApp[]> {
+  }): Promise<Raw<SafeApp[]>> {
     try {
       const providerUrl = `${this.baseUri}/api/v1/safe-apps/`;
       const params = {

diff --git a/src/datasources/db/v2/__tests__/postgresql-database.service.mock.ts b/src/datasources/db/v2/__tests__/postgresql-database.service.mock.ts
@@ -18,5 +18,4 @@ export const mockPostgresDatabaseService = {
         return callback(mockEntityManager);
       },
     ),
-  getTransactionRunner: jest.fn().mockReturnValue(mockEntityManager),
 } as jest.MockedObjectDeep<PostgresDatabaseService>;
diff --git a/src/datasources/db/v2/postgres-database.service.ts b/src/datasources/db/v2/postgres-database.service.ts
@@ -13,8 +13,6 @@ import {
 
 @Injectable()
 export class PostgresDatabaseService {
-  private transactionManager?: EntityManager = undefined;
-
   public constructor(
     @Inject(LoggingService) private readonly loggingService: ILoggingService,
     @InjectDataSource()
@@ -88,18 +86,9 @@ export class PostgresDatabaseService {
     callback: (transactionManager: EntityManager) => Promise<T>,
   ): Promise<T> {
     return this.dataSource.transaction(
-      async (transactionalEntityManager): Promise<T> => {
-        this.transactionManager = transactionalEntityManager;
-        return await callback(this.transactionManager);
+      async (transactionalEntityManager: EntityManager): Promise<T> => {
+        return await callback(transactionalEntityManager);
       },
     );
   }
-
-  public getTransactionRunner(): EntityManager {
-    if (!this.transactionManager) {
-      throw new Error('Query runner is not initialized...');
-    }
-
-    return this.transactionManager;
-  }
 }
diff --git a/src/datasources/errors/http-error-factory.ts b/src/datasources/errors/http-error-factory.ts
@@ -15,7 +15,6 @@ import { get } from 'lodash';
 @Injectable()
 export class HttpErrorFactory {
   from(source: unknown): DataSourceError {
-    // TODO: Handle instances of ZodError, returning issue from it
     if (source instanceof NetworkResponseError) {
       const errorMessage = get(source, 'data.message', 'An error occurred');
       return new DataSourceError(errorMessage, source.response.status);

diff --git a/src/datasources/jwt/jwt.module.ts b/src/datasources/jwt/jwt.module.ts
@@ -17,7 +17,7 @@ function jwtClientFactory() {
       },
     >(
       payload: T,
-      options: { secretOrPrivateKey: string },
+      options: { secretOrPrivateKey: string; algorithm?: jwt.Algorithm },
     ): string => {
       // All date-based claims should be second-based NumericDates
       const { exp, iat, nbf, ...rest } = payload;
@@ -30,24 +30,35 @@ function jwtClientFactory() {
           ...rest,
         },
         options.secretOrPrivateKey,
+        { algorithm: options.algorithm },
       );
     },
     verify: <T extends object>(
       token: string,
-      options: { issuer: string; secretOrPrivateKey: string },
+      options: {
+        issuer: string;
+        secretOrPrivateKey: string;
+        algorithms?: Array<jwt.Algorithm>;
+      },
     ): T => {
       return jwt.verify(token, options.secretOrPrivateKey, {
+        algorithms: options.algorithms,
         issuer: options.issuer,
         // Return only payload without claims, e.g. no exp, nbf, etc.
         complete: false,
       }) as T;
     },
     decode: <T extends object>(
       token: string,
-      options: { issuer: string; secretOrPrivateKey: string },
+      options: {
+        issuer: string;
+        secretOrPrivateKey: string;
+        algorithms?: Array<jwt.Algorithm>;
+      },
     ): JwtPayloadWithClaims<T> => {
       // Client has `decode` method but we also want to verify the signature
       const { payload } = jwt.verify(token, options.secretOrPrivateKey, {
+        algorithms: options.algorithms,
         issuer: options.issuer,
         // Return headers, payload (with claims) and signature
         complete: true,

diff --git a/src/datasources/jwt/jwt.service.interface.ts b/src/datasources/jwt/jwt.service.interface.ts
@@ -1,4 +1,5 @@
 import type { JwtPayloadWithClaims } from '@/datasources/jwt/jwt-claims.entity';
+import type { Algorithm } from 'jsonwebtoken';
 
 export const IJwtService = Symbol('IJwtService');
 
@@ -13,6 +14,7 @@ export interface IJwtService {
     payload: T,
     options?: {
       secretOrPrivateKey: string;
+      algorithm?: Algorithm;
     },
   ): string;
 

diff --git a/src/datasources/jwt/jwt.service.spec.ts b/src/datasources/jwt/jwt.service.spec.ts
@@ -44,6 +44,7 @@ describe('JwtService', () => {
         { iss: configIssuer, ...payload },
         {
           secretOrPrivateKey: configSecret,
+          algorithm: 'HS256',
         },
       );
     });
@@ -63,8 +64,27 @@ describe('JwtService', () => {
       expect(jwtClientMock.sign).toHaveBeenCalledTimes(1);
       expect(jwtClientMock.sign).toHaveBeenCalledWith(payload, {
         secretOrPrivateKey: customSecret,
+        algorithm: 'HS256',
       });
     });
+
+    it('should sign a payload with RS256 algorithm', () => {
+      const payload = JSON.parse(fakeJson()) as object;
+
+      service.sign(payload, {
+        secretOrPrivateKey: configSecret,
+        algorithm: 'RS256',
+      });
+
+      expect(jwtClientMock.sign).toHaveBeenCalledTimes(1);
+      expect(jwtClientMock.sign).toHaveBeenCalledWith(
+        { iss: configIssuer, ...payload },
+        {
+          secretOrPrivateKey: configSecret,
+          algorithm: 'RS256',
+        },
+      );
+    });
   });
 
   describe('verify', () => {
@@ -96,6 +116,25 @@ describe('JwtService', () => {
         secretOrPrivateKey: customSecret,
       });
     });
+
+    it('should verify a token with RS256 algorithm', () => {
+      const token = faker.string.alphanumeric();
+      const customIssuer = faker.word.noun();
+      const customSecret = faker.string.alphanumeric();
+
+      service.verify(token, {
+        issuer: customIssuer,
+        secretOrPrivateKey: customSecret,
+        algorithms: ['RS256'],
+      });
+
+      expect(jwtClientMock.verify).toHaveBeenCalledTimes(1);
+      expect(jwtClientMock.verify).toHaveBeenCalledWith(token, {
+        issuer: customIssuer,
+        secretOrPrivateKey: customSecret,
+        algorithms: ['RS256'],
+      });
+    });
   });
 
   describe('decode', () => {
@@ -127,5 +166,24 @@ describe('JwtService', () => {
         secretOrPrivateKey: customSecret,
       });
     });
+
+    it('should decode a token with RS256 Algorithm', () => {
+      const token = faker.string.alphanumeric();
+      const customIssuer = faker.word.noun();
+      const customSecret = faker.string.alphanumeric();
+
+      service.decode(token, {
+        issuer: customIssuer,
+        secretOrPrivateKey: customSecret,
+        algorithms: ['RS256'],
+      });
+
+      expect(jwtClientMock.decode).toHaveBeenCalledTimes(1);
+      expect(jwtClientMock.decode).toHaveBeenCalledWith(token, {
+        issuer: customIssuer,
+        secretOrPrivateKey: customSecret,
+        algorithms: ['RS256'],
+      });
+    });
   });
 });