@0xtorch/evm 0.0.73 → 0.0.75

package/logic/analyzeTransaction/createActions/json/verifyTxSatisfiesCondition.ts

@@ -0,0 +1,731 @@
+import { stringify } from '@0xtorch/core'
+import type { z } from 'zod'
+import type {
+  Erc20TokenTransfer,
+  Erc721TokenTransfer,
+  Erc1155TokenTransfer,
+  Log,
+  LowerHex,
+  TransactionDecoded,
+} from '../../../../types'
+import { getAllValue } from './allValue'
+import { checkValueIsArrayIn } from './arrayIn'
+import { checkValueIsBetweenBigInt } from './betweenBigInt'
+import { checkTransferIsMatchErc20Pattern } from './erc20Pattern'
+import { checkTransferIsMatchErc721Pattern } from './erc721Pattern'
+import { checkTransferIsMatchErc1155Pattern } from './erc1155Pattern'
+import type {
+  exactErc20TransfersConditionSchema,
+  exactErc721TransfersConditionSchema,
+  exactErc1155TransfersConditionSchema,
+  exactLogsConditionSchema,
+  someErc20TransfersConditionSchema,
+  someErc721TransfersConditionSchema,
+  someErc1155TransfersConditionSchema,
+  someLogsConditionSchema,
+} from './schema'
+import type { Condition } from './type'
+
+type VerifyTxSatisfiesConditionParameters = {
+  readonly transaction: TransactionDecoded
+  readonly relatedAddresses: Set<LowerHex>
+  readonly condition: Condition
+}
+
+export const verifyTxSatisfiesCondition = ({
+  transaction,
+  relatedAddresses,
+  condition,
+}: VerifyTxSatisfiesConditionParameters): boolean => {
+  try {
+    // chainId
+    if (condition.chainId !== undefined) {
+      const chainIds = new Set(condition.chainId)
+      if (!chainIds.has(transaction.chainId)) {
+        return false
+      }
+    }
+
+    // value
+    if (
+      condition.value !== undefined &&
+      !checkValueIsBetweenBigInt({
+        value: transaction.value,
+        schema: condition.value,
+      })
+    ) {
+      return false
+    }
+
+    // related addresses
+    if (condition.related !== undefined) {
+      let someRelatedAddressSatisfies = false
+      for (const address of relatedAddresses) {
+        if (
+          checkValueIsArrayIn({
+            value: address,
+            schema: condition.related,
+            transaction,
+            relatedAddresses,
+          })
+        ) {
+          someRelatedAddressSatisfies = true
+          break
+        }
+      }
+      if (!someRelatedAddressSatisfies) {
+        return false
+      }
+    }
+
+    // from
+    if (
+      condition.from !== undefined &&
+      !checkValueIsArrayIn({
+        value: transaction.from.address,
+        schema: condition.from,
+        transaction,
+        relatedAddresses,
+      })
+    ) {
+      return false
+    }
+
+    // to
+    if (
+      condition.to !== undefined &&
+      !checkValueIsArrayIn({
+        value: transaction.to?.address ?? '',
+        schema: condition.to,
+        transaction,
+        relatedAddresses,
+      })
+    ) {
+      return false
+    }
+
+    // function id
+    if (
+      transaction.input.length < 10 ||
+      transaction.input.slice(0, 10) !== condition.function.id
+    ) {
+      return false
+    }
+
+    // function interface
+    if (
+      condition.function.interface !== undefined &&
+      condition.function.interface !== transaction.function?.interface
+    ) {
+      return false
+    }
+
+    // function args
+    if (condition.function.args !== undefined) {
+      if (transaction.function === undefined) {
+        return false
+      }
+      for (const { index, value: valueSchema } of condition.function.args) {
+        const arg = transaction.function.args[index]
+        if (typeof valueSchema === 'string') {
+          if (arg.value !== valueSchema) {
+            return false
+          }
+          continue
+        }
+        switch (valueSchema.type) {
+          case 'array-in': {
+            // array-in
+            if (
+              !checkValueIsArrayIn({
+                value: stringify(arg.value).toLowerCase(),
+                schema: valueSchema,
+                transaction,
+                relatedAddresses,
+              })
+            ) {
+              return false
+            }
+            break
+          }
+          case 'between': {
+            // between bigint
+            if (
+              !checkValueIsBetweenBigInt({
+                value: BigInt(stringify(arg.value)),
+                schema: valueSchema,
+              })
+            ) {
+              return false
+            }
+            break
+          }
+          default: {
+            // all value
+            const value = getAllValue({
+              schema: valueSchema,
+              transaction,
+              relatedAddresses,
+            })
+            if (value !== stringify(arg.value).toLowerCase()) {
+              return false
+            }
+            break
+          }
+        }
+      }
+    }
+
+    // logs
+    if (condition.logs !== undefined) {
+      switch (condition.logs.type) {
+        case 'exact': {
+          if (
+            !verifyLogsSatisfiesExactCondition({
+              logs: transaction.logs,
+              transaction,
+              relatedAddresses,
+              condition: condition.logs,
+            })
+          ) {
+            return false
+          }
+          break
+        }
+        case 'some': {
+          if (
+            !verifyLogsSatisfiesSomeCondition({
+              logs: transaction.logs,
+              transaction,
+              relatedAddresses,
+              condition: condition.logs,
+            })
+          ) {
+            return false
+          }
+          break
+        }
+      }
+    }
+
+    // erc20Transfers
+    if (condition.erc20Transfers !== undefined) {
+      switch (condition.erc20Transfers.type) {
+        case 'exact': {
+          if (
+            !verifyErc20TransfersSatisfiesExactCondition({
+              transfers: transaction.erc20Transfers,
+              transaction,
+              relatedAddresses,
+              condition: condition.erc20Transfers,
+            })
+          ) {
+            return false
+          }
+          break
+        }
+        case 'some': {
+          if (
+            !verifyErc20TransfersSatisfiesSomeCondition({
+              transfers: transaction.erc20Transfers,
+              transaction,
+              relatedAddresses,
+              condition: condition.erc20Transfers,
+            })
+          ) {
+            return false
+          }
+          break
+        }
+      }
+    }
+
+    // erc721Transfers
+    if (condition.erc721Transfers !== undefined) {
+      switch (condition.erc721Transfers.type) {
+        case 'exact': {
+          if (
+            !verifyErc721TransfersSatisfiesExactCondition({
+              transfers: transaction.erc721Transfers,
+              transaction,
+              relatedAddresses,
+              condition: condition.erc721Transfers,
+            })
+          ) {
+            return false
+          }
+          break
+        }
+        case 'some': {
+          if (
+            !verifyErc721TransfersSatisfiesSomeCondition({
+              transfers: transaction.erc721Transfers,
+              transaction,
+              relatedAddresses,
+              condition: condition.erc721Transfers,
+            })
+          ) {
+            return false
+          }
+          break
+        }
+      }
+    }
+
+    // erc1155Transfers
+    if (condition.erc1155Transfers !== undefined) {
+      switch (condition.erc1155Transfers.type) {
+        case 'exact': {
+          if (
+            !verifyErc1155TransfersSatisfiesExactCondition({
+              transfers: transaction.erc1155Transfers,
+              transaction,
+              relatedAddresses,
+              condition: condition.erc1155Transfers,
+            })
+          ) {
+            return false
+          }
+          break
+        }
+        case 'some': {
+          if (
+            !verifyErc1155TransfersSatisfiesSomeCondition({
+              transfers: transaction.erc1155Transfers,
+              transaction,
+              relatedAddresses,
+              condition: condition.erc1155Transfers,
+            })
+          ) {
+            return false
+          }
+          break
+        }
+      }
+    }
+
+    return true
+  } catch (error) {
+    console.debug(error)
+    return false
+  }
+}
+
+const verifyLogsSatisfiesExactCondition = ({
+  logs,
+  transaction,
+  relatedAddresses,
+  condition: { patterns },
+}: {
+  readonly logs: readonly Log[]
+  readonly transaction: TransactionDecoded
+  readonly relatedAddresses: Set<LowerHex>
+  readonly condition: z.infer<typeof exactLogsConditionSchema>
+}): boolean => {
+  for (const [index, pattern] of patterns.entries()) {
+    const log = logs[index]
+
+    // address
+    if (
+      pattern.address !== undefined &&
+      !checkValueIsArrayIn({
+        value: log.address,
+        schema: pattern.address,
+        transaction,
+        relatedAddresses,
+      })
+    ) {
+      return false
+    }
+
+    // signature
+    if (
+      pattern.signature !== undefined &&
+      log.topics[0] !== pattern.signature
+    ) {
+      return false
+    }
+
+    // indexed count
+    if (
+      pattern.indexedCount !== undefined &&
+      log.topics.length - 1 !== pattern.indexedCount
+    ) {
+      return false
+    }
+
+    // args
+    if (pattern.args !== undefined) {
+      for (const { index, value: valueSchema } of pattern.args) {
+        const arg = log.args === undefined ? undefined : log.args[index].value
+
+        if (typeof valueSchema === 'string') {
+          if (stringify(arg).toLowerCase() !== valueSchema) {
+            return false
+          }
+          continue
+        }
+
+        switch (valueSchema.type) {
+          case 'array-in': {
+            if (
+              !checkValueIsArrayIn({
+                value: stringify(arg).toLowerCase(),
+                schema: valueSchema,
+                transaction,
+                relatedAddresses,
+              })
+            ) {
+              return false
+            }
+            break
+          }
+          case 'between': {
+            if (
+              !checkValueIsBetweenBigInt({
+                value: BigInt(stringify(arg)),
+                schema: valueSchema,
+              })
+            ) {
+              return false
+            }
+            break
+          }
+          default: {
+            const value = getAllValue({
+              schema: valueSchema,
+              transaction,
+              relatedAddresses,
+            })
+            if (stringify(arg).toLowerCase() !== value) {
+              return false
+            }
+            break
+          }
+        }
+      }
+    }
+  }
+
+  return true
+}
+
+const verifyLogsSatisfiesSomeCondition = ({
+  logs,
+  transaction,
+  relatedAddresses,
+  condition: { patterns },
+}: {
+  readonly logs: readonly Log[]
+  readonly transaction: TransactionDecoded
+  readonly relatedAddresses: Set<LowerHex>
+  readonly condition: z.infer<typeof someLogsConditionSchema>
+}): boolean => {
+  for (const pattern of patterns) {
+    let matchCount = 0n
+    for (const log of logs) {
+      // address
+      if (
+        pattern.address !== undefined &&
+        !checkValueIsArrayIn({
+          value: log.address,
+          schema: pattern.address,
+          transaction,
+          relatedAddresses,
+        })
+      ) {
+        continue
+      }
+
+      // signature
+      if (
+        pattern.signature !== undefined &&
+        log.topics[0] !== pattern.signature
+      ) {
+        continue
+      }
+
+      // indexed count
+      if (
+        pattern.indexedCount !== undefined &&
+        log.topics.length - 1 !== pattern.indexedCount
+      ) {
+        continue
+      }
+
+      // args
+      if (pattern.args !== undefined) {
+        let unmatched = false
+        for (const { index, value: valueSchema } of pattern.args) {
+          const arg = log.args === undefined ? undefined : log.args[index].value
+
+          if (typeof valueSchema === 'string') {
+            if (stringify(arg).toLowerCase() !== valueSchema) {
+              unmatched = true
+            }
+            continue
+          }
+
+          switch (valueSchema.type) {
+            case 'array-in': {
+              if (
+                !checkValueIsArrayIn({
+                  value: stringify(arg).toLowerCase(),
+                  schema: valueSchema,
+                  transaction,
+                  relatedAddresses,
+                })
+              ) {
+                unmatched = true
+              }
+              break
+            }
+            case 'between': {
+              if (
+                !checkValueIsBetweenBigInt({
+                  value: BigInt(stringify(arg)),
+                  schema: valueSchema,
+                })
+              ) {
+                unmatched = true
+              }
+              break
+            }
+            default: {
+              const value = getAllValue({
+                schema: valueSchema,
+                transaction,
+                relatedAddresses,
+              })
+              if (stringify(arg).toLowerCase() !== value) {
+                unmatched = true
+              }
+              break
+            }
+          }
+
+          if (unmatched) {
+            break
+          }
+        }
+        if (unmatched) {
+          continue
+        }
+      }
+
+      matchCount += 1n
+    }
+
+    if (
+      !checkValueIsBetweenBigInt({
+        value: matchCount,
+        schema: pattern.count,
+      })
+    ) {
+      return false
+    }
+  }
+
+  return true
+}
+
+const verifyErc20TransfersSatisfiesExactCondition = ({
+  transfers,
+  transaction,
+  relatedAddresses,
+  condition: { patterns },
+}: {
+  readonly transfers: readonly Erc20TokenTransfer[]
+  readonly transaction: TransactionDecoded
+  readonly relatedAddresses: Set<LowerHex>
+  readonly condition: z.infer<typeof exactErc20TransfersConditionSchema>
+}): boolean => {
+  for (const [index, pattern] of patterns.entries()) {
+    const transfer = transfers[index]
+
+    const matched = checkTransferIsMatchErc20Pattern({
+      transfer,
+      schema: pattern,
+      transaction,
+      relatedAddresses,
+    })
+    if (!matched) {
+      return false
+    }
+  }
+
+  return true
+}
+
+const verifyErc20TransfersSatisfiesSomeCondition = ({
+  transfers,
+  transaction,
+  relatedAddresses,
+  condition: { patterns },
+}: {
+  readonly transfers: readonly Erc20TokenTransfer[]
+  readonly transaction: TransactionDecoded
+  readonly relatedAddresses: Set<LowerHex>
+  readonly condition: z.infer<typeof someErc20TransfersConditionSchema>
+}): boolean => {
+  for (const pattern of patterns) {
+    let matchCount = 0n
+
+    for (const transfer of transfers) {
+      const matched = checkTransferIsMatchErc20Pattern({
+        transfer,
+        schema: pattern,
+        transaction,
+        relatedAddresses,
+      })
+      if (matched) {
+        matchCount += 1n
+      }
+    }
+
+    if (
+      !checkValueIsBetweenBigInt({
+        value: matchCount,
+        schema: pattern.count,
+      })
+    ) {
+      return false
+    }
+  }
+
+  return true
+}
+
+const verifyErc721TransfersSatisfiesExactCondition = ({
+  transfers,
+  transaction,
+  relatedAddresses,
+  condition: { patterns },
+}: {
+  readonly transfers: readonly Erc721TokenTransfer[]
+  readonly transaction: TransactionDecoded
+  readonly relatedAddresses: Set<LowerHex>
+  readonly condition: z.infer<typeof exactErc721TransfersConditionSchema>
+}): boolean => {
+  for (const [index, pattern] of patterns.entries()) {
+    const transfer = transfers[index]
+
+    const matched = checkTransferIsMatchErc721Pattern({
+      transfer,
+      schema: pattern,
+      transaction,
+      relatedAddresses,
+    })
+    if (!matched) {
+      return false
+    }
+  }
+
+  return true
+}
+
+const verifyErc721TransfersSatisfiesSomeCondition = ({
+  transfers,
+  transaction,
+  relatedAddresses,
+  condition: { patterns },
+}: {
+  readonly transfers: readonly Erc721TokenTransfer[]
+  readonly transaction: TransactionDecoded
+  readonly relatedAddresses: Set<LowerHex>
+  readonly condition: z.infer<typeof someErc721TransfersConditionSchema>
+}): boolean => {
+  for (const pattern of patterns) {
+    let matchCount = 0n
+
+    for (const transfer of transfers) {
+      const matched = checkTransferIsMatchErc721Pattern({
+        transfer,
+        schema: pattern,
+        transaction,
+        relatedAddresses,
+      })
+      if (matched) {
+        matchCount += 1n
+      }
+    }
+
+    if (
+      !checkValueIsBetweenBigInt({
+        value: matchCount,
+        schema: pattern.count,
+      })
+    ) {
+      return false
+    }
+  }
+
+  return true
+}
+
+const verifyErc1155TransfersSatisfiesExactCondition = ({
+  transfers,
+  transaction,
+  relatedAddresses,
+  condition: { patterns },
+}: {
+  readonly transfers: readonly Erc1155TokenTransfer[]
+  readonly transaction: TransactionDecoded
+  readonly relatedAddresses: Set<LowerHex>
+  readonly condition: z.infer<typeof exactErc1155TransfersConditionSchema>
+}): boolean => {
+  for (const [index, pattern] of patterns.entries()) {
+    const transfer = transfers[index]
+
+    const matched = checkTransferIsMatchErc1155Pattern({
+      transfer,
+      schema: pattern,
+      transaction,
+      relatedAddresses,
+    })
+    if (!matched) {
+      return false
+    }
+  }
+
+  return true
+}
+
+const verifyErc1155TransfersSatisfiesSomeCondition = ({
+  transfers,
+  transaction,
+  relatedAddresses,
+  condition: { patterns },
+}: {
+  readonly transfers: readonly Erc1155TokenTransfer[]
+  readonly transaction: TransactionDecoded
+  readonly relatedAddresses: Set<LowerHex>
+  readonly condition: z.infer<typeof someErc1155TransfersConditionSchema>
+}): boolean => {
+  for (const pattern of patterns) {
+    let matchCount = 0n
+
+    for (const transfer of transfers) {
+      const matched = checkTransferIsMatchErc1155Pattern({
+        transfer,
+        schema: pattern,
+        transaction,
+        relatedAddresses,
+      })
+      if (matched) {
+        matchCount += 1n
+      }
+    }
+
+    if (
+      !checkValueIsBetweenBigInt({
+        value: matchCount,
+        schema: pattern.count,
+      })
+    ) {
+      return false
+    }
+  }
+
+  return true
+}