fix: incosistent initialisation of accounts on evm

Author: filo87

src/@types/gobal.d.ts

@@ -1,3 +1,4 @@
+/* eslint-disable no-var */
 import { ApiPromise } from '@polkadot/api'
 import type { Provider } from '@ethersproject/providers'
 import { ApiDecoration } from '@polkadot/api/types'
@@ -11,5 +12,7 @@ declare global {
   const api: ApiAt & Provider
   const unsafeApi: ApiPromise | undefined
   function getNodeEvmChainId(): Promise<string | undefined>
+  var isSubstrateNode: boolean
+  var isEvmNode: boolean
 }
 export {}

src/index.ts

@@ -8,6 +8,8 @@ const isSubstrateNode = 'query' in api
 const isEvmNode = typeof (api as Provider).getNetwork === 'function'
 const ethNetworkProm = isEvmNode ? (api as Provider).getNetwork() : null
 
+global.isSubstrateNode = isSubstrateNode
+global.isEvmNode = isEvmNode
 global.fetch = fetch as unknown as typeof global.fetch
 global.atob = atob as typeof global.atob
 global.getNodeEvmChainId = async function () {

src/mappings/handlers/evmHandlers.ts

@@ -7,13 +7,12 @@ import { PoolService } from '../services/poolService'
 import { TrancheService } from '../services/trancheService'
 import { InvestorTransactionData, InvestorTransactionService } from '../services/investorTransactionService'
 import { CurrencyService } from '../services/currencyService'
-import { BlockchainService } from '../services/blockchainService'
+import { BlockchainService, LOCAL_CHAIN_ID } from '../services/blockchainService'
 import { CurrencyBalanceService } from '../services/currencyBalanceService'
 import { TrancheBalanceService } from '../services/trancheBalanceService'
 import { escrows } from '../../config'
 import { InvestorPositionService } from '../services/investorPositionService'
 import { getPeriodStart } from '../../helpers/timekeeperService'
-//const networkPromise = typeof ethApi.getNetwork === 'function' ? ethApi.getNetwork() : null
 
 export const handleEvmDeployTranche = errorHandler(_handleEvmDeployTranche)
 async function _handleEvmDeployTranche(event: DeployTrancheLog): Promise<void> {
@@ -23,6 +22,7 @@ async function _handleEvmDeployTranche(event: DeployTrancheLog): Promise<void> {
 
   const chainId = await getNodeEvmChainId()
   if (!chainId) throw new Error('Unable to retrieve chainId')
+  await BlockchainService.getOrInit(LOCAL_CHAIN_ID)
   const evmBlockchain = await BlockchainService.getOrInit(chainId)
 
   const poolId = _poolId.toString()
@@ -73,12 +73,14 @@ async function _handleEvmTransfer(event: TransferLog): Promise<void> {
   const _isFromUserEscrow = fromEvmAddress === userEscrowAddress
 
   if (!evmToken.poolId || !evmToken.trancheId) throw new Error('This is not a tranche token')
+  const pool = await PoolService.getById(evmToken.poolId)
+  if (!pool) throw new Error('Pool not found!')
   const trancheId = evmToken.trancheId.split('-')[1]
-  const tranche = await TrancheService.getById(evmToken.poolId, trancheId)
+  const tranche = await TrancheService.getById(pool.id, trancheId)
   if (!tranche) throw new Error('Tranche not found!')
 
   const orderData: Omit<InvestorTransactionData, 'address'> = {
-    poolId: evmToken.poolId,
+    poolId: pool.id,
     trancheId: trancheId,
     hash: event.transactionHash,
     timestamp: timestamp,

src/mappings/services/accountService.ts

@@ -5,19 +5,20 @@ const EVM_SUFFIX = '45564d00'
 
 export class AccountService extends Account {
   static async init(address: string) {
-    logger.info(`Initialising new account: ${address}`)
     if (await this.isForeignEvm(address)) {
       const chainId = this.readEvmChainId(address)
+      logger.info(`Initialising new account: ${address} as foreign for chainId: ${chainId}`)
       const account = new this(address, chainId)
       account.evmAddress = address.substring(0, 42)
       return account
     } else {
+      logger.info(`Initialising new account: ${address}`)
       return new this(address, LOCAL_CHAIN_ID)
     }
   }
 
   static async getOrInit(address: string, blockchainService = BlockchainService): Promise<AccountService> {
-    let account = (await this.get(address))
+    let account = await this.get(address)
     if (!account) {
       account = await this.init(address)
       await blockchainService.getOrInit(account.chainId)
@@ -27,7 +28,7 @@ export class AccountService extends Account {
   }
 
   static evmToSubstrate(evmAddress: string, chainId: string) {
-    const chainHex = parseInt(chainId,10).toString(16).padStart(4, '0')
+    const chainHex = parseInt(chainId, 10).toString(16).padStart(4, '0')
     return `0x${evmAddress.substring(2).toLowerCase()}000000000000${chainHex}${EVM_SUFFIX}`
   }
 
@@ -40,8 +41,12 @@ export class AccountService extends Account {
   }
 
   static async isForeignEvm(address: string) {
-    const nodeEvmChainId = await getNodeEvmChainId()
-    return this.isEvm(address) && this.readEvmChainId(address) !== nodeEvmChainId
+    if (isSubstrateNode) {
+      const nodeEvmChainId = await getNodeEvmChainId()
+      return this.isEvm(address) && this.readEvmChainId(address) !== nodeEvmChainId
+    } else {
+      return this.isEvm(address)
+    }
   }
 
   public isForeignEvm() {