@sentio/runtime 2.39.7-rc.9 → 2.40.0-rc.10

package/src/plugin.ts

@@ -1,4 +1,12 @@
-import { DataBinding, HandlerType, ProcessConfigResponse, ProcessResult, StartRequest } from '@sentio/protos'
+import {
+  DataBinding,
+  HandlerType,
+  PreparedData,
+  PreprocessResult,
+  ProcessConfigResponse,
+  ProcessResult,
+  StartRequest
+} from '@sentio/protos'
 import { StoreContext } from './db-context.js'
 import { AsyncLocalStorage } from 'node:async_hooks'
 
@@ -16,9 +24,13 @@ export abstract class Plugin {
     return false
   }
 
-  async processBinding(request: DataBinding): Promise<ProcessResult> {
+  async processBinding(request: DataBinding, preparedData: PreparedData | undefined): Promise<ProcessResult> {
     return ProcessResult.create()
   }
+
+  async preprocessBinding(request: DataBinding): Promise<PreprocessResult> {
+    return PreprocessResult.create()
+  }
 }
 
 export class PluginManager {
@@ -58,13 +70,27 @@ export class PluginManager {
     return this.plugins.some((plugin) => plugin.stateDiff(config))
   }
 
-  processBinding(request: DataBinding, dbContext?: StoreContext): Promise<ProcessResult> {
+  processBinding(
+    request: DataBinding,
+    preparedData: PreparedData | undefined,
+    dbContext?: StoreContext
+  ): Promise<ProcessResult> {
+    const plugin = this.typesToPlugin.get(request.handlerType)
+    if (!plugin) {
+      throw new Error(`No plugin for ${request.handlerType}`)
+    }
+    return this.dbContextLocalStorage.run(dbContext, () => {
+      return plugin.processBinding(request, preparedData)
+    })
+  }
+
+  preprocessBinding(request: DataBinding, dbContext?: StoreContext): Promise<PreprocessResult> {
     const plugin = this.typesToPlugin.get(request.handlerType)
     if (!plugin) {
       throw new Error(`No plugin for ${request.handlerType}`)
     }
     return this.dbContextLocalStorage.run(dbContext, () => {
-      return plugin.processBinding(request)
+      return plugin.preprocessBinding(request)
     })
   }
 }

package/src/processor-runner.ts

@@ -8,6 +8,7 @@ import commandLineArgs from 'command-line-args'
 import { createServer } from 'nice-grpc'
 import { errorDetailsServerMiddleware } from 'nice-grpc-error-details'
 import { registry as niceGrpcRegistry, prometheusServerMiddleware } from 'nice-grpc-prometheus'
+import { openTelemetryServerMiddleware } from 'nice-grpc-opentelemetry'
 import { register as globalRegistry, Registry } from 'prom-client'
 import http from 'http'
 // @ts-ignore inspector promises is not included in @type/node
@@ -20,6 +21,21 @@ import { FullProcessorServiceImpl } from './full-service.js'
 import { ChainConfig } from './chain-config.js'
 import { setupLogger } from './logger.js'
 
+import { NodeSDK } from '@opentelemetry/sdk-node'
+import { OTLPMetricExporter } from '@opentelemetry/exporter-metrics-otlp-grpc'
+import { OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-grpc'
+import { PeriodicExportingMetricReader } from '@opentelemetry/sdk-metrics'
+
+const sdk = new NodeSDK({
+  traceExporter: new OTLPTraceExporter(),
+  metricReader: new PeriodicExportingMetricReader({
+    exporter: new OTLPMetricExporter()
+  })
+  // instrumentations: [getNodeAutoInstrumentations()],
+})
+
+sdk.start()
+
 const mergedRegistry = Registry.merge([globalRegistry, niceGrpcRegistry])
 
 const optionDefinitions = [
@@ -50,8 +66,15 @@ Error.stackTraceLimit = 20
 const fullPath = path.resolve(options['chains-config'])
 const chainsConfig = fs.readJsonSync(fullPath)
 
-Endpoints.INSTANCE.concurrency = options.concurrency
-Endpoints.INSTANCE.batchCount = options['batch-count']
+const concurrencyOverride = process.env['OVERRIDE_CONCURRENCY']
+  ? parseInt(process.env['OVERRIDE_CONCURRENCY'])
+  : undefined
+const batchCountOverride = process.env['OVERRIDE_BATCH_COUNT']
+  ? parseInt(process.env['OVERRIDE_BATCH_COUNT'])
+  : undefined
+
+Endpoints.INSTANCE.concurrency = concurrencyOverride ?? options.concurrency
+Endpoints.INSTANCE.batchCount = batchCountOverride ?? options['batch-count']
 Endpoints.INSTANCE.chainQueryAPI = options['chainquery-server']
 Endpoints.INSTANCE.priceFeedAPI = options['pricefeed-server']
 
@@ -77,6 +100,7 @@ const server = createServer({
   'grpc.default_compression_algorithm': compressionAlgorithms.gzip
 })
   .use(prometheusServerMiddleware())
+  .use(openTelemetryServerMiddleware())
   .use(errorDetailsServerMiddleware)
 const baseService = new ProcessorServiceImpl(async () => {
   const m = await import(options.target)

package/src/provider.ts

@@ -0,0 +1,168 @@
+import { JsonRpcProvider, Network, Provider } from 'ethers'
+
+import PQueue from 'p-queue'
+import { Endpoints } from './endpoints.js'
+import { EthChainId } from '@sentio/chain'
+import { LRUCache } from 'lru-cache'
+import { metrics } from '@opentelemetry/api'
+
+export const DummyProvider = new JsonRpcProvider('', Network.from(1))
+
+const meter = metrics.getMeter('processor_provider')
+const hit_count = meter.createCounter('provider_hit_count')
+const miss_count = meter.createCounter('provider_miss_count')
+const queue_size = meter.createGauge('provider_queue_size')
+const total_duration = meter.createCounter('provider_total_duration')
+const total_queued = meter.createCounter('provider_total_queued')
+
+const providers = new Map<string, JsonRpcProvider>()
+
+// export function getEthChainId(networkish?: EthContext | EthChainId): EthChainId {
+//   if (!networkish) {
+//     networkish = EthChainId.ETHEREUM
+//   }
+//   if (networkish instanceof BaseContext) {
+//     networkish = networkish.getChainId()
+//   }
+//   return networkish
+// }
+
+export function getProvider(chainId?: EthChainId): Provider {
+  // const network = getNetworkFromCtxOrNetworkish(networkish)
+  if (!chainId) {
+    chainId = EthChainId.ETHEREUM
+  }
+  const network = Network.from(parseInt(chainId))
+  // TODO check if other key needed
+
+  const address = Endpoints.INSTANCE.chainServer.get(chainId)
+  const key = network.chainId.toString() + '-' + address
+
+  console.debug(`init provider for ${chainId}, address: ${address}`)
+  let provider = providers.get(key)
+
+  if (provider) {
+    return provider
+  }
+
+  if (address === undefined) {
+    throw Error(
+      'Provider not found for chain ' +
+        network.chainId +
+        ', configured chains: ' +
+        [...Endpoints.INSTANCE.chainServer.keys()].join(' ')
+    )
+  }
+  console.log(
+    `init provider for chain ${network.chainId}, concurrency: ${Endpoints.INSTANCE.concurrency}, batchCount: ${Endpoints.INSTANCE.batchCount}`
+  )
+  provider = new QueuedStaticJsonRpcProvider(
+    address,
+    network,
+    Endpoints.INSTANCE.concurrency,
+    Endpoints.INSTANCE.batchCount
+  )
+  providers.set(key, provider)
+  return provider
+}
+
+function getTag(prefix: string, value: any): string {
+  return (
+    prefix +
+    ':' +
+    JSON.stringify(value, (k, v) => {
+      if (v == null) {
+        return 'null'
+      }
+      if (typeof v === 'bigint') {
+        return `bigint:${v.toString()}`
+      }
+      if (typeof v === 'string') {
+        return v.toLowerCase()
+      }
+
+      // Sort object keys
+      if (typeof v === 'object' && !Array.isArray(v)) {
+        const keys = Object.keys(v)
+        keys.sort()
+        return keys.reduce(
+          (accum, key) => {
+            accum[key] = v[key]
+            return accum
+          },
+          <any>{}
+        )
+      }
+
+      return v
+    })
+  )
+}
+
+class QueuedStaticJsonRpcProvider extends JsonRpcProvider {
+  executor: PQueue
+  #performCache = new LRUCache<string, Promise<any>>({
+    max: 300000 // 300k items
+    // maxSize: 300 * 1024 * 1024, // 300mb for cache
+    // ttl: 1000 * 60 * 60, // 1 hour   no ttl for better performance
+    // sizeCalculation: (value: any) => {
+    // assume each item is 1kb for simplicity
+    // return 1024
+    // }
+  })
+
+  constructor(url: string, network: Network, concurrency: number, batchCount = 1) {
+    // TODO re-enable match when possible
+    super(url, network, { staticNetwork: network, batchMaxCount: batchCount })
+    this.executor = new PQueue({ concurrency: concurrency })
+  }
+
+  async send(method: string, params: Array<any>): Promise<any> {
+    if (method !== 'eth_call') {
+      return await this.executor.add(() => super.send(method, params))
+    }
+    const tag = getTag(method, params)
+    const block = params[params.length - 1]
+    let perform = this.#performCache.get(tag)
+    if (!perform) {
+      miss_count.add(1)
+      const queued: number = Date.now()
+      perform = this.executor.add(() => {
+        const started = Date.now()
+        total_queued.add(started - queued)
+
+        return super.send(method, params).finally(() => {
+          total_duration.add(Date.now() - started)
+        })
+      })
+      perform.catch((e) => {
+        // if (e.code !== 'CALL_EXCEPTION' && e.code !== 'BAD_DATA') {
+        setTimeout(() => {
+          if (this.#performCache.get(tag) === perform) {
+            this.#performCache.delete(tag)
+          }
+        }, 1000)
+      })
+
+      queue_size.record(this.executor.size)
+
+      this.#performCache.set(tag, perform)
+      // For non latest block call, we cache permanently, otherwise we cache for one minute
+      if (block === 'latest') {
+        setTimeout(() => {
+          if (this.#performCache.get(tag) === perform) {
+            this.#performCache.delete(tag)
+          }
+        }, 60 * 1000)
+      }
+    } else {
+      hit_count.add(1)
+    }
+
+    const result = await perform
+    if (!result) {
+      throw Error('Unexpected null response')
+    }
+    return result
+  }
+}

package/src/service.ts

@@ -7,7 +7,12 @@ import {
   DataBinding,
   DeepPartial,
   Empty,
+  EthCallParam,
   HandlerType,
+  PreparedData,
+  PreprocessResult,
+  PreprocessStreamRequest,
+  PreprocessStreamResponse,
   ProcessBindingResponse,
   ProcessBindingsRequest,
   ProcessConfigRequest,
@@ -20,11 +25,21 @@ import {
 } from '@sentio/protos'
 
 import { PluginManager } from './plugin.js'
-import { errorString, mergeProcessResults } from './utils.js'
+import { errorString, makeEthCallKey, mergeProcessResults } from './utils.js'
 import { freezeGlobalConfig, GLOBAL_CONFIG } from './global-config.js'
 
 import { StoreContext } from './db-context.js'
 import { Subject } from 'rxjs'
+import { metrics } from '@opentelemetry/api'
+import { getProvider } from './provider.js'
+import { EthChainId } from '@sentio/chain'
+import { Provider } from 'ethers'
+
+const meter = metrics.getMeter('processor_service')
+const process_binding_count = meter.createCounter('process_binding_count')
+const process_binding_time = meter.createCounter('process_binding_time')
+const process_binding_error = meter.createCounter('process_binding_error')
+
 ;(BigInt.prototype as any).toJSON = function () {
   return this.toString()
 }
@@ -39,6 +54,8 @@ export class ProcessorServiceImpl implements ProcessorServiceImplementation {
 
   private readonly shutdownHandler?: () => void
 
+  private readonly preprocessedEthCalls: { [calldata: string]: any[] }
+
   constructor(loader: () => Promise<any>, shutdownHandler?: () => void) {
     this.loader = loader
     this.shutdownHandler = shutdownHandler
@@ -111,10 +128,11 @@ export class ProcessorServiceImpl implements ProcessorServiceImplementation {
   }
 
   async processBindings(request: ProcessBindingsRequest, options?: CallContext): Promise<ProcessBindingResponse> {
-    const promises = []
+    const ethCallResults = await this.preprocessBindings(request.bindings, undefined, options)
 
+    const promises = []
     for (const binding of request.bindings) {
-      const promise = this.processBinding(binding)
+      const promise = this.processBinding(binding, { ethCallResults })
       if (GLOBAL_CONFIG.execution.sequential) {
         await promise
       }
@@ -139,7 +157,99 @@ export class ProcessorServiceImpl implements ProcessorServiceImplementation {
     }
   }
 
-  async processBinding(request: DataBinding, options?: CallContext): Promise<ProcessResult> {
+  async preprocessBindings(
+    bindings: DataBinding[],
+    dbContext?: StoreContext,
+    options?: CallContext
+  ): Promise<{ [ethCallKey: string]: string }> {
+    console.debug(`preprocessBindings start, bindings: ${bindings.length}`)
+    const promises = []
+    for (const binding of bindings) {
+      promises.push(this.preprocessBinding(binding, dbContext, options))
+    }
+    let preprocessResults: PreprocessResult[]
+    try {
+      preprocessResults = await Promise.all(promises)
+    } catch (e) {
+      throw e
+    }
+    console.debug(
+      'ethCallParams: ',
+      preprocessResults.map((r) => r.ethCallParams)
+    )
+    const groupedRequests = new Map<string, EthCallParam[]>()
+    const providers = new Map<string, Provider>()
+    for (const result of preprocessResults) {
+      for (const param of result.ethCallParams) {
+        const { chainId, address, blockTag } = param.context!
+        if (!providers.has(chainId)) {
+          providers.set(chainId, getProvider(chainId as EthChainId))
+        }
+        const key = [chainId, address, blockTag].join('|')
+        if (!groupedRequests.has(key)) {
+          groupedRequests.set(key, [])
+        }
+        groupedRequests.get(key)!.push(param)
+      }
+    }
+
+    const start = Date.now()
+    const callPromises = []
+    for (const params of groupedRequests.values()) {
+      const { chainId, address, blockTag } = params[0].context!
+      console.log(`chain: ${chainId}, address: ${address}, blockTag: ${blockTag}, totalCalls: ${params.length}`)
+      // TODO multicall
+      for (const param of params) {
+        callPromises.push(
+          providers
+            .get(chainId)!
+            .call({
+              to: address,
+              data: param.calldata,
+              blockTag
+            })
+            .then((result) => [makeEthCallKey(param), result])
+        )
+      }
+    }
+    let results = {}
+    try {
+      results = Object.fromEntries(await Promise.all(callPromises))
+    } catch (e) {
+      console.error(`eth call error: ${e}`)
+    }
+    console.log(`${callPromises.length} calls finished, elapsed: ${Date.now() - start}ms`)
+    return results
+  }
+
+  async preprocessBinding(
+    request: DataBinding,
+    dbContext?: StoreContext,
+    options?: CallContext
+  ): Promise<PreprocessResult> {
+    if (!this.started) {
+      throw new ServerError(Status.UNAVAILABLE, 'Service Not started.')
+    }
+    if (this.unhandled) {
+      throw new RichServerError(
+        Status.UNAVAILABLE,
+        'Unhandled exception/rejection in previous request: ' + errorString(this.unhandled),
+        [
+          DebugInfo.fromPartial({
+            detail: this.unhandled.message,
+            stackEntries: this.unhandled.stack?.split('\n')
+          })
+        ]
+      )
+    }
+    return await PluginManager.INSTANCE.preprocessBinding(request, dbContext)
+  }
+
+  async processBinding(
+    request: DataBinding,
+    preparedData: PreparedData | undefined,
+    options?: CallContext
+  ): Promise<ProcessResult> {
     if (!this.started) {
       throw new ServerError(Status.UNAVAILABLE, 'Service Not started.')
     }
@@ -155,7 +265,7 @@ export class ProcessorServiceImpl implements ProcessorServiceImplementation {
         ]
       )
     }
-    const result = await PluginManager.INSTANCE.processBinding(request)
+    const result = await PluginManager.INSTANCE.processBinding(request, preparedData)
     recordRuntimeInfo(result, request.handlerType)
     return result
   }
@@ -177,6 +287,63 @@ export class ProcessorServiceImpl implements ProcessorServiceImplementation {
     yield* from(subject).pipe(withAbort(context.signal))
   }
 
+  async handlePreprocessRequests(
+    requests: AsyncIterable<PreprocessStreamRequest>,
+    subject: Subject<DeepPartial<PreprocessStreamResponse>>
+  ) {
+    const contexts = new Contexts()
+
+    for await (const request of requests) {
+      try {
+        console.debug('received request:', request)
+        if (request.bindings) {
+          const bindings = request.bindings.bindings
+          const dbContext = contexts.new(request.processId, subject)
+          const start = Date.now()
+          this.preprocessBindings(bindings, dbContext)
+            .then(() => {
+              subject.next({
+                processId: request.processId
+              })
+            })
+            .catch((e) => {
+              console.debug(e)
+              dbContext.error(request.processId, e)
+            })
+            .finally(() => {
+              const cost = Date.now() - start
+              console.debug('preprocessBinding', request.processId, ' took', cost, 'ms')
+              contexts.delete(request.processId)
+            })
+        }
+        if (request.dbResult) {
+          const dbContext = contexts.get(request.processId)
+          dbContext?.result(request.dbResult)
+        }
+      } catch (e) {
+        // should not happen
+        console.error('unexpect error during handle loop', e)
+      }
+    }
+  }
+
+  async *preprocessBindingsStream(requests: AsyncIterable<PreprocessStreamRequest>, context: CallContext) {
+    if (!this.started) {
+      throw new ServerError(Status.UNAVAILABLE, 'Service Not started.')
+    }
+
+    const subject = new Subject<DeepPartial<PreprocessStreamResponse>>()
+    this.handlePreprocessRequests(requests, subject)
+      .then(() => {
+        subject.complete()
+      })
+      .catch((e) => {
+        console.error(e)
+        subject.error(e)
+      })
+    yield* from(subject).pipe(withAbort(context.signal))
+  }
+
   private async handleRequests(
     requests: AsyncIterable<ProcessStreamRequest>,
     subject: Subject<DeepPartial<ProcessStreamResponse>>
@@ -184,30 +351,40 @@ export class ProcessorServiceImpl implements ProcessorServiceImplementation {
     const contexts = new Contexts()
 
     for await (const request of requests) {
-      console.debug('received request:', request)
-      if (request.binding) {
-        const binding = request.binding
-        const dbContext = contexts.new(request.processId, subject)
-
-        PluginManager.INSTANCE.processBinding(binding, dbContext)
-          .then((result) => {
-            subject.next({
-              result,
-              processId: request.processId
+      try {
+        console.debug('received request:', request)
+        if (request.binding) {
+          process_binding_count.add(1)
+          const binding = request.binding
+          const dbContext = contexts.new(request.processId, subject)
+          const start = Date.now()
+          PluginManager.INSTANCE.processBinding(binding, undefined, dbContext)
+            .then((result) => {
+              subject.next({
+                result,
+                processId: request.processId
+              })
+              recordRuntimeInfo(result, binding.handlerType)
             })
-            recordRuntimeInfo(result, binding.handlerType)
-          })
-          .catch((e) => {
-            console.error(e)
-            dbContext.error(request.processId, e)
-          })
-          .finally(() => {
-            contexts.delete(request.processId)
-          })
-      }
-      if (request.dbResult) {
-        const dbContext = contexts.get(request.processId)
-        dbContext?.result(request.dbResult)
+            .catch((e) => {
+              console.debug(e)
+              dbContext.error(request.processId, e)
+              process_binding_error.add(1)
+            })
+            .finally(() => {
+              const cost = Date.now() - start
+              console.debug('processBinding', request.processId, ' took', cost, 'ms')
+              process_binding_time.add(cost)
+              contexts.delete(request.processId)
+            })
+        }
+        if (request.dbResult) {
+          const dbContext = contexts.get(request.processId)
+          dbContext?.result(request.dbResult)
+        }
+      } catch (e) {
+        // should not happen
+        console.error('unexpect error during handle loop', e)
       }
     }
   }

package/src/tsup.config.ts

@@ -0,0 +1,14 @@
+import { defineConfig } from 'tsup'
+
+export default defineConfig({
+  esbuildOptions: (options) => {
+    options.banner = {
+      js: `import { createRequire as createRequireShim } from 'module'; const require = createRequireShim(import.meta.url);`
+    }
+  },
+  entry: ['src/index.ts', 'src/processor-runner.ts'],
+  outDir: 'lib',
+  clean: true,
+  dts: true,
+  format: 'esm'
+})

package/src/utils.ts

@@ -1,4 +1,4 @@
-import { ProcessResult } from '@sentio/protos'
+import { EthCallParam, ProcessResult } from '@sentio/protos'
 
 // TODO better handling this, because old proto doesn't have this
 import { StateResult, ProcessResult as ProcessResultFull } from './gen/processor/protos/processor.js'
@@ -8,7 +8,7 @@ import { Required } from 'utility-types'
 export function mergeProcessResults(results: ProcessResult[]): Required<ProcessResult, 'states'> {
   const res = {
     ...ProcessResultFull.create(),
-    states: StateResult.create(),
+    states: StateResult.create()
   }
 
   for (const r of results) {
@@ -17,7 +17,7 @@ export function mergeProcessResults(results: ProcessResult[]): Required<ProcessR
     res.events = res.events.concat(r.events)
     res.exports = res.exports.concat(r.exports)
     res.states = {
-      configUpdated: res.states?.configUpdated || r.states?.configUpdated || false,
+      configUpdated: res.states?.configUpdated || r.states?.configUpdated || false
     }
   }
   return res
@@ -28,3 +28,11 @@ export function errorString(e: Error): string {
 }
 
 export const USER_PROCESSOR = 'user_processor'
+
+export function makeEthCallKey(param: EthCallParam) {
+  if (!param.context) {
+    throw new Error('null context for eth call')
+  }
+  const { chainId, address, blockTag } = param.context
+  return `${chainId}|${address}|${blockTag}|${param.calldata}`
+}

package/lib/chain-config.d.ts

@@ -1,6 +0,0 @@
-export interface ChainConfig {
-    ChainID: string;
-    Https?: string[];
-    ChainServer?: string;
-}
-//# sourceMappingURL=chain-config.d.ts.map

package/lib/chain-config.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"chain-config.d.ts","sourceRoot":"","sources":["../src/chain-config.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,WAAW;IAC1B,OAAO,EAAE,MAAM,CAAA;IACf,KAAK,CAAC,EAAE,MAAM,EAAE,CAAA;IAChB,WAAW,CAAC,EAAE,MAAM,CAAA;CACrB"}

package/lib/chain-config.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=chain-config.js.map

package/lib/chain-config.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"chain-config.js","sourceRoot":"","sources":["../src/chain-config.ts"],"names":[],"mappings":""}

package/lib/db-context.d.ts

@@ -1,17 +0,0 @@
-import { Subject } from 'rxjs';
-import { DBRequest, DBResponse, DeepPartial, ProcessStreamResponse } from '@sentio/protos';
-type Request = Omit<DBRequest, 'opId'>;
-export declare class StoreContext {
-    readonly subject: Subject<DeepPartial<ProcessStreamResponse>>;
-    readonly processId: number;
-    private static opCounter;
-    private defers;
-    constructor(subject: Subject<DeepPartial<ProcessStreamResponse>>, processId: number);
-    newPromise<T>(opId: bigint): Promise<T>;
-    sendRequest(request: DeepPartial<Request>): Promise<unknown>;
-    result(dbResult: DBResponse): void;
-    error(processId: number, e: any): void;
-    close(): void;
-}
-export {};
-//# sourceMappingURL=db-context.d.ts.map

package/lib/db-context.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"db-context.d.ts","sourceRoot":"","sources":["../src/db-context.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,MAAM,CAAA;AAC9B,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,WAAW,EAAiB,qBAAqB,EAAE,MAAM,gBAAgB,CAAA;AAEzG,KAAK,OAAO,GAAG,IAAI,CAAC,SAAS,EAAE,MAAM,CAAC,CAAA;AAEtC,qBAAa,YAAY;IAMrB,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC,WAAW,CAAC,qBAAqB,CAAC,CAAC;IAC7D,QAAQ,CAAC,SAAS,EAAE,MAAM;IAN5B,OAAO,CAAC,MAAM,CAAC,SAAS,CAAK;IAE7B,OAAO,CAAC,MAAM,CAAuF;gBAG1F,OAAO,EAAE,OAAO,CAAC,WAAW,CAAC,qBAAqB,CAAC,CAAC,EACpD,SAAS,EAAE,MAAM;IAG5B,UAAU,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM;IAM1B,WAAW,CAAC,OAAO,EAAE,WAAW,CAAC,OAAO,CAAC;IAczC,MAAM,CAAC,QAAQ,EAAE,UAAU;IAc3B,KAAK,CAAC,SAAS,EAAE,MAAM,EAAE,CAAC,EAAE,GAAG;IAa/B,KAAK;CAON"}