refactor: improves encapsulation of app

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,63 +4,60 @@ 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;
+  async createDerivedWallet(index: number): Promise<Wallet> {
+    const instance = await this.#instanceAsPromised;
+    return new Wallet(instance.mnemonic, index);
   }
 }
 

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

@@ -1,33 +1,29 @@
 import { Provider } from "@akashnetwork/database/dbSchemas/akash";
-import { CosmosDistributionCommunityPoolResponse, CosmosHttpService } from "@akashnetwork/http-sdk";
-import { DirectSecp256k1HdWallet } from "@cosmjs/proto-signing";
-import axios from "axios";
+import { CosmosHttpService } from "@akashnetwork/http-sdk";
 import { Op, QueryTypes } from "sequelize";
-import { singleton } from "tsyringe";
+import { inject, singleton } from "tsyringe";
 
 import { USDC_IBC_DENOMS } from "@src/billing/config/network.config";
-import { type BillingConfig, InjectBillingConfig } from "@src/billing/providers";
+import type { Wallet } from "@src/billing/lib/wallet/wallet";
+import { MANAGED_MASTER_WALLET } from "@src/billing/providers/wallet.provider";
 import { UserWalletRepository } from "@src/billing/repositories";
 import { chainDb } from "@src/db/dbConnection";
-import { apiNodeUrl } from "@src/utils/constants";
 
 @singleton()
 export class FinancialStatsService {
   constructor(
-    @InjectBillingConfig() private readonly config: BillingConfig,
     private readonly userWalletRepository: UserWalletRepository,
-    private readonly cosmosHttpService: CosmosHttpService
+    private readonly cosmosHttpService: CosmosHttpService,
+    @inject(MANAGED_MASTER_WALLET) private readonly managedMasterWallet: Wallet
   ) {}
 
   async getPayingUserCount() {
     return this.userWalletRepository.payingUserCount();
   }
 
-  async getMasterWalletBalanceUsdc() {
-    const wallet = await DirectSecp256k1HdWallet.fromMnemonic(this.config.MASTER_WALLET_MNEMONIC, { prefix: "akash" });
-    const [account] = await wallet.getAccounts();
-
-    return this.getWalletBalances(account.address, USDC_IBC_DENOMS.mainnetId);
+  async getMasterWalletBalanceUsdc(): Promise<number> {
+    const address = await this.managedMasterWallet.getFirstAddress();
+    return this.getWalletBalances(address, USDC_IBC_DENOMS.mainnetId);
   }
 
   private async getWalletBalances(address: string, denom: string) {
@@ -52,9 +48,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

@@ -1,7 +1,6 @@
 import { AuthzHttpService } from "@akashnetwork/http-sdk";
 import { LoggerService } from "@akashnetwork/logging";
-import { stringToPath } from "@cosmjs/crypto";
-import { DirectSecp256k1HdWallet, EncodeObject } from "@cosmjs/proto-signing";
+import { EncodeObject } from "@cosmjs/proto-signing";
 import add from "date-fns/add";
 import { singleton } from "tsyringe";
 
@@ -27,10 +26,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(
@@ -56,16 +51,12 @@ export class ManagedUserWalletService {
     return { address, limits };
   }
 
-  async createWallet({ addressIndex }: { addressIndex: number }) {
-    const hdPath = stringToPath(`${this.HD_PATH}/${addressIndex}`);
-    const wallet = await DirectSecp256k1HdWallet.fromMnemonic(this.config.MASTER_WALLET_MNEMONIC, {
-      prefix: this.PREFIX,
-      hdPaths: [hdPath]
-    });
-    const [account] = await wallet.getAccounts();
-    this.logger.debug({ event: "WALLET_CREATED", address: account.address });
+  async createWallet(input: { addressIndex: number }): Promise<{ address: string }> {
+    const wallet = await this.masterWallet.createDerivedWallet(input.addressIndex);
+    const address = await wallet.getFirstAddress();
+    this.logger.debug({ event: "WALLET_CREATED", address });
 
-    return { address: account.address };
+    return { address };
   }
 
   async authorizeSpending(options: SpendingAuthorizationOptions) {

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

@@ -119,10 +119,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

@@ -1,9 +1,13 @@
-import { container } from "tsyringe";
+import type { InjectionToken } from "tsyringe";
+import { container, instancePerContainerCachingFactory } from "tsyringe";
 
-import { config } from "@src/core/config";
+import type { CoreConfig } from "../config/env.config";
+import { envSchema } from "../config/env.config";
 
-export const CORE_CONFIG = "CORE_CONFIG";
+export const CORE_CONFIG: InjectionToken<CoreConfig> = "CORE_CONFIG";
 
-container.register(CORE_CONFIG, { useValue: config });
+container.register(CORE_CONFIG, {
+  useFactory: instancePerContainerCachingFactory(() => envSchema.parse(process.env))
+});
 
-export type CoreConfig = typeof config;
+export type { CoreConfig };