eco-solver 0.0.1-security → 1.5.0

package/src/balance/balance.ws.service.ts

@@ -0,0 +1,104 @@
+import { Injectable, Logger, OnApplicationBootstrap, OnModuleDestroy } from '@nestjs/common'
+import { EcoConfigService } from '../eco-configs/eco-config.service'
+import { Network } from 'alchemy-sdk'
+import { JobsOptions, Queue } from 'bullmq'
+import { QUEUES } from '../common/redis/constants'
+import { InjectQueue } from '@nestjs/bullmq'
+import { ViemEventLog } from '../common/events/viem'
+import { erc20Abi, Hex, WatchContractEventReturnType, zeroHash } from 'viem'
+import { convertBigIntsToStrings } from '../common/viem/utils'
+import { EcoLogMessage } from '../common/logging/eco-log-message'
+import { getIntentJobId } from '../common/utils/strings'
+import { KernelAccountClientService } from '../transaction/smart-wallets/kernel/kernel-account-client.service'
+import { EcoError } from '@/common/errors/eco-error'
+
+@Injectable()
+export class BalanceWebsocketService implements OnApplicationBootstrap, OnModuleDestroy {
+  private logger = new Logger(BalanceWebsocketService.name)
+  private intentJobConfig: JobsOptions
+  private unwatch: Record<string, WatchContractEventReturnType> = {}
+
+  constructor(
+    @InjectQueue(QUEUES.ETH_SOCKET.queue) private readonly ethQueue: Queue,
+    private readonly kernelAccountClientService: KernelAccountClientService,
+    private readonly ecoConfigService: EcoConfigService,
+  ) {}
+
+  async onApplicationBootstrap() {
+    await this.subscribeWS()
+  }
+
+  async onModuleDestroy() {
+    // close all websockets
+    try {
+      Object.values(this.unwatch).forEach((unwatch) => unwatch())
+    } catch (e) {
+      this.logger.error(
+        EcoLogMessage.withError({
+          message: `watch-event: unsubscribe`,
+          error: EcoError.WatchEventUnsubscribeError,
+          properties: {
+            errorPassed: e,
+          },
+        }),
+      )
+    }
+  }
+
+  async subscribeWS() {
+    this.intentJobConfig = this.ecoConfigService.getRedis().jobs.intentJobConfig
+
+    const websocketTasks = Object.entries(this.ecoConfigService.getSolvers()).map(
+      async ([, solver]) => {
+        const client = await this.kernelAccountClientService.getClient(solver.chainID)
+        // const instanceAddress = this.alchemyService.getWallet(solver.network).address
+
+        Object.entries(solver.targets).forEach(([address, source]) => {
+          // const [address, source] = targetEntity
+          if (source.contractType === 'erc20') {
+            this.unwatch[`${solver.chainID}-${address}`] = client.watchContractEvent({
+              address: address as Hex,
+              abi: erc20Abi,
+              eventName: 'Transfer',
+              // restrict transfers from anyone to the simple account address
+              args: { to: client.kernelAccount.address },
+              onLogs: this.addJob(solver.network, solver.chainID) as any,
+            })
+          }
+        })
+      },
+    )
+    await Promise.all(websocketTasks)
+  }
+
+  addJob(network: Network, chainID: number) {
+    return async (logs: ViemEventLog[]) => {
+      const logTasks = logs.map((transferEvent) => {
+        transferEvent.sourceChainID = BigInt(chainID)
+        //add network to the event
+        transferEvent.sourceNetwork = network
+
+        //bigint as it cant serialize to json
+        transferEvent = convertBigIntsToStrings(transferEvent)
+        this.logger.debug(
+          EcoLogMessage.fromDefault({
+            message: `ws: balance transfer`,
+            properties: {
+              transferEvent: transferEvent,
+            },
+          }),
+        )
+        //add to processing queue
+        return this.ethQueue.add(QUEUES.ETH_SOCKET.jobs.erc20_balance_socket, transferEvent, {
+          jobId: getIntentJobId(
+            'websocket',
+            transferEvent.transactionHash ?? zeroHash,
+            transferEvent.logIndex ?? 0,
+          ),
+          ...this.intentJobConfig,
+        })
+      })
+      await Promise.all(logTasks)
+    }
+  }
+}

package/src/balance/types.ts

@@ -0,0 +1,16 @@
+import { TargetContractType } from '@/eco-configs/eco-config.types'
+import { Hex } from 'viem'
+
+export type TokenConfig = {
+  address: Hex
+  chainId: number
+  minBalance: number
+  targetBalance: number
+  type: TargetContractType
+}
+
+export type TokenBalance = {
+  address: Hex
+  decimals: number
+  balance: bigint
+}

package/src/bullmq/bullmq.helper.ts

@@ -0,0 +1,41 @@
+import { BullModule, RegisterQueueOptions } from '@nestjs/bullmq'
+import { DynamicModule } from '@nestjs/common'
+import { EcoConfigService } from '@/eco-configs/eco-config.service'
+import { RedisConnectionUtils } from '@/common/redis/redis-connection-utils'
+import { QueueMetadata } from '@/common/redis/constants'
+
+/**
+ * Initialize the BullMQ queue with the given token and eco configs
+ * @param {QueueMetadata} queueInterface queue interface
+ * @param {Partial<RegisterQueueOptions>} opts queue options
+ * @returns
+ */
+export function initBullMQ(
+  queueInterface: QueueMetadata,
+  opts?: Partial<RegisterQueueOptions>,
+): DynamicModule {
+  return BullModule.registerQueueAsync({
+    name: queueInterface.queue,
+    useFactory: (configService: EcoConfigService) => {
+      return {
+        ...RedisConnectionUtils.getQueueOptions(queueInterface, configService.getRedis()),
+        ...opts,
+      }
+    },
+    inject: [EcoConfigService],
+  })
+}
+
+/**
+ * Initialize the BullMQ flow with the given name and eco configs
+ * @param {QueueMetadata} queueInterface queue interface
+ * @returns
+ */
+export function initFlowBullMQ(queueInterface: QueueMetadata): DynamicModule {
+  return BullModule.registerFlowProducerAsync({
+    name: queueInterface.queue,
+    useFactory: (configService: EcoConfigService) =>
+      RedisConnectionUtils.getQueueOptions(queueInterface, configService.getRedis()),
+    inject: [EcoConfigService],
+  })
+}

package/src/bullmq/processors/eth-ws.processor.ts

@@ -0,0 +1,47 @@
+import { Processor, WorkerHost } from '@nestjs/bullmq'
+import { QUEUES } from '../../common/redis/constants'
+import { Injectable, Logger } from '@nestjs/common'
+import { Job } from 'bullmq'
+import { EcoLogMessage } from '../../common/logging/eco-log-message'
+import { BalanceService } from '../../balance/balance.service'
+import { ViemEventLog } from '../../common/events/viem'
+
+@Injectable()
+@Processor(QUEUES.ETH_SOCKET.queue)
+export class EthWebsocketProcessor extends WorkerHost {
+  private logger = new Logger(EthWebsocketProcessor.name)
+  constructor(private readonly balanceService: BalanceService) {
+    super()
+  }
+
+  async process(
+    job: Job<any, any, string>,
+    processToken?: string | undefined, // eslint-disable-line @typescript-eslint/no-unused-vars
+  ): Promise<any> {
+    this.logger.debug(
+      EcoLogMessage.fromDefault({
+        message: `EthWebsocketProcessor: process`,
+      }),
+    )
+
+    switch (job.name) {
+      case QUEUES.ETH_SOCKET.jobs.erc20_balance_socket:
+        this.logger.debug(
+          EcoLogMessage.fromDefault({
+            message: `EthWebsocketProcessor: ws event`,
+            properties: {
+              event: job.data,
+            },
+          }),
+        )
+        return this.balanceService.updateBalance(job.data as ViemEventLog)
+      default:
+        this.logger.error(
+          EcoLogMessage.fromDefault({
+            message: `EthWebsocketProcessor: Invalid job type ${job.name}`,
+          }),
+        )
+        return Promise.reject('Invalid job type')
+    }
+  }
+}

package/src/bullmq/processors/inbox.processor.ts

@@ -0,0 +1,55 @@
+import { OnWorkerEvent, Processor, WorkerHost } from '@nestjs/bullmq'
+import { QUEUES } from '@/common/redis/constants'
+import { Injectable, Logger } from '@nestjs/common'
+import { Job } from 'bullmq'
+import { EcoLogMessage } from '@/common/logging/eco-log-message'
+import { UtilsIntentService } from '@/intent/utils-intent.service'
+import { FulfillmentLog } from '@/contracts/inbox'
+
+@Injectable()
+@Processor(QUEUES.INBOX.queue)
+export class InboxProcessor extends WorkerHost {
+  private logger = new Logger(InboxProcessor.name)
+  constructor(private readonly utilsIntentService: UtilsIntentService) {
+    super()
+  }
+
+  async process(
+    job: Job<any, any, string>,
+    processToken?: string | undefined, // eslint-disable-line @typescript-eslint/no-unused-vars
+  ): Promise<any> {
+    this.logger.debug(
+      EcoLogMessage.fromDefault({
+        message: `InboxProcessor: process`,
+        properties: {
+          job: job.name,
+        },
+      }),
+    )
+
+    switch (job.name) {
+      case QUEUES.INBOX.jobs.fulfillment:
+        return await this.utilsIntentService.updateOnFulfillment(job.data as FulfillmentLog)
+      default:
+        this.logger.error(
+          EcoLogMessage.fromDefault({
+            message: `InboxProcessor: Invalid job type ${job.name}`,
+          }),
+        )
+        return Promise.reject('Invalid job type')
+    }
+  }
+
+  @OnWorkerEvent('failed')
+  onJobFailed(job: Job<any, any, string>, error: Error) {
+    this.logger.error(
+      EcoLogMessage.fromDefault({
+        message: `InboxProcessor: Error processing job`,
+        properties: {
+          job,
+          error,
+        },
+      }),
+    )
+  }
+}

package/src/bullmq/processors/interval.processor.ts

@@ -0,0 +1,54 @@
+import { OnWorkerEvent, Processor, WorkerHost } from '@nestjs/bullmq'
+import { QUEUES } from '@/common/redis/constants'
+import { Injectable, Logger } from '@nestjs/common'
+import { Job } from 'bullmq'
+import { EcoLogMessage } from '@/common/logging/eco-log-message'
+import { RetryInfeasableIntentsService } from '@/intervals/retry-infeasable-intents.service'
+
+@Injectable()
+@Processor(QUEUES.INTERVAL.queue)
+export class IntervalProcessor extends WorkerHost {
+  private logger = new Logger(IntervalProcessor.name)
+  constructor(private readonly retryInfeasableIntentsService: RetryInfeasableIntentsService) {
+    super()
+  }
+
+  async process(
+    job: Job<any, any, string>,
+    processToken?: string | undefined, // eslint-disable-line @typescript-eslint/no-unused-vars
+  ): Promise<any> {
+    this.logger.debug(
+      EcoLogMessage.fromDefault({
+        message: `IntervalProcessor: process`,
+        properties: {
+          job: job.name,
+        },
+      }),
+    )
+
+    switch (job.name) {
+      case QUEUES.INTERVAL.jobs.retry_infeasable_intents:
+        return await this.retryInfeasableIntentsService.retryInfeasableIntents()
+      default:
+        this.logger.error(
+          EcoLogMessage.fromDefault({
+            message: `IntervalProcessor: Invalid job type ${job.name}`,
+          }),
+        )
+        return Promise.reject('Invalid job type')
+    }
+  }
+
+  @OnWorkerEvent('failed')
+  onJobFailed(job: Job<any, any, string>, error: Error) {
+    this.logger.error(
+      EcoLogMessage.fromDefault({
+        message: `IntervalProcessor: Error processing job`,
+        properties: {
+          job,
+          error,
+        },
+      }),
+    )
+  }
+}

package/src/bullmq/processors/processor.module.ts

@@ -0,0 +1,14 @@
+import { Module } from '@nestjs/common'
+import { EthWebsocketProcessor } from './eth-ws.processor'
+import { SignerProcessor } from './signer.processor'
+import { SolveIntentProcessor } from './solve-intent.processor'
+import { BalanceModule } from '../../balance/balance.module'
+import { IntentModule } from '../../intent/intent.module'
+import { SignModule } from '../../sign/sign.module'
+import { InboxProcessor } from '@/bullmq/processors/inbox.processor'
+
+@Module({
+  imports: [BalanceModule, IntentModule, SignModule],
+  providers: [EthWebsocketProcessor, SignerProcessor, SolveIntentProcessor, InboxProcessor],
+})
+export class ProcessorModule {}

package/src/bullmq/processors/signer.processor.ts

@@ -0,0 +1,41 @@
+import { Processor, WorkerHost } from '@nestjs/bullmq'
+import { QUEUES } from '../../common/redis/constants'
+import { Injectable, Logger } from '@nestjs/common'
+import { Job } from 'bullmq'
+import { EcoLogMessage } from '../../common/logging/eco-log-message'
+import { NonceService } from '../../sign/nonce.service'
+
+@Injectable()
+@Processor(QUEUES.SIGNER.queue)
+export class SignerProcessor extends WorkerHost {
+  private logger = new Logger(SignerProcessor.name)
+  constructor(private readonly nonceService: NonceService) {
+    super()
+  }
+
+  async process(
+    job: Job<any, any, string>,
+    processToken?: string | undefined, // eslint-disable-line @typescript-eslint/no-unused-vars
+  ): Promise<any> {
+    this.logger.debug(
+      EcoLogMessage.fromDefault({
+        message: `SignerProcessor: process`,
+        properties: {
+          job: job.name,
+        },
+      }),
+    )
+
+    switch (job.name) {
+      case QUEUES.SIGNER.jobs.nonce_sync:
+        return this.nonceService.syncNonces()
+      default:
+        this.logger.error(
+          EcoLogMessage.fromDefault({
+            message: `SignerProcessor: Invalid job type ${job.name}`,
+          }),
+        )
+        return Promise.reject('Invalid job type')
+    }
+  }
+}

package/src/bullmq/processors/solve-intent.processor.ts

@@ -0,0 +1,73 @@
+import { OnWorkerEvent, Processor, WorkerHost } from '@nestjs/bullmq'
+import { QUEUES } from '@/common/redis/constants'
+import { Injectable, Logger } from '@nestjs/common'
+import { Job } from 'bullmq'
+import { EcoLogMessage } from '@/common/logging/eco-log-message'
+import { FeasableIntentService } from '@/intent/feasable-intent.service'
+import { ValidateIntentService } from '@/intent/validate-intent.service'
+import { CreateIntentService } from '@/intent/create-intent.service'
+import { FulfillIntentService } from '@/intent/fulfill-intent.service'
+import { Hex } from 'viem'
+import { IntentCreatedLog } from '@/contracts'
+import { Serialize } from '@/liquidity-manager/utils/serialize'
+
+@Injectable()
+@Processor(QUEUES.SOURCE_INTENT.queue)
+export class SolveIntentProcessor extends WorkerHost {
+  private logger = new Logger(SolveIntentProcessor.name)
+
+  constructor(
+    private readonly createIntentService: CreateIntentService,
+    private readonly validateIntentService: ValidateIntentService,
+    private readonly feasableIntentService: FeasableIntentService,
+    private readonly fulfillIntentService: FulfillIntentService,
+  ) {
+    super()
+  }
+
+  async process(
+    job: Job<any, any, string>,
+    processToken?: string | undefined, // eslint-disable-line @typescript-eslint/no-unused-vars
+  ): Promise<any> {
+    this.logger.debug(
+      EcoLogMessage.fromDefault({
+        message: `SolveIntentProcessor: process`,
+        properties: {
+          job: job.name,
+        },
+      }),
+    )
+
+    switch (job.name) {
+      case QUEUES.SOURCE_INTENT.jobs.create_intent:
+        return await this.createIntentService.createIntent(job.data as Serialize<IntentCreatedLog>)
+      case QUEUES.SOURCE_INTENT.jobs.validate_intent:
+      case QUEUES.SOURCE_INTENT.jobs.retry_intent:
+        return await this.validateIntentService.validateIntent(job.data as Hex)
+      case QUEUES.SOURCE_INTENT.jobs.feasable_intent:
+        return await this.feasableIntentService.feasableIntent(job.data as Hex)
+      case QUEUES.SOURCE_INTENT.jobs.fulfill_intent:
+        return await this.fulfillIntentService.executeFulfillIntent(job.data as Hex)
+      default:
+        this.logger.error(
+          EcoLogMessage.fromDefault({
+            message: `SolveIntentProcessor: Invalid job type ${job.name}`,
+          }),
+        )
+        return Promise.reject('Invalid job type')
+    }
+  }
+
+  @OnWorkerEvent('failed')
+  onJobFailed(job: Job<any, any, string>, error: Error) {
+    this.logger.error(
+      EcoLogMessage.fromDefault({
+        message: `SolveIntentProcessor: Error processing job`,
+        properties: {
+          job,
+          error,
+        },
+      }),
+    )
+  }
+}

package/src/bullmq/processors/tests/solve-intent.processor.spec.ts

@@ -0,0 +1,3 @@
+describe('Solve Intent Processor tests', () => {
+  it('should ', async () => {})
+})

package/src/bullmq/utils/queue.ts

@@ -0,0 +1,22 @@
+import { Queue } from 'bullmq'
+
+export async function removeJobSchedulers(queue: Queue, jobName: string) {
+  const repeatableJobs = await queue.getJobSchedulers()
+
+  for (const job of repeatableJobs) {
+    if (job.name === jobName) {
+      await queue.removeJobScheduler(job.key)
+    }
+  }
+}
+
+/**
+ * Checks to see if there is a scheduled job of a given name in the queue.
+ * @param queue the queue to check
+ * @param jobName the name of the job to check
+ * @returns
+ */
+export async function isJobScheduled(queue: Queue, jobName: string): Promise<boolean> {
+  const repeatableJobs = await queue.getJobSchedulers()
+  return !!repeatableJobs.find((job) => job.name === jobName)
+}

package/src/chain-monitor/chain-monitor.module.ts

@@ -0,0 +1,12 @@
+import { Module } from '@nestjs/common'
+import { IntentModule } from '../intent/intent.module'
+import { ChainSyncService } from './chain-sync.service'
+import { TransactionModule } from '../transaction/transaction.module'
+import { WatchModule } from '@/watch/watch.module'
+
+@Module({
+  imports: [IntentModule, TransactionModule, WatchModule],
+  providers: [ChainSyncService],
+  exports: [ChainSyncService],
+})
+export class ChainMonitorModule {}

package/src/chain-monitor/chain-sync.service.ts

@@ -0,0 +1,134 @@
+import { Injectable, Logger, OnApplicationBootstrap } from '@nestjs/common'
+import { InjectModel } from '@nestjs/mongoose'
+import { Model } from 'mongoose'
+import { IntentSourceModel } from '../intent/schemas/intent-source.schema'
+import { EcoConfigService } from '../eco-configs/eco-config.service'
+import { EcoLogMessage } from '../common/logging/eco-log-message'
+import { IntentSource } from '../eco-configs/eco-config.types'
+import { IntentCreatedLog } from '../contracts'
+import { BlockTag } from 'viem'
+import { WatchCreateIntentService } from '../watch/intent/watch-create-intent.service'
+import { KernelAccountClientService } from '../transaction/smart-wallets/kernel/kernel-account-client.service'
+import { IntentSourceAbi } from '@eco-foundation/routes-ts'
+
+/**
+ * Service class for syncing any missing transactions for all the source intent contracts.
+ * When the module starts up, it will check for any transactions that have occured since the
+ * last recorded transaction in the database and what is on chain. Intended to fill any
+ * gap in transactions that may have been missed while the serivce was down.
+ */
+@Injectable()
+export class ChainSyncService implements OnApplicationBootstrap {
+  private logger = new Logger(ChainSyncService.name)
+
+  constructor(
+    @InjectModel(IntentSourceModel.name) private intentModel: Model<IntentSourceModel>,
+    private readonly kernelAccountClientService: KernelAccountClientService,
+    private readonly watchIntentService: WatchCreateIntentService,
+    private ecoConfigService: EcoConfigService,
+  ) {}
+
+  async onApplicationBootstrap() {
+    this.logger.debug(
+      EcoLogMessage.fromDefault({
+        message: `ChainSyncService:OnApplicationBootstrap`,
+      }),
+    )
+    await this.syncTxs()
+  }
+
+  /**
+   * Syncs all the missing transactions for all the source intent contracts.
+   */
+  async syncTxs() {
+    const missingTxsTasks = this.ecoConfigService.getIntentSources().map((source) => {
+      return this.syncTxsPerSource(source)
+    })
+
+    await Promise.all(missingTxsTasks)
+  }
+
+  /**
+   * Returns the missing transactions for a source intent contract
+   *
+   * @param source the source intent to get the missing transactions for
+   * @returns
+   */
+  async syncTxsPerSource(source: IntentSource) {
+    const createIntentLogs = await this.getMissingTxs(source)
+    if (createIntentLogs.length === 0) {
+      return
+    }
+
+    return this.watchIntentService.addJob(source)(createIntentLogs)
+  }
+
+  /**
+   * Gets the missing transactions for a source intent contract by checking the last processed
+   * event in the database and querying the chain for events from that block number.
+   *
+   * TODO: need to add pagination for large amounts of missing transactions with subgraphs at 10k events
+   * @param source the source intent to get missing transactions for
+   * @returns
+   */
+  async getMissingTxs(source: IntentSource): Promise<IntentCreatedLog[]> {
+    const client = await this.kernelAccountClientService.getClient(source.chainID)
+
+    const lastRecordedTx = await this.getLastRecordedTx(source)
+    const fromBlock: bigint =
+      lastRecordedTx.length > 0
+        ? BigInt(lastRecordedTx[0].event.blockNumber) + 1n //start search from next block
+        : 0n
+    const toBlock: BlockTag = 'latest'
+    const supportedChains = this.ecoConfigService.getSupportedChains()
+    const createIntentLogs = (
+      await client.getContractEvents({
+        address: source.sourceAddress,
+        abi: IntentSourceAbi,
+        eventName: 'IntentCreated',
+        args: {
+          prover: source.provers,
+        },
+        fromBlock,
+        toBlock,
+      })
+    ).filter((log) => supportedChains.includes(log.args.destination || 0n))
+
+    //todo clean out already fulfilled intents
+    if (createIntentLogs.length === 0) {
+      this.logger.log(
+        EcoLogMessage.fromDefault({
+          message: `No transactions found for source ${source.network} to sync from block ${fromBlock}`,
+          properties: {
+            chainID: source.chainID,
+            fromBlock,
+          },
+        }),
+      )
+      return []
+    }
+
+    // add the required source network and chain id to the logs
+    return createIntentLogs.map((log) => {
+      return {
+        ...log,
+        sourceNetwork: source.network,
+        sourceChainID: source.chainID,
+      } as unknown as IntentCreatedLog
+    })
+  }
+
+  /**
+   * Returns the last recorded transaction for a source intent contract.
+   *
+   * @param source the source intent to get the last recorded transaction for
+   * @returns
+   */
+  async getLastRecordedTx(source: IntentSource): Promise<IntentSourceModel[]> {
+    return await this.intentModel
+      .find({ 'event.sourceChainID': source.chainID })
+      .sort({ 'event.blockNumber': -1 })
+      .limit(1)
+      .exec()
+  }
+}