Separate the Abi Resolvers by fragment and full address abi (#80)

Ferossgp · web-flow · commit 32af229b7f1c · 2024-07-21T20:53:27.000+02:00
diff --git a/.changeset/proud-ghosts-behave.md b/.changeset/proud-ghosts-behave.md
@@ -0,0 +1,5 @@
+---
+'@3loop/transaction-decoder': minor
+---
+
+Separate ABI resolvers into fragment and full address abi
diff --git a/packages/transaction-decoder/src/abi-loader.ts b/packages/transaction-decoder/src/abi-loader.ts
@@ -1,5 +1,5 @@
 import { Context, Effect, Either, RequestResolver, Request, Array, pipe } from 'effect'
-import { ContractABI, GetContractABIStrategy } from './abi-strategy/request-model.js'
+import { ContractABI, ContractAbiResolverStrategy, GetContractABIStrategy } from './abi-strategy/request-model.js'
 
 const STRATEGY_TIMEOUT = 5000
 export interface AbiParams {
@@ -28,7 +28,7 @@ export type ContractAbiResult = ContractAbiSuccess | ContractAbiNotFound | Contr
 
 type ChainOrDefault = number | 'default'
 export interface AbiStore<Key = AbiParams, Value = ContractAbiResult> {
-  readonly strategies: Record<ChainOrDefault, readonly RequestResolver.RequestResolver<GetContractABIStrategy>[]>
+  readonly strategies: Record<ChainOrDefault, readonly ContractAbiResolverStrategy[]>
   readonly set: (key: Key, value: Value) => Effect.Effect<void, never>
   readonly get: (arg: Key) => Effect.Effect<Value, never>
   readonly getMany?: (arg: Array<Key>) => Effect.Effect<Array<Value>, never>
@@ -46,7 +46,7 @@ export interface AbiLoader extends Request.Request<string | null, unknown> {
 
 const AbiLoader = Request.tagged<AbiLoader>('AbiLoader')
 
-function makeKey(key: AbiLoader) {
+function makeRequestKey(key: AbiLoader) {
   return `abi::${key.chainID}:${key.address}:${key.event}:${key.signature}`
 }
 
@@ -121,7 +121,7 @@ const getBestMatch = (abi: ContractABI | null) => {
  * To optimize concurrent requests, the AbiLoader uses the RequestResolver
  * to batch and cache requests. However, out-of-the-box, the RequestResolver does not
  * perform request deduplication. To address this, we implement request deduplication
- * inside the resolver's body. We use the `makeKey` function to generate a unique key
+ * inside the resolver's body. We use the `makeRequestKey` function to generate a unique key
  * for each request and group them by that key. We then load the ABI for the unique
  * requests and resolve the pending requests in a group with the same result.
  *
@@ -133,12 +133,11 @@ const AbiLoaderRequestResolver = RequestResolver.makeBatched((requests: Array<Ab
     if (requests.length === 0) return
 
     const { strategies } = yield* AbiStore
-    // NOTE: We can further optimize if we have match by Address by avoid extra requests for each signature
-    // but might need to update the Loader public API
-    const groups = Array.groupBy(requests, makeKey)
-    const uniqueRequests = Object.values(groups).map((group) => group[0])
 
-    const [remaining, results] = yield* pipe(
+    const requestGroups = Array.groupBy(requests, makeRequestKey)
+    const uniqueRequests = Object.values(requestGroups).map((group) => group[0])
+
+    const [remaining, cachedResults] = yield* pipe(
       getMany(uniqueRequests),
       Effect.map(
         Array.partitionMap((resp, i) => {
@@ -152,9 +151,9 @@ const AbiLoaderRequestResolver = RequestResolver.makeBatched((requests: Array<Ab
 
     //  Resolve ABI from the store
     yield* Effect.forEach(
-      results,
+      cachedResults,
       ([request, result]) => {
-        const group = groups[makeKey(request)]
+        const group = requestGroups[makeRequestKey(request)]
         const abi = result?.abi ?? null
         return Effect.forEach(group, (req) => Request.succeed(req, abi), { discard: true })
       },
@@ -163,32 +162,64 @@ const AbiLoaderRequestResolver = RequestResolver.makeBatched((requests: Array<Ab
       },
     )
 
-    // Load the ABI from the strategies
-    const strategyResults = yield* Effect.forEach(remaining, ({ chainID, address, event, signature }) => {
+    // NOTE: Firstly we batch strategies by address because in a transaction most of events and traces are from the same abi
+    const response = yield* Effect.forEach(remaining, (req) => {
+      const strategyRequest = GetContractABIStrategy({
+        address: req.address,
+        chainID: req.chainID,
+      })
+
+      const allAvailableStrategies = Array.prependAll(strategies.default, strategies[req.chainID] ?? []).filter(
+        (strategy) => strategy.type === 'address',
+      )
+
+      return Effect.validateFirst(allAvailableStrategies, (strategy) =>
+        pipe(
+          Effect.request(strategyRequest, strategy.resolver),
+          Effect.withRequestCaching(true),
+          Effect.timeout(STRATEGY_TIMEOUT),
+        ),
+      ).pipe(
+        Effect.map(Either.left),
+        Effect.orElseSucceed(() => Either.right(req)),
+      )
+    })
+
+    const [addressStrategyResults, notFound] = Array.partitionMap(response, (res) => res)
+
+    // NOTE: Secondly we request strategies to fetch fragments
+    const fragmentStrategyResults = yield* Effect.forEach(notFound, ({ chainID, address, event, signature }) => {
       const strategyRequest = GetContractABIStrategy({
         address,
+        chainID,
         event,
         signature,
-        chainID,
       })
 
-      const allAvailableStrategies = Array.prependAll(strategies.default, strategies[chainID] ?? [])
+      const allAvailableStrategies = Array.prependAll(strategies.default, strategies[chainID] ?? []).filter(
+        (strategy) => strategy.type === 'fragment',
+      )
 
       // TODO: Distinct the errors and missing data, so we can retry on errors
-      return Effect.validateFirst(allAvailableStrategies, (strategy) => Effect.request(strategyRequest, strategy)).pipe(
-        Effect.timeout(STRATEGY_TIMEOUT),
-        Effect.orElseSucceed(() => null),
-      )
+      return Effect.validateFirst(allAvailableStrategies, (strategy) =>
+        pipe(
+          Effect.request(strategyRequest, strategy.resolver),
+          Effect.withRequestCaching(true),
+          Effect.timeout(STRATEGY_TIMEOUT),
+        ),
+      ).pipe(Effect.orElseSucceed(() => null))
     })
 
+    const strategyResults = Array.appendAll(addressStrategyResults, fragmentStrategyResults)
+
     // Store results and resolve pending requests
     yield* Effect.forEach(
       strategyResults,
       (abi, i) => {
         const request = remaining[i]
         const result = getBestMatch(abi)
 
-        const group = groups[makeKey(request)]
+        const group = requestGroups[makeRequestKey(request)]
 
         return Effect.zipRight(
           setValue(request, abi),
diff --git a/packages/transaction-decoder/src/abi-strategy/blockscout-abi.ts b/packages/transaction-decoder/src/abi-strategy/blockscout-abi.ts
@@ -34,14 +34,21 @@ async function fetchContractABI(
   throw new Error(`Failed to fetch ABI for ${address} on chain ${chainID}`)
 }
 
-export const BlockscoutStrategyResolver = (config: { apikey?: string; endpoint: string }) =>
-  RequestResolver.fromEffect((req: RequestModel.GetContractABIStrategy) =>
-    Effect.withSpan(
-      Effect.tryPromise({
-        try: () => fetchContractABI(req, config),
-        catch: () => new RequestModel.ResolveStrategyABIError('Blockscout', req.address, req.chainID),
-      }),
-      'AbiStrategy.BlockscoutStrategyResolver',
-      { attributes: { chainID: req.chainID, address: req.address } },
+export const BlockscoutStrategyResolver = (config: {
+  apikey?: string
+  endpoint: string
+}): RequestModel.ContractAbiResolverStrategy => {
+  return {
+    type: 'address',
+    resolver: RequestResolver.fromEffect((req: RequestModel.GetContractABIStrategy) =>
+      Effect.withSpan(
+        Effect.tryPromise({
+          try: () => fetchContractABI(req, config),
+          catch: () => new RequestModel.ResolveStrategyABIError('Blockscout', req.address, req.chainID),
+        }),
+        'AbiStrategy.BlockscoutStrategyResolver',
+        { attributes: { chainID: req.chainID, address: req.address } },
+      ),
     ),
-  )
+  }
+}
diff --git a/packages/transaction-decoder/src/abi-strategy/etherscan-abi.ts b/packages/transaction-decoder/src/abi-strategy/etherscan-abi.ts
@@ -52,7 +52,7 @@ async function fetchContractABI(
   config?: { apikey?: string; endpoint?: string },
 ): Promise<RequestModel.ContractABI> {
   const endpoint = config?.endpoint ?? endpoints[chainID]
-
+  console.log('fetchContractABI', address)
   const params: Record<string, string> = {
     module: 'contract',
     action: 'getabi',
@@ -80,14 +80,21 @@ async function fetchContractABI(
   throw new Error(`Failed to fetch ABI for ${address} on chain ${chainID}`)
 }
 
-export const EtherscanStrategyResolver = (config?: { apikey?: string; endpoint?: string }) =>
-  RequestResolver.fromEffect((req: RequestModel.GetContractABIStrategy) =>
-    Effect.withSpan(
-      Effect.tryPromise({
-        try: () => fetchContractABI(req, config),
-        catch: () => new RequestModel.ResolveStrategyABIError('etherscan', req.address, req.chainID),
-      }),
-      'AbiStrategy.EtherscanStrategyResolver',
-      { attributes: { chainID: req.chainID, address: req.address } },
+export const EtherscanStrategyResolver = (config?: {
+  apikey?: string
+  endpoint?: string
+}): RequestModel.ContractAbiResolverStrategy => {
+  return {
+    type: 'address',
+    resolver: RequestResolver.fromEffect((req: RequestModel.GetContractABIStrategy) =>
+      Effect.withSpan(
+        Effect.tryPromise({
+          try: () => fetchContractABI(req, config),
+          catch: () => new RequestModel.ResolveStrategyABIError('etherscan', req.address, req.chainID),
+        }),
+        'AbiStrategy.EtherscanStrategyResolver',
+        { attributes: { chainID: req.chainID, address: req.address } },
+      ),
     ),
-  )
+  }
+}
diff --git a/packages/transaction-decoder/src/abi-strategy/fourbyte-abi.ts b/packages/transaction-decoder/src/abi-strategy/fourbyte-abi.ts
@@ -58,14 +58,18 @@ async function fetchABI({
   throw new Error(`Failed to fetch ABI for ${address} on chain ${chainID}`)
 }
 
-export const FourByteStrategyResolver = () =>
-  RequestResolver.fromEffect((req: RequestModel.GetContractABIStrategy) =>
-    Effect.withSpan(
-      Effect.tryPromise({
-        try: () => fetchABI(req),
-        catch: () => new RequestModel.ResolveStrategyABIError('4byte.directory', req.address, req.chainID),
-      }),
-      'AbiStrategy.FourByteStrategyResolver',
-      { attributes: { chainID: req.chainID, address: req.address } },
+export const FourByteStrategyResolver = (): RequestModel.ContractAbiResolverStrategy => {
+  return {
+    type: 'fragment',
+    resolver: RequestResolver.fromEffect((req: RequestModel.GetContractABIStrategy) =>
+      Effect.withSpan(
+        Effect.tryPromise({
+          try: () => fetchABI(req),
+          catch: () => new RequestModel.ResolveStrategyABIError('4byte.directory', req.address, req.chainID),
+        }),
+        'AbiStrategy.FourByteStrategyResolver',
+        { attributes: { chainID: req.chainID, address: req.address } },
+      ),
     ),
-  )
+  }
+}
diff --git a/packages/transaction-decoder/src/abi-strategy/openchain-abi.ts b/packages/transaction-decoder/src/abi-strategy/openchain-abi.ts
@@ -76,14 +76,18 @@ async function fetchABI({
   throw new Error(`Failed to fetch ABI for ${address} on chain ${chainID}`)
 }
 
-export const OpenchainStrategyResolver = () =>
-  RequestResolver.fromEffect((req: RequestModel.GetContractABIStrategy) =>
-    Effect.withSpan(
-      Effect.tryPromise({
-        try: () => fetchABI(req),
-        catch: () => new RequestModel.ResolveStrategyABIError('openchain', req.address, req.chainID),
-      }),
-      'AbiStrategy.OpenchainStrategyResolver',
-      { attributes: { chainID: req.chainID, address: req.address } },
+export const OpenchainStrategyResolver = (): RequestModel.ContractAbiResolverStrategy => {
+  return {
+    type: 'fragment',
+    resolver: RequestResolver.fromEffect((req: RequestModel.GetContractABIStrategy) =>
+      Effect.withSpan(
+        Effect.tryPromise({
+          try: () => fetchABI(req),
+          catch: () => new RequestModel.ResolveStrategyABIError('openchain', req.address, req.chainID),
+        }),
+        'AbiStrategy.OpenchainStrategyResolver',
+        { attributes: { chainID: req.chainID, address: req.address } },
+      ),
     ),
-  )
+  }
+}
diff --git a/packages/transaction-decoder/src/abi-strategy/request-model.ts b/packages/transaction-decoder/src/abi-strategy/request-model.ts
@@ -1,4 +1,4 @@
-import { Request } from 'effect'
+import { Request, RequestResolver } from 'effect'
 
 export interface FetchABIParams {
   readonly chainID: number
@@ -47,3 +47,8 @@ export interface GetContractABIStrategy extends Request.Request<ContractABI, Res
 }
 
 export const GetContractABIStrategy = Request.tagged<GetContractABIStrategy>('GetContractABIStrategy')
+
+export interface ContractAbiResolverStrategy {
+  type: 'address' | 'fragment'
+  resolver: RequestResolver.RequestResolver<GetContractABIStrategy, never>
+}
diff --git a/packages/transaction-decoder/src/abi-strategy/sourcify-abi.ts b/packages/transaction-decoder/src/abi-strategy/sourcify-abi.ts
@@ -43,14 +43,18 @@ async function fetchContractABI({
   throw new Error(`Failed to fetch ABI for ${address} on chain ${chainID}`)
 }
 
-export const SourcifyStrategyResolver = () =>
-  RequestResolver.fromEffect((req: RequestModel.GetContractABIStrategy) =>
-    Effect.withSpan(
-      Effect.tryPromise({
-        try: () => fetchContractABI(req),
-        catch: () => new RequestModel.ResolveStrategyABIError('sourcify', req.address, req.chainID),
-      }),
-      'AbiStrategy.SourcifyStrategyResolver',
-      { attributes: { chainID: req.chainID, address: req.address } },
+export const SourcifyStrategyResolver = (): RequestModel.ContractAbiResolverStrategy => {
+  return {
+    type: 'address',
+    resolver: RequestResolver.fromEffect((req: RequestModel.GetContractABIStrategy) =>
+      Effect.withSpan(
+        Effect.tryPromise({
+          try: () => fetchContractABI(req),
+          catch: () => new RequestModel.ResolveStrategyABIError('sourcify', req.address, req.chainID),
+        }),
+        'AbiStrategy.SourcifyStrategyResolver',
+        { attributes: { chainID: req.chainID, address: req.address } },
+      ),
     ),
-  )
+  }
+}
diff --git a/packages/transaction-decoder/src/vanilla.ts b/packages/transaction-decoder/src/vanilla.ts
@@ -7,9 +7,9 @@ import {
   ContractMetaResult,
   ContractMetaStore as EffectContractMetaStore,
 } from './contract-meta-loader.js'
-import { GetContractABIStrategy } from './abi-strategy/index.js'
-import { Hex } from 'viem'
-import { GetContractMetaStrategy } from './meta-strategy/request-model.js'
+import type { ContractAbiResolverStrategy } from './abi-strategy/index.js'
+import type { Hex } from 'viem'
+import type { GetContractMetaStrategy } from './meta-strategy/request-model.js'
 
 export interface TransactionDecoderOptions {
   getPublicClient: (chainID: number) => PublicClientObject | undefined
@@ -19,7 +19,7 @@ export interface TransactionDecoderOptions {
 }
 
 export interface VanillaAbiStore {
-  strategies?: readonly RequestResolver.RequestResolver<GetContractABIStrategy>[]
+  strategies?: readonly ContractAbiResolverStrategy[]
   get: (key: AbiParams) => Promise<ContractAbiResult>
   set: (key: AbiParams, val: ContractAbiResult) => Promise<void>
 }

-Original file line number
+Diff line change
@@ @@ -0,0 +1,5 @@ @@
 +---
 +'@3loop/transaction-decoder': minor
 +---
++
 +Separate ABI resolvers into fragment and full address abi