refactor: improves encapsulation of console-api (#2249)

Author: stalniy

apps/api/env/.env.mainnet

@@ -1,2 +1,3 @@
 RPC_NODE_ENDPOINT=https://consolerpc.akashnet.net
+REST_API_NODE_URL=https://consoleapi.akashnet.net
 DEPLOYMENT_GRANT_DENOM=ibc/170C677610AC31DF0904FFE09CD3B5C657492170E7E52372E48756B71E56F2F1

apps/api/env/.env.sandbox

@@ -1,2 +1,3 @@
 RPC_NODE_ENDPOINT=https://rpc.sandbox-2.aksh.pw:443
-DEPLOYMENT_GRANT_DENOM=uakt
+REST_API_NODE_URL=https://api.sandbox-2.aksh.pw:443
+DEPLOYMENT_GRANT_DENOM=uakt

apps/api/src/billing/lib/wallet/wallet.ts

@@ -4,62 +4,54 @@ import type { DirectSignResponse, OfflineDirectSigner } from "@cosmjs/proto-sign
 import { DirectSecp256k1HdWallet } from "@cosmjs/proto-signing";
 import type { DirectSecp256k1HdWalletOptions } from "@cosmjs/proto-signing/build/directsecp256k1hdwallet";
 
+export const WALLET_ADDRESS_PREFIX = "akash";
+
 export class Wallet implements OfflineDirectSigner {
   static create(mnemonic?: string, index?: number): Wallet {
     return new Wallet(mnemonic, index);
   }
 
-  private readonly PREFIX = "akash";
-
-  private readonly instanceAsPromised: Promise<DirectSecp256k1HdWallet>;
-  private aminoSignerPromise?: Promise<OfflineAminoSigner>;
-  private readonly walletIndex?: number;
+  readonly #instanceAsPromised: Promise<DirectSecp256k1HdWallet>;
+  #aminoSignerPromise?: Promise<OfflineAminoSigner>;
+  #walletIndex?: number;
 
   constructor(mnemonic?: string, index?: number) {
-    this.walletIndex = index;
+    this.#walletIndex = index;
     if (typeof mnemonic === "undefined") {
-      this.instanceAsPromised = DirectSecp256k1HdWallet.generate(24, this.getInstanceOptions(index));
+      this.#instanceAsPromised = DirectSecp256k1HdWallet.generate(24, this.getInstanceOptions(index));
     } else {
-      this.instanceAsPromised = DirectSecp256k1HdWallet.fromMnemonic(mnemonic, this.getInstanceOptions(index));
+      this.#instanceAsPromised = DirectSecp256k1HdWallet.fromMnemonic(mnemonic, this.getInstanceOptions(index));
     }
   }
 
   private getInstanceOptions(index?: number): Partial<DirectSecp256k1HdWalletOptions> {
     if (typeof index === "undefined") {
-      return { prefix: this.PREFIX };
+      return { prefix: WALLET_ADDRESS_PREFIX };
     }
 
     return {
-      prefix: this.PREFIX,
+      prefix: WALLET_ADDRESS_PREFIX,
       hdPaths: [makeCosmoshubPath(index)]
     };
   }
 
   async getAccounts() {
-    return (await this.instanceAsPromised).getAccounts();
+    return (await this.#instanceAsPromised).getAccounts();
   }
 
   async signDirect(...args: Parameters<DirectSecp256k1HdWallet["signDirect"]>): Promise<DirectSignResponse> {
-    return (await this.instanceAsPromised).signDirect(...args);
+    return (await this.#instanceAsPromised).signDirect(...args);
   }
 
   async signAmino(address: string, data: StdSignDoc): Promise<AminoSignResponse> {
-    const wallet = await this.instanceAsPromised;
-    this.aminoSignerPromise ??= Secp256k1HdWallet.fromMnemonic(wallet.mnemonic, this.getInstanceOptions(this.walletIndex));
-    const aminoSigner = await this.aminoSignerPromise;
+    const wallet = await this.#instanceAsPromised;
+    this.#aminoSignerPromise ??= Secp256k1HdWallet.fromMnemonic(wallet.mnemonic, this.getInstanceOptions(this.#walletIndex));
+    const aminoSigner = await this.#aminoSignerPromise;
     return aminoSigner.signAmino(address, data);
   }
 
-  async getFirstAddress() {
+  async getFirstAddress(): Promise<string> {
     const accounts = await this.getAccounts();
     return accounts[0].address;
   }
-
-  async getMnemonic() {
-    return (await this.instanceAsPromised).mnemonic;
-  }
-
-  async getInstance() {
-    return await this.instanceAsPromised;
-  }
 }

apps/api/src/billing/services/financial-stats/financial-stats.service.ts

@@ -1,13 +1,11 @@
 import { Provider } from "@akashnetwork/database/dbSchemas/akash";
-import { CosmosDistributionCommunityPoolResponse, CosmosHttpService } from "@akashnetwork/http-sdk";
-import axios from "axios";
+import { CosmosHttpService } from "@akashnetwork/http-sdk";
 import { Op, QueryTypes } from "sequelize";
 import { singleton } from "tsyringe";
 
 import { USDC_IBC_DENOMS } from "@src/billing/config/network.config";
 import { UserWalletRepository } from "@src/billing/repositories";
 import { chainDb } from "@src/db/dbConnection";
-import { apiNodeUrl } from "@src/utils/constants";
 import { TxManagerService } from "../tx-manager/tx-manager.service";
 
 @singleton()
@@ -48,9 +46,9 @@ export class FinancialStatsService {
     return balances;
   }
 
-  async getCommunityPoolUsdc() {
-    const communityPoolData = await axios.get<CosmosDistributionCommunityPoolResponse>(`${apiNodeUrl}/cosmos/distribution/v1beta1/community_pool`);
-    return parseFloat(communityPoolData.data.pool.find(x => x.denom === USDC_IBC_DENOMS.mainnetId)?.amount || "0");
+  async getCommunityPoolUsdc(): Promise<number> {
+    const pool = await this.cosmosHttpService.getCommunityPool();
+    return parseFloat(pool.find(x => x.denom === USDC_IBC_DENOMS.mainnetId)?.amount || "0");
   }
 
   async getProviderRevenues() {

apps/api/src/billing/services/managed-user-wallet/managed-user-wallet.service.ts

@@ -25,10 +25,6 @@ interface SpendingAuthorizationOptions {
 
 @singleton()
 export class ManagedUserWalletService {
-  private readonly PREFIX = "akash";
-
-  private readonly HD_PATH = "m/44'/118'/0'/0";
-
   private readonly logger = LoggerService.forContext(ManagedUserWalletService.name);
 
   constructor(

apps/api/src/chain/services/block-http/block-http.service.spec.ts

@@ -1,24 +1,24 @@
 import "@test/mocks/logger-service.mock";
 
-import { BlockHttpService as BlockHttpServiceCommon } from "@akashnetwork/http-sdk";
+import type { BlockHttpService as BlockHttpServiceCommon } from "@akashnetwork/http-sdk";
 import { faker } from "@faker-js/faker";
+import { mock } from "jest-mock-extended";
 
 import { BlockHttpService } from "./block-http.service";
 
 describe(BlockHttpService.name, () => {
-  let service: BlockHttpService;
-  let blockHttpService: BlockHttpServiceCommon;
-
-  beforeEach(() => {
-    blockHttpService = new BlockHttpServiceCommon();
-    service = new BlockHttpService(blockHttpService);
-  });
-
   it("should get current height", async () => {
+    const { blockHttpService, service } = setup();
     const height = faker.number.int({ min: 1000000, max: 10000000 });
     jest.spyOn(blockHttpService, "getCurrentHeight").mockResolvedValue(height);
     const result = await service.getCurrentHeight();
 
     expect(result).toBe(height);
   });
+
+  function setup() {
+    const blockHttpService = mock<BlockHttpServiceCommon>();
+    const service = new BlockHttpService(blockHttpService);
+    return { blockHttpService, service };
+  }
 });

apps/api/src/console.ts

@@ -105,10 +105,7 @@ async function executeCliHandler(name: string, handler: () => Promise<unknown>,
 }
 
 const shutdown = once(async () => {
-  // eslint-disable-next-line @typescript-eslint/no-var-requires
-  const { closeConnections } = require("./core/providers/postgres.provider");
-
-  await Promise.all([closeConnections(), chainDb.close(), container.dispose()]);
+  await container.dispose();
 });
 process.on("SIGTERM", shutdown);
 process.on("SIGINT", shutdown);

apps/api/src/core/config/env.config.ts

@@ -1,3 +1,4 @@
+import { netConfig } from "@akashnetwork/net";
 import { z } from "zod";
 
 export const envSchema = z
@@ -23,7 +24,11 @@ export const envSchema = z
     FEATURE_FLAGS_ENABLE_ALL: z
       .string()
       .default("false")
-      .transform(value => value === "true")
+      .transform(value => value === "true"),
+    REST_API_NODE_URL: z
+      .string()
+      .url()
+      .default(() => netConfig.getBaseAPIUrl(process.env.NETWORK || "mainnet"))
   })
   .superRefine((value, ctx) => {
     if (!value.FEATURE_FLAGS_ENABLE_ALL && (!value.UNLEASH_SERVER_API_URL || !value.UNLEASH_SERVER_API_TOKEN)) {
@@ -34,4 +39,4 @@ export const envSchema = z
     }
   });
 
-export const envConfig = envSchema.parse(process.env);
+export type CoreConfig = z.infer<typeof envSchema>;

apps/api/src/core/config/index.ts

@@ -24,9 +24,8 @@ export class DisposableRegistry implements Disposable {
     return container.resolve(DisposableRegistry).registerFromFactory(factory);
   }
 
-  private isDisposed = false;
-
-  private readonly disposes: Array<() => Promise<void> | void> = [];
+  #isDisposed = false;
+  readonly #disposables: Disposable[] = [];
 
   /**
    * Wraps a factory function to automatically register disposable instances.
@@ -41,15 +40,18 @@ export class DisposableRegistry implements Disposable {
   registerFromFactory<T>(factory: FactoryProvider<T>["useFactory"]): FactoryProvider<T>["useFactory"] {
     return container => {
       const value = factory(container);
-
       if (this.isDisposable(value)) {
-        this.disposes.push(() => value.dispose());
+        this.register(value as Disposable);
       }
 
       return value;
     };
   }
 
+  register(item: Disposable): void {
+    this.#disposables.push(item);
+  }
+
   /**
    * Disposes all registered disposable instances.
    *
@@ -65,17 +67,17 @@ export class DisposableRegistry implements Disposable {
    * @returns A promise that resolves when all dispose operations complete successfully.
    * @throws AggregateError if any dispose operations failed, containing all failure reasons.
    */
-  async dispose() {
-    if (this.isDisposed) {
+  async dispose(): Promise<void> {
+    if (this.#isDisposed) {
       return;
     }
 
-    this.isDisposed = true;
+    this.#isDisposed = true;
 
-    const results = await Promise.allSettled(this.disposes.map(dispose => dispose()));
+    const results = await Promise.allSettled(this.#disposables.map(item => item.dispose()));
     const errors = results.filter((r): r is PromiseRejectedResult => r.status === "rejected");
 
-    this.disposes.length = 0;
+    this.#disposables.length = 0;
 
     if (errors.length > 0) {
       throw new AggregateError(