@xyo-network/chain-bridge 1.19.17 → 1.20.0

package/src/modules/XL1TransactionCompletionMonitorSentinel/XL1TransactionCompletionMonitorSentinel.ts

@@ -1,165 +0,0 @@
-import type { Attributes, Counter } from '@opentelemetry/api'
-import type { Hash } from '@xylabs/sdk-js'
-import {
-  assertEx, delay, isDefined, isNull, isUndefined,
-} from '@xylabs/sdk-js'
-import type { AnyConfigSchema, Payload } from '@xyo-network/sdk-js'
-import { asSchema, PayloadBuilder } from '@xyo-network/sdk-js'
-import { AbstractSentinel } from '@xyo-network/sentinel-abstract'
-import type {
-  SentinelConfig, SentinelInstance, SentinelModuleEventData, SentinelParams,
-} from '@xyo-network/sentinel-model'
-import type {
-  IterableMap, MapType, SignedHydratedTransaction,
-  XyoViewer,
-} from '@xyo-network/xl1-sdk'
-import {
-  flattenHydratedTransaction, flattenHydratedTransactions, tryUnflattenHydratedTransaction,
-} from '@xyo-network/xl1-sdk'
-import { Mutex } from 'async-mutex'
-
-export const XL1TransactionCompletionMonitorSentinelConfigSchema = asSchema('network.xyo.sentinel.chain.transaction.completion.monitor.config', true)
-export type XL1TransactionCompletionMonitorSentinelConfigSchema = typeof XL1TransactionCompletionMonitorSentinelConfigSchema
-
-/**
- * The configuration for the sentinel
- */
-export type XL1TransactionCompletionMonitorSentinelConfig = SentinelConfig<{
-  /**
-   * The interval in milliseconds between checking for jobs to fulfill
-   */
-  jobCheckInterval: number
-
-  /**
-   * The schema for the sentinel config
-   */
-  schema: XL1TransactionCompletionMonitorSentinelConfigSchema
-}>
-
-interface XL1TransactionCompletionMonitorSentinelParamFields {
-  /**
-   * The map of completed transactions to monitor for completion
-   */
-  completedTransactions: MapType<Hash, SignedHydratedTransaction>
-
-  /**
-   * The map of pending transactions to monitor for completion
-   */
-  pendingTransactions: IterableMap<Hash, SignedHydratedTransaction>
-
-  /**
-   * The viewer instance to use for viewing transactions
-   */
-  viewer: XyoViewer
-}
-
-export type XL1TransactionCompletionMonitorSentinelParams<
-  TConfig extends AnyConfigSchema<XL1TransactionCompletionMonitorSentinelConfig> = AnyConfigSchema<XL1TransactionCompletionMonitorSentinelConfig>,
-> = SentinelParams<TConfig> & XL1TransactionCompletionMonitorSentinelParamFields
-
-const defaultJobCheckIntervalMs = 15_000
-
-export class XL1TransactionCompletionMonitorSentinel<
-  TParams extends XL1TransactionCompletionMonitorSentinelParams = XL1TransactionCompletionMonitorSentinelParams,
-  TEventData extends SentinelModuleEventData<SentinelInstance<TParams>> = SentinelModuleEventData<SentinelInstance<TParams>>,
-> extends AbstractSentinel<TParams, TEventData> {
-  static override readonly configSchemas = [XL1TransactionCompletionMonitorSentinelConfigSchema]
-  static override readonly defaultConfigSchema = XL1TransactionCompletionMonitorSentinelConfigSchema
-  private _attemptsCounter: Counter<Attributes> | undefined
-  private _checkCounter: Counter<Attributes> | undefined
-  private _errorCounter: Counter<Attributes> | undefined
-  private _reportMutex = new Mutex()
-  private _successCounter: Counter<Attributes> | undefined
-
-  protected get completedTransactions(): MapType<Hash, SignedHydratedTransaction> {
-    return assertEx(this.params.completedTransactions, () => 'Completed transactions map is not defined')
-  }
-
-  protected get jobCheckInterval(): number {
-    return isDefined(this.config.jobCheckInterval) ? this.config.jobCheckInterval : defaultJobCheckIntervalMs
-  }
-
-  protected get pendingTransactions(): IterableMap<Hash, SignedHydratedTransaction> {
-    return assertEx(this.params.pendingTransactions, () => 'Pending transactions map is not defined')
-  }
-
-  protected get viewer(): XyoViewer {
-    return assertEx(this.params.viewer, () => 'Viewer is not defined in params')
-  }
-
-  override async createHandler() {
-    await super.createHandler()
-    // Create meters for tracking bridge attempts, successes, and errors.
-    this._attemptsCounter = this.meter?.createCounter('xl1_transaction_completion_monitor_sentinel_attempts_total', { description: 'Number of attempts' })
-    this._checkCounter = this.meter?.createCounter('xl1_transaction_completion_monitor_sentinel_check_total', { description: 'Number of checks' })
-    this._successCounter = this.meter?.createCounter('xl1_transaction_completion_monitor_sentinel_success_total', { description: 'Number of successes' })
-    this._errorCounter = this.meter?.createCounter('xl1_transaction_completion_monitor_sentinel_errors_total', { description: 'Number of errors' })
-  }
-
-  override async reportHandler(payloads?: Payload[]): Promise<Payload[]> {
-    if (isDefined(payloads) && payloads.length > 0) {
-      const signedHydratedTransaction = tryUnflattenHydratedTransaction(payloads)
-      if (isDefined(signedHydratedTransaction)) {
-        // Insert into pending transactions for monitoring
-        const txHash = await PayloadBuilder.hash(signedHydratedTransaction[0])
-        this.logger?.info(`Adding transaction ${signedHydratedTransaction[0]} with hash ${txHash} to pending transactions for monitoring`)
-        await this.pendingTransactions.set(txHash, signedHydratedTransaction)
-        return flattenHydratedTransaction(signedHydratedTransaction)
-      }
-      return []
-    } else {
-      if (this._reportMutex.isLocked()) {
-        this.logger?.debug(`XL1TransactionCompletionMonitorSentinel [${this.id}] is already running, skipping report [${Date.now()}]`)
-        return []
-      }
-      return await this._reportMutex.runExclusive(async () => {
-        const response: Payload[] = []
-        if (isUndefined(payloads) || payloads.length === 0) {
-          await this.processAllTransactions()
-        }
-        return response
-      })
-    }
-  }
-
-  private async processAllTransactions(): Promise<Payload[]> {
-    const results: SignedHydratedTransaction[] = []
-    for await (const [hash, signedHydratedTransaction] of this.pendingTransactions) {
-      const result = await this.processTransaction([hash, signedHydratedTransaction])
-      if (isDefined(result)) results.push(result[1])
-      await delay(this.jobCheckInterval)
-    }
-    return flattenHydratedTransactions(results)
-  }
-
-  private async processTransaction(
-    [hash, signedHydratedTransaction]: [Hash, SignedHydratedTransaction],
-  ): Promise<[Hash, SignedHydratedTransaction] | undefined> {
-    this.logger?.info(`Checking for transaction ${signedHydratedTransaction[0]} with hash ${hash}`)
-    try {
-      let ret: [Hash, SignedHydratedTransaction] | undefined = undefined
-      this._checkCounter?.add(1)
-      this._attemptsCounter?.add(1)
-      // Check if the transaction is already included in the chain
-      const tx = await this.viewer.transactionByHash(hash)
-      if (isDefined(tx) && !isNull(tx)) {
-        await this.completedTransactions.set(hash, signedHydratedTransaction)
-        this.logger?.info(`Found transaction ${signedHydratedTransaction[0]} with hash ${hash}`)
-        this.logger?.info(`Removing completed transaction ${signedHydratedTransaction[0]} with hash ${hash}`)
-        await this.pendingTransactions.delete(hash)
-        ret = [hash, signedHydratedTransaction]
-      } else {
-        const currentBlockNumber = await this.viewer.currentBlockNumber()
-        if (signedHydratedTransaction[0].exp < currentBlockNumber) {
-          this.logger?.info(`Removing expired transaction ${signedHydratedTransaction[0]} with hash ${hash}`)
-          await this.pendingTransactions.delete(hash)
-        }
-      }
-      this._successCounter?.add(1)
-      return ret
-    } catch (error) {
-      this._errorCounter?.add(1)
-      this.logger?.error(`Error checking for transaction ${signedHydratedTransaction[0]} with hash ${hash}:`, error)
-    }
-  }
-}

package/src/modules/XL1TransactionCompletionMonitorSentinel/index.ts

@@ -1 +0,0 @@
-export * from './XL1TransactionCompletionMonitorSentinel.ts'