@0xtorch/evm 0.0.1

package/src/analyzer/json/analyze.ts

@@ -0,0 +1,536 @@
+import type {
+  ActionType,
+  CryptoCurrencyPrice,
+  NormalAction,
+} from '@0xtorch/core'
+import type { EvmAccount, TransactionDecoded } from '../../types'
+import { toLowerHex } from '../../types'
+import { createAccountActionByAction } from '../createAccountActionByAction'
+import type { AnalyzeParameters, AnalyzeReturnType } from '../types'
+import { generateActionsByAnyLogGenerator } from './generatorAnyLog'
+import { generateActionsByAnyTokenTransferGenerator } from './generatorAnyTokenTransfer'
+import { generateActionBySpecificTokenTransferGenerator } from './generatorSpecificTokenTransfer'
+import type { AnalyzeRule, ParameterBase, ParameterIndex } from './types'
+
+export const createAnalyzeByJsonRule =
+  (rule: AnalyzeRule) =>
+  <Price extends CryptoCurrencyPrice | undefined>({
+    chain,
+    transaction,
+    accountAddresses,
+  }: AnalyzeParameters<Price>): Promise<
+    AnalyzeReturnType<Price> | undefined
+  > => {
+    const {
+      chainId,
+      from,
+      to,
+      value,
+      functionSignature,
+      functionInterface,
+      logsPatterns,
+      internalsPatterns,
+      parameterMatchPatterns,
+      generators,
+    } = rule
+
+    // transaction fail の場合は undefined
+    if (transaction.status !== 'success') {
+      return Promise.resolve(undefined)
+    }
+
+    // chainId != undefined で chainId が一致しない場合は undefined
+    if (chainId !== undefined && transaction.chainId !== chainId) {
+      return Promise.resolve(undefined)
+    }
+
+    // from != undefined で from が一致しない場合は undefined
+    if (from !== undefined && !from.includes(toLowerHex(transaction.from))) {
+      return Promise.resolve(undefined)
+    }
+
+    // to != undefined で to が一致しない場合は undefined
+    if (
+      to !== undefined &&
+      (transaction.to === null || !to.includes(toLowerHex(transaction.to)))
+    ) {
+      return Promise.resolve(undefined)
+    }
+
+    // value != undefined で value が一致しない場合は undefined
+    switch (value) {
+      case 'plus': {
+        if (transaction.value <= 0n) {
+          return Promise.resolve(undefined)
+        }
+        break
+      }
+      case 'zero': {
+        if (transaction.value !== 0n) {
+          return Promise.resolve(undefined)
+        }
+        break
+      }
+      case undefined: {
+        break
+      }
+    }
+
+    // function signature が一致しない場合は undefined
+    if (functionSignature !== toLowerHex(transaction.input).slice(0, 10)) {
+      return Promise.resolve(undefined)
+    }
+
+    // functionInterface!= undefined で functionInterface が一致しない場合は undefined
+    if (functionInterface !== undefined) {
+      if (transaction.function === undefined) {
+        return Promise.resolve(undefined)
+      }
+      const argumentsInterface =
+        transaction.function.args === undefined
+          ? ''
+          : transaction.function.args.map(({ type }) => type).join(', ')
+      const interface_ = `${transaction.function.name}(${argumentsInterface})`
+      if (functionInterface !== interface_) {
+        return Promise.resolve(undefined)
+      }
+    }
+
+    // logs pattern に一致するか確認
+    for (const pattern of logsPatterns) {
+      switch (pattern.matchType) {
+        case 'exact': {
+          // log が完全一致するか確認
+          for (const [index, log] of transaction.logs.entries()) {
+            const item = pattern.items[index]
+            if (log.log.topics.length === 0) {
+              return Promise.resolve(undefined)
+            }
+            const topics0 = log.log.topics[0]
+            const signature =
+              topics0 === undefined ? undefined : toLowerHex(topics0)
+            if (signature === undefined || item.signature !== signature) {
+              return Promise.resolve(undefined)
+            }
+            if (item.indexedCount !== log.log.topics.length - 1) {
+              return Promise.resolve(undefined)
+            }
+            if (item.args !== undefined) {
+              for (const { type, index, value } of item.args) {
+                switch (type) {
+                  case 'to-lower-string-value': {
+                    if (log.type !== 'decoded') {
+                      return Promise.resolve(undefined)
+                    }
+                    if (
+                      String(log.log.args[index].value).toLowerCase() !== value
+                    ) {
+                      return Promise.resolve(undefined)
+                    }
+                    break
+                  }
+                }
+              }
+            }
+          }
+          break
+        }
+        case 'partial': {
+          // log が部分一致するか確認
+          const matchLogCount = transaction.logs.filter((log) => {
+            if (log.log.topics.length === 0) {
+              return false
+            }
+            const topics0 = log.log.topics[0]
+            const signature =
+              topics0 === undefined ? undefined : toLowerHex(topics0)
+            if (signature === undefined || pattern.signature !== signature) {
+              return false
+            }
+            if (pattern.indexedCount !== log.log.topics.length - 1) {
+              return false
+            }
+            if (pattern.args !== undefined) {
+              for (const { type, index, value } of pattern.args) {
+                switch (type) {
+                  case 'to-lower-string-value': {
+                    if (log.type !== 'decoded') {
+                      return false
+                    }
+                    if (
+                      String(log.log.args[index].value).toLowerCase() !== value
+                    ) {
+                      return false
+                    }
+                    break
+                  }
+                }
+              }
+            }
+            return true
+          }).length
+          if (pattern.logCount === undefined && matchLogCount === 0) {
+            return Promise.resolve(undefined)
+          }
+          if (
+            pattern.logCount !== undefined &&
+            pattern.logCount !== matchLogCount
+          ) {
+            return Promise.resolve(undefined)
+          }
+          break
+        }
+      }
+    }
+
+    // internal pattern に一致するか確認
+    for (const pattern of internalsPatterns ?? []) {
+      switch (pattern.type) {
+        case 'partial': {
+          const matchInternalCount = transaction.internalTransactions.filter(
+            (internal) => {
+              if (
+                pattern.from !== undefined &&
+                pattern.from !== internal.from
+              ) {
+                return false
+              }
+              if (pattern.to !== undefined && pattern.to !== internal.to) {
+                return false
+              }
+              if (pattern.value !== undefined) {
+                switch (pattern.value) {
+                  case 'plus': {
+                    if (internal.value <= 0n) {
+                      return false
+                    }
+                    break
+                  }
+                  case 'zero': {
+                    if (internal.value !== 0n) {
+                      return false
+                    }
+                    break
+                  }
+                }
+              }
+              return true
+            },
+          ).length
+          if (pattern.count === undefined && matchInternalCount === 0) {
+            return Promise.resolve(undefined)
+          }
+          if (
+            pattern.count !== undefined &&
+            pattern.count !== matchInternalCount
+          ) {
+            return Promise.resolve(undefined)
+          }
+        }
+      }
+    }
+
+    // parameter match pattern に一致するか確認
+    for (const pattern of parameterMatchPatterns ?? []) {
+      // base から value を取得
+      const baseValue = getParameterBaseValue(transaction, pattern.base)
+      if (baseValue === undefined) {
+        return Promise.resolve(undefined)
+      }
+      // compare から value 一覧を取得
+      const compareValues = getParameterCompareValues(
+        transaction,
+        pattern.compare,
+      )
+      if (compareValues === undefined) {
+        return Promise.resolve(undefined)
+      }
+
+      // compare が base value と一致するか確認
+      switch (compareValues.type) {
+        case 'every': {
+          if (!compareValues.values.every((value) => value === baseValue)) {
+            return Promise.resolve(undefined)
+          }
+          break
+        }
+        case 'some': {
+          if (!compareValues.values.includes(baseValue)) {
+            return Promise.resolve(undefined)
+          }
+          break
+        }
+      }
+    }
+
+    // rule に基づいて action を生成する
+    const mut_actions: NormalAction<ActionType, EvmAccount, Price>[] = []
+    for (const generator of generators) {
+      switch (generator.type) {
+        case 'any-token-transfer': {
+          const actions = generateActionsByAnyTokenTransferGenerator(
+            generator,
+            transaction,
+          )
+          mut_actions.push(...actions)
+          break
+        }
+        case 'any-log': {
+          const actions = generateActionsByAnyLogGenerator(
+            generator,
+            chain,
+            transaction,
+          )
+          mut_actions.push(...actions)
+          break
+        }
+        case 'specific-token-transfer': {
+          const action = generateActionBySpecificTokenTransferGenerator(
+            generator,
+            chain,
+            transaction,
+          )
+          mut_actions.push(action)
+          break
+        }
+      }
+    }
+
+    // actions から account actions の作成
+    const optionalAccountActions = mut_actions.map((action) =>
+      createAccountActionByAction(action, transaction, accountAddresses),
+    )
+    const accountActions = optionalAccountActions
+      .filter(
+        (action): action is Exclude<typeof action, undefined> =>
+          action !== undefined,
+      )
+      .map((action, index) => ({ ...action, order: index }))
+
+    return Promise.resolve({
+      actions: mut_actions,
+      accountActions,
+    })
+  }
+
+const getParameterBaseValue = <Price extends CryptoCurrencyPrice | undefined>(
+  transaction: TransactionDecoded<Price>,
+  base: ParameterBase,
+): string | undefined => {
+  switch (base.type) {
+    case 'from': {
+      return toLowerHex(transaction.from)
+    }
+    case 'to': {
+      return transaction.to === null ? undefined : toLowerHex(transaction.to)
+    }
+    case 'value': {
+      return transaction.value.toString()
+    }
+    case 'function': {
+      if (
+        transaction.function === undefined ||
+        transaction.function.args === undefined
+      ) {
+        return undefined
+      }
+      if (transaction.function.args.length <= base.argIndex) {
+        return undefined
+      }
+      return String(
+        transaction.function.args[base.argIndex].value,
+      ).toLowerCase()
+    }
+    case 'internal': {
+      if (transaction.internalTransactions.length <= base.index) {
+        return undefined
+      }
+      const internal = transaction.internalTransactions[base.index]
+      switch (base.key) {
+        case 'from': {
+          return internal.from
+        }
+        case 'to': {
+          return internal.to === undefined ? undefined : internal.to
+        }
+        case 'value': {
+          return internal.value.toString()
+        }
+      }
+      return undefined
+    }
+    case 'log': {
+      const targetLogs = transaction.logs.filter(
+        (log) =>
+          log.log.topics[0] === base.signature &&
+          log.log.topics.length - 1 === base.indexedCount,
+      )
+      if (targetLogs.length <= base.index) {
+        return undefined
+      }
+      const log = targetLogs[base.index]
+      if (log.type !== 'decoded') {
+        return undefined
+      }
+      if (log.log.args.length <= base.argIndex) {
+        return undefined
+      }
+      return String(log.log.args[base.argIndex].value).toLowerCase()
+    }
+  }
+}
+
+const getParameterCompareValues = <
+  Price extends CryptoCurrencyPrice | undefined,
+>(
+  transaction: TransactionDecoded<Price>,
+  compare: ParameterIndex,
+):
+  | {
+      readonly values: string[]
+      readonly type: 'some' | 'every'
+    }
+  | undefined => {
+  switch (compare.type) {
+    case 'from': {
+      return {
+        values: [toLowerHex(transaction.from)],
+        type: 'every',
+      }
+    }
+    case 'to': {
+      return transaction.to === null
+        ? undefined
+        : {
+            values: [toLowerHex(transaction.to)],
+            type: 'every',
+          }
+    }
+    case 'value': {
+      return {
+        values: [transaction.value.toString()],
+        type: 'every',
+      }
+    }
+    case 'function': {
+      if (
+        transaction.function === undefined ||
+        transaction.function.args === undefined
+      ) {
+        return undefined
+      }
+      if (transaction.function.args.length <= compare.argIndex) {
+        return undefined
+      }
+      return {
+        values: [
+          String(
+            transaction.function.args[compare.argIndex].value,
+          ).toLowerCase(),
+        ],
+        type: 'every',
+      }
+    }
+    case 'internal': {
+      if (compare.index === 'every' || compare.index === 'some') {
+        switch (compare.key) {
+          case 'from': {
+            return {
+              values: transaction.internalTransactions.map(
+                (internal) => internal.from,
+              ),
+              type: compare.index,
+            }
+          }
+          case 'to': {
+            return {
+              values: transaction.internalTransactions.map((internal) =>
+                internal.to === undefined ? '' : internal.to,
+              ),
+              type: compare.index,
+            }
+          }
+          case 'value': {
+            return {
+              values: transaction.internalTransactions.map((internal) =>
+                internal.value.toString(),
+              ),
+              type: compare.index,
+            }
+          }
+        }
+      } else {
+        if (transaction.internalTransactions.length <= compare.index) {
+          return undefined
+        }
+        const internal = transaction.internalTransactions[compare.index]
+        switch (compare.key) {
+          case 'from': {
+            return {
+              values: [internal.from],
+              type: 'every',
+            }
+          }
+          case 'to': {
+            return internal.to === undefined
+              ? undefined
+              : {
+                  values: [internal.to],
+                  type: 'every',
+                }
+          }
+          case 'value': {
+            return {
+              values: [internal.value.toString()],
+              type: 'every',
+            }
+          }
+        }
+      }
+      return undefined
+    }
+    case 'log': {
+      const targetLogs = transaction.logs.filter(
+        (log) =>
+          log.log.topics[0] === compare.signature &&
+          log.log.topics.length - 1 === compare.indexedCount,
+      )
+      if (targetLogs.length === 0) {
+        return undefined
+      }
+      if (compare.index === 'some' || compare.index === 'every') {
+        const values = targetLogs.map((log) => {
+          if (log.type !== 'decoded') {
+            return undefined
+          }
+          if (log.log.args.length <= compare.argIndex) {
+            return undefined
+          }
+          return String(log.log.args[compare.argIndex].value).toLowerCase()
+        })
+        if (values.includes(undefined)) {
+          return undefined
+        }
+        return {
+          values: values as string[],
+          type: compare.index,
+        }
+      } else {
+        if (targetLogs.length <= compare.index) {
+          return undefined
+        }
+        const log = targetLogs[compare.index]
+        if (log.type !== 'decoded') {
+          return undefined
+        }
+        if (log.log.args.length <= compare.argIndex) {
+          return undefined
+        }
+        return {
+          values: [String(log.log.args[compare.argIndex].value).toLowerCase()],
+          type: 'every',
+        }
+      }
+    }
+  }
+}