refactor getConfiguration

Author: alexcos20

src/OceanNode.ts

@@ -1,7 +1,13 @@
 import { OceanP2P } from './components/P2P/index.js'
 import { OceanProvider } from './components/Provider/index.js'
 import { OceanIndexer } from './components/Indexer/index.js'
-import { OceanNodeConfig, P2PCommandResponse } from './@types/OceanNode.js'
+import {
+  AccessListContract,
+  OceanNodeConfig,
+  P2PCommandResponse
+} from './@types/OceanNode.js'
+import { ValidateChainId } from './@types/commands.js'
+
 import { Database } from './components/database/index.js'
 import { Escrow } from './components/core/utils/escrow.js'
 import { CoreHandlersRegistry } from './components/core/handler/coreHandlersRegistry.js'
@@ -15,6 +21,8 @@ import { BlockchainRegistry } from './components/BlockchainRegistry/index.js'
 import { Blockchain } from './utils/blockchain.js'
 import { createPersistentStorage } from './components/persistentStorage/createPersistentStorage.js'
 import { PersistentStorageFactory } from './components/persistentStorage/PersistentStorageFactory.js'
+import { isAddress, FallbackProvider, ethers } from 'ethers'
+import { create256Hash } from './utils/crypt.js'
 
 export interface RequestLimiter {
   requester: string | string[] // IP address or peer ID
@@ -40,6 +48,7 @@ export class OceanNode {
   private requestMap: Map<string, RequestLimiter>
   private auth: Auth
   private persistentStorage: PersistentStorageFactory
+  private database: Database
 
   // eslint-disable-next-line no-useless-constructor
   private constructor(
@@ -64,8 +73,9 @@ export class OceanNode {
     this.coreHandlers = CoreHandlersRegistry.getInstance(this)
     this.requestMap = new Map<string, RequestLimiter>()
     this.config = config
+    this.database = db
     if (this.db && this.db?.authToken) {
-      this.auth = new Auth(this.db.authToken)
+      this.auth = new Auth(this.db.authToken, config)
     }
     if (node) {
       node.setCoreHandlers(this.coreHandlers)
@@ -161,10 +171,6 @@ export class OceanNode {
     return this.indexer
   }
 
-  public getDatabase(): Database {
-    return this.db
-  }
-
   public getC2DEngines(): C2DEngines {
     return this.c2dEngines
   }
@@ -259,4 +265,81 @@ export class OceanNode {
       }
     }
   }
+
+  getAdminAddresses(): { addresses: string[]; accessLists: any } {
+    const ret = {
+      addresses: [] as string[],
+      accessLists: undefined as AccessListContract | undefined
+    }
+
+    if (this.config.allowedAdmins && this.config.allowedAdmins.length > 0) {
+      for (const admin of this.config.allowedAdmins) {
+        if (isAddress(admin) === true) {
+          ret.addresses.push(admin)
+        }
+      }
+    }
+    ret.accessLists = this.config.allowedAdminsList
+    return ret
+  }
+
+  checkSupportedChainId(chainId: number): ValidateChainId {
+    if (!chainId || !(`${chainId.toString()}` in this.config.supportedNetworks)) {
+      OCEAN_NODE_LOGGER.error(`Chain ID ${chainId} is not supported`)
+      return {
+        validation: false,
+        networkRpc: ''
+      }
+    }
+    return {
+      validation: true,
+      networkRpc: this.config.supportedNetworks[chainId.toString()].rpc
+    }
+  }
+
+  async getJsonRpcProvider(chainId: number): Promise<FallbackProvider> {
+    const checkResult = this.checkSupportedChainId(chainId)
+    if (!checkResult.validation) {
+      return null
+    }
+    const blockchain = this.getBlockchain(chainId)
+    if (!blockchain) return null
+    return await blockchain.getProvider()
+  }
+
+  hasP2PInterface() {
+    return this.config.hasP2P || false
+  }
+
+  async getDatabase(forceReload: boolean = false): Promise<Database> {
+    if (!this.database || forceReload) {
+      const { dbConfig } = this.config
+      if (dbConfig && dbConfig.url) {
+        this.database = await Database.init(dbConfig)
+      }
+    }
+    return this.database
+  }
+
+  async getValidationSignature(ddo: string): Promise<any> {
+    try {
+      const hashedDDO = create256Hash(ddo)
+      const providerWallet = await this.keyManager.getEthWallet()
+      const messageHash = ethers.solidityPackedKeccak256(
+        ['bytes'],
+        [ethers.hexlify(ethers.toUtf8Bytes(hashedDDO))]
+      )
+      const signed32Bytes = await providerWallet.signMessage(
+        new Uint8Array(ethers.toBeArray(messageHash))
+      )
+      const signatureSplitted = ethers.Signature.from(signed32Bytes)
+      const v = signatureSplitted.v <= 1 ? signatureSplitted.v + 27 : signatureSplitted.v
+      const r = ethers.hexlify(signatureSplitted.r) // 32 bytes
+      const s = ethers.hexlify(signatureSplitted.s)
+      return { hash: hashedDDO, publicKey: providerWallet.address, r, s, v }
+    } catch (error) {
+      OCEAN_NODE_LOGGER.logMessage(`Validation signature error: ${error}`, true)
+      return { hash: '', publicKey: '', r: '', s: '', v: '' }
+    }
+  }
 }

src/components/Auth/index.ts

@@ -2,9 +2,8 @@ import { AuthToken, AuthTokenDatabase } from '../database/AuthTokenDatabase.js'
 import jwt from 'jsonwebtoken'
 import { checkNonce, NonceResponse } from '../core/utils/nonceHandler.js'
 import { OceanNode } from '../../OceanNode.js'
-import { getConfiguration } from '../../utils/index.js'
 import { CommonValidation } from '../../utils/validators.js'
-
+import { OceanNodeConfig } from '../../@types/OceanNode.js'
 export interface AuthValidation {
   token?: string
   address?: string
@@ -16,24 +15,26 @@ export interface AuthValidation {
 
 export class Auth {
   private authTokenDatabase: AuthTokenDatabase
+  private jwtSecret: string
 
-  public constructor(authTokenDatabase: AuthTokenDatabase) {
+  public constructor(authTokenDatabase: AuthTokenDatabase, config: OceanNodeConfig) {
     this.authTokenDatabase = authTokenDatabase
+    this.jwtSecret = config.jwtSecret
   }
 
-  public async getJwtSecret(): Promise<string> {
-    const config = await getConfiguration()
-    return config.jwtSecret
+  public getJwtSecret(): string {
+    return this.jwtSecret
   }
 
+  // eslint-disable-next-line require-await
   async getJWTToken(address: string, nonce: string, createdAt: number): Promise<string> {
     const jwtToken = jwt.sign(
       {
         address,
         nonce,
         createdAt
       },
-      await this.getJwtSecret()
+      this.getJwtSecret()
     )
 
     return jwtToken
@@ -84,7 +85,8 @@ export class Auth {
       if (signature && address && nonce) {
         const oceanNode = OceanNode.getInstance()
         const nonceCheckResult: NonceResponse = await checkNonce(
-          oceanNode.getDatabase().nonce,
+          oceanNode.getConfig(),
+          (await oceanNode.getDatabase()).nonce,
           address,
           parseInt(nonce),
           signature,

src/components/Indexer/ChainIndexer.ts

@@ -5,7 +5,6 @@ import { LOG_LEVELS_STR } from '../../utils/logging/Logger.js'
 import { isDefined, sleep } from '../../utils/util.js'
 import { EVENTS, INDEXER_CRAWLING_EVENTS } from '../../utils/index.js'
 import { INDEXER_LOGGER } from '../../utils/logging/common.js'
-import { getDatabase } from '../../utils/database.js'
 import { DEVELOPMENT_CHAIN_ID } from '../../utils/address.js'
 import { processBlocks, processChunkLogs } from './processor.js'
 import { Blockchain } from '../../utils/blockchain.js'
@@ -16,6 +15,7 @@ import {
   retrieveChunkEvents
 } from './utils.js'
 import { OceanNodeConfig } from '../../@types/OceanNode.js'
+import { Database } from '../database/index.js'
 
 export interface ReindexTask {
   txId: string
@@ -36,15 +36,18 @@ export class ChainIndexer {
   private reindexQueue: ReindexTask[] = []
   private eventEmitter: EventEmitter
   private blockchain: Blockchain
+  private db: Database
 
   constructor(
     blockchain: Blockchain,
     rpcDetails: SupportedNetwork,
-    eventEmitter: EventEmitter
+    eventEmitter: EventEmitter,
+    database: Database
   ) {
     this.blockchain = blockchain
     this.eventEmitter = eventEmitter
     this.rpcDetails = rpcDetails
+    this.db = database
   }
 
   /**
@@ -237,7 +240,8 @@ export class ChainIndexer {
                 provider,
                 this.blockchain.getSupportedChain(),
                 startBlock,
-                blocksToProcess
+                blocksToProcess,
+                this.config
               )
 
               INDEXER_LOGGER.debug(
@@ -320,7 +324,7 @@ export class ChainIndexer {
    * Get the last indexed block from database
    */
   private async getLastIndexedBlock(): Promise<number | null> {
-    const { indexer } = await getDatabase()
+    const { indexer } = this.db
     try {
       const networkDetails = await indexer.retrieve(this.blockchain.getSupportedChain())
       if (networkDetails && networkDetails.lastIndexedBlock) {
@@ -352,7 +356,7 @@ export class ChainIndexer {
         return -1
       }
 
-      const { indexer } = await getDatabase()
+      const { indexer } = this.db
       const updatedIndex = await indexer.update(
         this.blockchain.getSupportedChain(),
         block
@@ -383,7 +387,7 @@ export class ChainIndexer {
    * Delete all assets from this chain
    */
   private async deleteAllAssetsFromChain(): Promise<number> {
-    const { ddo } = await getDatabase()
+    const { ddo } = this.db
     try {
       const numDeleted = await ddo.deleteAllAssetsFromChain(
         this.blockchain.getSupportedChain()
@@ -449,7 +453,8 @@ export class ChainIndexer {
             logs,
             signer,
             provider,
-            this.blockchain.getSupportedChain()
+            this.blockchain.getSupportedChain(),
+            this.config
           )
 
           // Emit event to clear from parent queue

src/components/Indexer/index.ts

@@ -35,7 +35,7 @@ import { BlockchainRegistry } from '../BlockchainRegistry/index.js'
 import { CommandStatus, JobStatus } from '../../@types/commands.js'
 import { buildJobIdentifier, getDeployedContractBlock } from './utils.js'
 import { create256Hash } from '../../utils/crypt.js'
-import { getDatabase, isReachableConnection } from '../../utils/database.js'
+import { isReachableConnection } from '../../utils/database.js'
 import { sleep } from '../../utils/util.js'
 import { isReindexingNeeded } from './version.js'
 import { getPackageVersion } from '../../utils/version.js'
@@ -145,10 +145,10 @@ export class OceanIndexer {
         INDEXER_LOGGER.info(
           'Database connection stable - reinitialising DB and restarting all chain indexers'
         )
-        const freshDb = await getDatabase(true)
-        if (freshDb) {
-          this.db = freshDb
-        }
+        // const freshDb = await getDatabase(true)
+        // if (freshDb) {
+        // this.db = freshDb
+        // }
 
         await this.startAllChainIndexers()
       }, 5000)
@@ -292,7 +292,8 @@ export class OceanIndexer {
     const indexer = new ChainIndexer(
       blockchain,
       rpcDetails,
-      INDEXER_CRAWLING_EVENT_EMITTER
+      INDEXER_CRAWLING_EVENT_EMITTER,
+      this.db
     )
 
     INDEXER_LOGGER.log(

src/components/Indexer/processor.ts

@@ -1,7 +1,6 @@
 import { ethers, Signer, FallbackProvider, Interface, getAddress } from 'ethers'
 import { BlocksEvents, ProcessingEvents } from '../../@types/blockchain.js'
 import { EVENTS } from '../../utils/constants.js'
-import { getConfiguration } from '../../utils/config.js'
 import { INDEXER_LOGGER } from '../../utils/logging/common.js'
 import { LOG_LEVELS_STR } from '../../utils/logging/Logger.js'
 import { fetchEventFromTransaction } from '../../utils/util.js'
@@ -23,6 +22,7 @@ import {
 import { findEventByKey } from './utils.js'
 import ERC20Template from '@oceanprotocol/contracts/artifacts/contracts/templates/ERC20TemplateEnterprise.sol/ERC20TemplateEnterprise.json' with { type: 'json' }
 import AccessListContract from '@oceanprotocol/contracts/artifacts/contracts/accesslists/AccessList.sol/AccessList.json' with { type: 'json' }
+import { OceanNodeConfig } from '../../@types/OceanNode.js'
 
 const EVENT_PROCESSOR_MAP: Record<string, ProcessorConstructor> = {
   [EVENTS.METADATA_CREATED]: MetadataEventProcessor,
@@ -41,15 +41,19 @@ const EVENT_PROCESSOR_MAP: Record<string, ProcessorConstructor> = {
 
 const processorInstances = new Map<string, BaseEventProcessor>()
 
-function getEventProcessor(eventType: string, chainId: number): BaseEventProcessor {
+function getEventProcessor(
+  eventType: string,
+  chainId: number,
+  config: OceanNodeConfig
+): BaseEventProcessor {
   const cacheKey = `${eventType}-${chainId}`
 
   if (!processorInstances.has(cacheKey)) {
     const ProcessorClass = EVENT_PROCESSOR_MAP[eventType]
     if (!ProcessorClass) {
       throw new Error(`No processor found for event type: ${eventType}`)
     }
-    processorInstances.set(cacheKey, new ProcessorClass(chainId))
+    processorInstances.set(cacheKey, new ProcessorClass(chainId, config))
   }
 
   return processorInstances.get(cacheKey)
@@ -59,11 +63,12 @@ export const processChunkLogs = async (
   logs: readonly ethers.Log[],
   signer: Signer,
   provider: FallbackProvider,
-  chainId: number
+  chainId: number,
+  config: OceanNodeConfig
 ): Promise<BlocksEvents> => {
   const storeEvents: BlocksEvents = {}
   if (logs.length > 0) {
-    const { allowedValidators, allowedValidatorsList } = await getConfiguration() //  getAllowedValidators()
+    const { allowedValidators, allowedValidatorsList } = config //  getAllowedValidators()
     const checkMetadataValidated =
       allowedValidators.length > 0 ||
       (allowedValidatorsList && Object.keys(allowedValidatorsList).length > 0)
@@ -164,7 +169,7 @@ export const processChunkLogs = async (
         if (event.type === EVENTS.TOKEN_URI_UPDATE) {
           storeEvents[event.type] = 'TOKEN_URI_UPDATE'
         } else {
-          const processor = getEventProcessor(event.type, chainId)
+          const processor = getEventProcessor(event.type, chainId, config)
           storeEvents[event.type] = await processor.processEvent(
             log,
             chainId,
@@ -188,12 +193,13 @@ export const processBlocks = async (
   provider: FallbackProvider,
   network: number,
   lastIndexedBlock: number,
-  count: number
+  count: number,
+  config: OceanNodeConfig
 ): Promise<ProcessingEvents> => {
   try {
     const events: any[] | BlocksEvents =
       blockLogs && blockLogs.length > 0
-        ? await processChunkLogs(blockLogs, signer, provider, network)
+        ? await processChunkLogs(blockLogs, signer, provider, network, config)
         : []
 
     return {