fixes after review

Author: stefangutica

src/endpoints/accounts-v2/account.controller.v2.ts

@@ -1,11 +1,11 @@
 import { Controller, Get, NotFoundException, Param, Query, UseInterceptors } from '@nestjs/common';
 import { ApiOkResponse, ApiOperation, ApiQuery, ApiTags } from '@nestjs/swagger';
 import { AccountServiceV2 } from './account.service.v2';
-import { AccountDetailed } from './entities/account.detailed';
-import { ParseAddressPipe, ParseBoolPipe, ParseIntPipe } from '@multiversx/sdk-nestjs-common';
+import { ParseAddressPipe, ParseBoolPipe } from '@multiversx/sdk-nestjs-common';
 import { DeepHistoryInterceptor } from 'src/interceptors/deep-history.interceptor';
-import { AccountFetchOptions } from './entities/account.fetch.options';
 import { NoCache } from '@multiversx/sdk-nestjs-cache';
+import { AccountDetailed } from '../accounts/entities/account.detailed';
+import { AccountFetchOptions } from '../accounts/entities/account.fetch.options';
 
 @Controller('')
 @ApiTags('accounts')
@@ -33,7 +33,6 @@ export class AccountControllerV2 {
     @Query('withScrCount', ParseBoolPipe) withScrCount?: boolean,
     @Query('withTimestamp', ParseBoolPipe) withTimestamp?: boolean,
     @Query('withAssets', ParseBoolPipe) withAssets?: boolean,
-    @Query('timestamp', ParseIntPipe) _timestamp?: number,
   ): Promise<AccountDetailed> {
     const account = await this.accountServiceV2.getAccount(
       address,

src/endpoints/accounts-v2/account.module.v2.ts

@@ -16,6 +16,7 @@ import { AccountServiceV2 } from "./account.service.v2";
 import { ProviderModule } from "../providers/provider.module";
 import { KeysModule } from "../keys/keys.module";
 import { MongoDbModule } from "src/common/indexer/db";
+import { AccountService } from "../accounts/account.service";
 
 @Module({
   imports: [
@@ -37,9 +38,11 @@ import { MongoDbModule } from "src/common/indexer/db";
     MongoDbModule,
   ],
   providers: [
+    AccountService,
     AccountServiceV2,
   ],
   exports: [
+    AccountService,
     AccountServiceV2,
   ],
 })

src/endpoints/accounts-v2/account.service.v2.ts

@@ -1,45 +1,34 @@
-import { forwardRef, HttpStatus, Inject, Injectable } from '@nestjs/common';
-import { AccountDetailed } from './entities/account.detailed';
-import { ApiConfigService } from 'src/common/api-config/api.config.service';
+import { forwardRef, Inject, Injectable } from '@nestjs/common';
 import { PluginService } from 'src/common/plugins/plugin.service';
-import { TransferService } from '../transfers/transfer.service';
-import { TransactionType } from '../transactions/entities/transaction.type';
 import { AssetsService } from 'src/common/assets/assets.service';
-import { TransactionFilter } from '../transactions/entities/transaction.filter';
 import { CacheService } from "@multiversx/sdk-nestjs-cache";
 import { AddressUtils, OriginLogger } from '@multiversx/sdk-nestjs-common';
-import { ApiService } from "@multiversx/sdk-nestjs-http";
-import { GatewayService } from 'src/common/gateway/gateway.service';
 import { IndexerService } from "src/common/indexer/indexer.service";
 import { CacheInfo } from 'src/utils/cache.info';
 import { UsernameService } from '../usernames/username.service';
-import { ProtocolService } from 'src/common/protocol/protocol.service';
 import { ProviderService } from '../providers/provider.service';
-import { AccountFetchOptions } from './entities/account.fetch.options';
 import { Provider } from '../providers/entities/provider';
 import { AccountDetailsRepository } from 'src/common/indexer/db';
 import { StateChangesConsumerService } from 'src/state-changes/state.changes.consumer.service';
+import { AccountService } from '../accounts/account.service';
+import { AccountDetailed } from '../accounts/entities/account.detailed';
+import { AccountFetchOptions } from '../accounts/entities/account.fetch.options';
 
 @Injectable()
 export class AccountServiceV2 {
   private readonly logger = new OriginLogger(AccountServiceV2.name);
 
   constructor(
     private readonly indexerService: IndexerService,
-    private readonly gatewayService: GatewayService,
     private readonly cachingService: CacheService,
-    private readonly apiConfigService: ApiConfigService,
     @Inject(forwardRef(() => PluginService))
     private readonly pluginService: PluginService,
-    @Inject(forwardRef(() => TransferService))
-    private readonly transferService: TransferService,
     private readonly assetsService: AssetsService,
     private readonly usernameService: UsernameService,
-    private readonly apiService: ApiService,
-    private readonly protocolService: ProtocolService,
     @Inject(forwardRef(() => ProviderService))
     private readonly providerService: ProviderService,
     private readonly accountDetailsDepository: AccountDetailsRepository,
+    private readonly accountServiceV1: AccountService,
   ) { }
 
   private async getAccountWithFallBack(address: string, options?: AccountFetchOptions): Promise<AccountDetailed | null> {
@@ -50,7 +39,7 @@ export class AccountServiceV2 {
     }
     if (!accountFromDb) {
       // Second use the legacy method
-      return await this.getAccountRaw(address, options?.withAssets);
+      return await this.accountServiceV1.getAccountRaw(address, options?.withAssets);
     }
     if (options && options.withAssets === true) {
       const assets = await this.assetsService.getAllAccountAssets();
@@ -82,23 +71,23 @@ export class AccountServiceV2 {
           account.username = await this.usernameService.getUsernameForAddress(address) ?? undefined;
         }
       } else {
-        account = await this.getAccountRaw(address, options?.withAssets);
+        account = await this.accountServiceV1.getAccountRaw(address, options?.withAssets);
       }
 
       if (!account) {
         return null;
       }
 
       if (options?.withTxCount === true) {
-        account.txCount = await this.getAccountTxCount(address);
+        account.txCount = await this.accountServiceV1.getAccountTxCount(address);
       }
 
       if (options?.withScrCount === true) {
-        account.scrCount = await this.getAccountScResults(address);
+        account.scrCount = await this.accountServiceV1.getAccountScResults(address);
       }
 
       if (options?.withGuardianInfo === true) {
-        await this.applyGuardianInfo(account);
+        await this.accountServiceV1.applyGuardianInfo(account);
       }
 
       if (options?.withTimestamp) {
@@ -127,161 +116,4 @@ export class AccountServiceV2 {
 
     return account;
   }
-
-  async applyGuardianInfo(account: AccountDetailed): Promise<void> {
-    try {
-      const guardianResult = await this.gatewayService.getGuardianData(account.address);
-      const guardianData = guardianResult?.guardianData;
-      if (guardianData) {
-        const activeGuardian = guardianData.activeGuardian;
-        if (activeGuardian) {
-          account.activeGuardianActivationEpoch = activeGuardian.activationEpoch;
-          account.activeGuardianAddress = activeGuardian.address;
-          account.activeGuardianServiceUid = activeGuardian.serviceUID;
-        }
-
-        const pendingGuardian = guardianData.pendingGuardian;
-        if (pendingGuardian) {
-          account.pendingGuardianActivationEpoch = pendingGuardian.activationEpoch;
-          account.pendingGuardianAddress = pendingGuardian.address;
-          account.pendingGuardianServiceUid = pendingGuardian.serviceUID;
-        }
-
-        account.isGuarded = guardianData.guarded;
-      }
-    } catch (error) {
-      this.logger.error(`Error when getting guardian data for address '${account.address}'`);
-      this.logger.error(error);
-    }
-  }
-
-  async getAccountRaw(address: string, withAssets?: boolean): Promise<AccountDetailed | null> {
-    try {
-      const {
-        account: { nonce, balance, code, codeHash, rootHash, developerReward, ownerAddress, codeMetadata },
-      } = await this.gatewayService.getAddressDetails(address);
-
-      const shardCount = await this.protocolService.getShardCount();
-      const shard = AddressUtils.computeShard(AddressUtils.bech32Decode(address), shardCount);
-      let account = new AccountDetailed({ address, nonce, balance, code, codeHash, rootHash, shard, developerReward, ownerAddress, scamInfo: undefined, nftCollections: undefined, nfts: undefined });
-
-      if (withAssets === true) {
-        const assets = await this.assetsService.getAllAccountAssets();
-        account.assets = assets[address];
-        account.ownerAssets = assets[ownerAddress];
-      }
-
-      if (AddressUtils.isSmartContractAddress(address) && account.code) {
-        const codeAttributes = AddressUtils.decodeCodeMetadata(codeMetadata);
-        if (codeAttributes) {
-          account = { ...account, ...codeAttributes };
-        }
-
-        const deployTxHash = await this.getAccountDeployedTxHash(address);
-        if (deployTxHash) {
-          account.deployTxHash = deployTxHash;
-        }
-
-        const deployedAt = await this.getAccountDeployedAt(address);
-        if (deployedAt) {
-          account.deployedAt = deployedAt;
-        }
-
-        const isVerified = await this.getAccountIsVerified(address, account.codeHash);
-        if (isVerified) {
-          account.isVerified = isVerified;
-        }
-      }
-
-      if (!AddressUtils.isSmartContractAddress(address)) {
-        account.username = await this.usernameService.getUsernameForAddress(address) ?? undefined;
-        account.isPayableBySmartContract = undefined;
-        account.isUpgradeable = undefined;
-        account.isReadable = undefined;
-        account.isPayable = undefined;
-      }
-
-      await this.pluginService.processAccount(account);
-      return account;
-    } catch (error) {
-      this.logger.error(error);
-      this.logger.error(`Error when getting account details for address '${address}'`);
-      return null;
-    }
-  }
-
-  async getAccountTxCount(address: string): Promise<number> {
-    return await this.transferService.getTransfersCount(new TransactionFilter({ address, type: TransactionType.Transaction }));
-  }
-
-  async getAccountScResults(address: string): Promise<number> {
-    return await this.transferService.getTransfersCount(new TransactionFilter({ address, type: TransactionType.SmartContractResult }));
-  }
-
-  async getAccountDeployedAt(address: string): Promise<number | null> {
-    return await this.cachingService.getOrSet(
-      CacheInfo.AccountDeployedAt(address).key,
-      async () => await this.getAccountDeployedAtRaw(address),
-      CacheInfo.AccountDeployedAt(address).ttl
-    );
-  }
-
-  async getAccountDeployedAtRaw(address: string): Promise<number | null> {
-    const scDeploy = await this.indexerService.getScDeploy(address);
-    if (!scDeploy) {
-      return null;
-    }
-
-    const txHash = scDeploy.deployTxHash;
-    if (!txHash) {
-      return null;
-    }
-
-    const transaction = await this.indexerService.getTransaction(txHash);
-    if (!transaction) {
-      return null;
-    }
-
-    return transaction.timestamp;
-  }
-
-  async getAccountDeployedTxHash(address: string): Promise<string | null> {
-    return await this.cachingService.getOrSet(
-      CacheInfo.AccountDeployTxHash(address).key,
-      async () => await this.getAccountDeployedTxHashRaw(address),
-      CacheInfo.AccountDeployTxHash(address).ttl,
-    );
-  }
-
-  async getAccountDeployedTxHashRaw(address: string): Promise<string | null> {
-    const scDeploy = await this.indexerService.getScDeploy(address);
-    if (!scDeploy) {
-      return null;
-    }
-
-    return scDeploy.deployTxHash;
-  }
-
-  async getAccountIsVerified(address: string, codeHash: string): Promise<boolean | null> {
-    return await this.cachingService.getOrSet(
-      CacheInfo.AccountIsVerified(address).key,
-      async () => await this.getAccountIsVerifiedRaw(address, codeHash),
-      CacheInfo.AccountIsVerified(address).ttl
-    );
-  }
-
-  async getAccountIsVerifiedRaw(address: string, codeHash: string): Promise<boolean | null> {
-    try {
-      // eslint-disable-next-line require-await
-      const { data } = await this.apiService.get(`${this.apiConfigService.getVerifierUrl()}/verifier/${address}/codehash`, undefined, async (error) => error.response?.status === HttpStatus.NOT_FOUND);
-
-      if (data.codeHash === Buffer.from(codeHash, 'base64').toString('hex')) {
-        return true;
-      }
-    } catch {
-      // ignore
-    }
-
-    return null;
-  }
 }