@0xtorch/evm 0.0.74 → 0.0.76

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

@@ -0,0 +1,53 @@
+import { createBigDecimal } from '@0xtorch/big-decimal'
+import type { Transfer } from '@0xtorch/core'
+import type { z } from 'zod'
+import type { LowerHex, TransactionDecoded } from '../../../../types'
+import { createEvmAddressId } from '../../../../utils'
+import { checkTransferIsMatchErc1155Pattern } from './erc1155Pattern'
+import type { erc1155TransferGeneratorSchema } from './schema'
+
+export const generateTransfersByErc1155Transfer = ({
+  schema,
+  transaction,
+  relatedAddresses,
+}: {
+  readonly schema: z.infer<typeof erc1155TransferGeneratorSchema>
+  readonly transaction: TransactionDecoded
+  readonly relatedAddresses: Set<LowerHex>
+}): readonly Transfer[] => {
+  const transfers: Transfer[] = []
+  let currentIndex = -1
+  for (const transfer of transaction.erc1155Transfers) {
+    const matched = checkTransferIsMatchErc1155Pattern({
+      transfer,
+      schema,
+      transaction,
+      relatedAddresses,
+    })
+    if (matched) {
+      currentIndex += 1
+      if (schema.index === undefined || currentIndex === schema.index) {
+        transfers.push({
+          direction: schema.direction,
+          from: createEvmAddressId({
+            chainId: transaction.chainId,
+            address: transfer.from,
+          }),
+          to: createEvmAddressId({
+            chainId: transaction.chainId,
+            address: transfer.to,
+          }),
+          asset: transfer.token,
+          amount: createBigDecimal(transfer.value),
+        })
+      }
+      if (currentIndex === schema.index) {
+        return transfers
+      }
+    }
+  }
+  if (schema.index === undefined) {
+    return transfers
+  }
+  throw new Error('Matched ERC1155 transfer is not found')
+}

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

@@ -0,0 +1,96 @@
+import type { z } from 'zod'
+import type {
+  Erc20TokenTransfer,
+  LowerHex,
+  TransactionDecoded,
+} from '../../../../types'
+import { getAllValue } from './allValue'
+import { checkValueIsArrayIn } from './arrayIn'
+import { checkValueIsBetweenBigInt } from './betweenBigInt'
+import type { erc20TransferPatternSchema } from './schema'
+
+export const checkTransferIsMatchErc20Pattern = ({
+  transfer,
+  schema,
+  transaction,
+  relatedAddresses,
+}: {
+  readonly transfer: Erc20TokenTransfer
+  readonly schema: z.infer<typeof erc20TransferPatternSchema>
+  readonly transaction: TransactionDecoded
+  readonly relatedAddresses: Set<LowerHex>
+}): boolean => {
+  // address
+  if (
+    schema.address !== undefined &&
+    !checkValueIsArrayIn({
+      value: transfer.address,
+      schema: schema.address,
+      transaction,
+      relatedAddresses,
+    })
+  ) {
+    return false
+  }
+
+  // from
+  if (
+    schema.from !== undefined &&
+    !checkValueIsArrayIn({
+      value: transfer.from,
+      schema: schema.from,
+      transaction,
+      relatedAddresses,
+    })
+  ) {
+    return false
+  }
+
+  // to
+  if (
+    schema.to !== undefined &&
+    !checkValueIsArrayIn({
+      value: transfer.to,
+      schema: schema.to,
+      transaction,
+      relatedAddresses,
+    })
+  ) {
+    return false
+  }
+
+  // amount
+  if (schema.amount !== undefined) {
+    if (typeof schema.amount === 'string') {
+      if (transfer.value.toString() !== schema.amount) {
+        return false
+      }
+    } else {
+      switch (schema.amount.type) {
+        case 'between': {
+          if (
+            !checkValueIsBetweenBigInt({
+              value: transfer.value,
+              schema: schema.amount,
+            })
+          ) {
+            return false
+          }
+          break
+        }
+        default: {
+          const value = getAllValue({
+            schema: schema.amount,
+            transaction,
+            relatedAddresses,
+          })
+          if (transfer.value.toString() !== value) {
+            return false
+          }
+        }
+      }
+    }
+  }
+
+  return true
+}

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

@@ -0,0 +1,53 @@
+import { createBigDecimal } from '@0xtorch/big-decimal'
+import type { Transfer } from '@0xtorch/core'
+import type { z } from 'zod'
+import type { LowerHex, TransactionDecoded } from '../../../../types'
+import { createEvmAddressId } from '../../../../utils'
+import { checkTransferIsMatchErc20Pattern } from './erc20Pattern'
+import type { erc20TransferGeneratorSchema } from './schema'
+
+export const generateTransfersByErc20Transfer = ({
+  schema,
+  transaction,
+  relatedAddresses,
+}: {
+  readonly schema: z.infer<typeof erc20TransferGeneratorSchema>
+  readonly transaction: TransactionDecoded
+  readonly relatedAddresses: Set<LowerHex>
+}): readonly Transfer[] => {
+  const transfers: Transfer[] = []
+  let currentIndex = -1
+  for (const transfer of transaction.erc20Transfers) {
+    const matched = checkTransferIsMatchErc20Pattern({
+      transfer,
+      schema,
+      transaction,
+      relatedAddresses,
+    })
+    if (matched) {
+      currentIndex += 1
+      if (schema.index === undefined || currentIndex === schema.index) {
+        transfers.push({
+          direction: schema.direction,
+          from: createEvmAddressId({
+            chainId: transaction.chainId,
+            address: transfer.from,
+          }),
+          to: createEvmAddressId({
+            chainId: transaction.chainId,
+            address: transfer.to,
+          }),
+          asset: transfer.token.currency,
+          amount: createBigDecimal(transfer.value, transfer.token.decimals),
+        })
+      }
+      if (currentIndex === schema.index) {
+        return transfers
+      }
+    }
+  }
+  if (schema.index === undefined) {
+    return transfers
+  }
+  throw new Error('Matched ERC20 transfer is not found')
+}

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

@@ -0,0 +1,74 @@
+import type { z } from 'zod'
+import type {
+  Erc721TokenTransfer,
+  LowerHex,
+  TransactionDecoded,
+} from '../../../../types'
+import { getAllValue } from './allValue'
+import { checkValueIsArrayIn } from './arrayIn'
+import type { erc721TransferPatternSchema } from './schema'
+
+export const checkTransferIsMatchErc721Pattern = ({
+  transfer,
+  schema,
+  transaction,
+  relatedAddresses,
+}: {
+  readonly transfer: Erc721TokenTransfer
+  readonly schema: z.infer<typeof erc721TransferPatternSchema>
+  readonly transaction: TransactionDecoded
+  readonly relatedAddresses: Set<LowerHex>
+}): boolean => {
+  // address
+  if (
+    schema.address !== undefined &&
+    !checkValueIsArrayIn({
+      value: transfer.address,
+      schema: schema.address,
+      transaction,
+      relatedAddresses,
+    })
+  ) {
+    return false
+  }
+
+  // from
+  if (
+    schema.from !== undefined &&
+    !checkValueIsArrayIn({
+      value: transfer.from,
+      schema: schema.from,
+      transaction,
+      relatedAddresses,
+    })
+  ) {
+    return false
+  }
+
+  // to
+  if (
+    schema.to !== undefined &&
+    !checkValueIsArrayIn({
+      value: transfer.to,
+      schema: schema.to,
+      transaction,
+      relatedAddresses,
+    })
+  ) {
+    return false
+  }
+
+  // id
+  if (
+    schema.id !== undefined &&
+    getAllValue({
+      schema: schema.id,
+      transaction,
+      relatedAddresses,
+    }) !== transfer.tokenId.toString()
+  ) {
+    return false
+  }
+
+  return true
+}

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

@@ -0,0 +1,53 @@
+import { createBigDecimal } from '@0xtorch/big-decimal'
+import type { Transfer } from '@0xtorch/core'
+import type { z } from 'zod'
+import type { LowerHex, TransactionDecoded } from '../../../../types'
+import { createEvmAddressId } from '../../../../utils'
+import { checkTransferIsMatchErc721Pattern } from './erc721Pattern'
+import type { erc721TransferGeneratorSchema } from './schema'
+
+export const generateTransfersByErc721Transfer = ({
+  schema,
+  transaction,
+  relatedAddresses,
+}: {
+  readonly schema: z.infer<typeof erc721TransferGeneratorSchema>
+  readonly transaction: TransactionDecoded
+  readonly relatedAddresses: Set<LowerHex>
+}): readonly Transfer[] => {
+  const transfers: Transfer[] = []
+  let currentIndex = -1
+  for (const transfer of transaction.erc721Transfers) {
+    const matched = checkTransferIsMatchErc721Pattern({
+      transfer,
+      schema,
+      transaction,
+      relatedAddresses,
+    })
+    if (matched) {
+      currentIndex += 1
+      if (schema.index === undefined || currentIndex === schema.index) {
+        transfers.push({
+          direction: schema.direction,
+          from: createEvmAddressId({
+            chainId: transaction.chainId,
+            address: transfer.from,
+          }),
+          to: createEvmAddressId({
+            chainId: transaction.chainId,
+            address: transfer.to,
+          }),
+          asset: transfer.token,
+          amount: createBigDecimal(1n),
+        })
+      }
+      if (currentIndex === schema.index) {
+        return transfers
+      }
+    }
+  }
+  if (schema.index === undefined) {
+    return transfers
+  }
+  throw new Error('Matched ERC721 transfer is not found')
+}

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

@@ -0,0 +1,248 @@
+import type { Action, Nft } from '@0xtorch/core'
+import type { Chain } from '../../../../chain'
+import type {
+  Erc20TokenTransfer,
+  Erc721TokenTransfer,
+  Erc1155TokenTransfer,
+  LowerHex,
+  TransactionDecoded,
+} from '../../../../types'
+import { getAllValue } from './allValue'
+import { checkTransferIsMatchErc20Pattern } from './erc20Pattern'
+import { checkTransferIsMatchErc721Pattern } from './erc721Pattern'
+import { checkTransferIsMatchErc1155Pattern } from './erc1155Pattern'
+import { generateTransfers } from './transferGenerator'
+import type { Generator } from './type'
+
+type GenerateActionsParameters = {
+  readonly chain: Chain
+  readonly transaction: TransactionDecoded
+  readonly relatedAddresses: Set<LowerHex>
+  readonly generator: Generator
+  readonly source: string
+}
+
+export const generateActions = ({
+  chain,
+  transaction,
+  relatedAddresses,
+  generator,
+  source,
+}: GenerateActionsParameters): readonly Action[] => {
+  // target 取得
+  if (generator.target !== undefined) {
+    const actions: Action[] = []
+    switch (generator.target.type) {
+      case 'erc20': {
+        for (const transfer of transaction.erc20Transfers) {
+          if (
+            !checkTransferIsMatchErc20Pattern({
+              transfer,
+              schema: generator.target,
+              transaction,
+              relatedAddresses,
+            })
+          ) {
+            continue
+          }
+          actions.push(
+            generateActionsWithTarget({
+              chain,
+              transaction,
+              relatedAddresses,
+              generator,
+              source,
+              erc20Target: transfer,
+            }),
+          )
+        }
+        break
+      }
+      case 'erc721': {
+        for (const transfer of transaction.erc721Transfers) {
+          if (
+            !checkTransferIsMatchErc721Pattern({
+              transfer,
+              schema: generator.target,
+              transaction,
+              relatedAddresses,
+            })
+          ) {
+            continue
+          }
+          actions.push(
+            generateActionsWithTarget({
+              chain,
+              transaction,
+              relatedAddresses,
+              generator,
+              source,
+              erc721Target: transfer,
+            }),
+          )
+        }
+        break
+      }
+      case 'erc1155': {
+        for (const transfer of transaction.erc1155Transfers) {
+          if (
+            !checkTransferIsMatchErc1155Pattern({
+              transfer,
+              schema: generator.target,
+              transaction,
+              relatedAddresses,
+            })
+          ) {
+            continue
+          }
+          actions.push(
+            generateActionsWithTarget({
+              chain,
+              transaction,
+              relatedAddresses,
+              generator,
+              source,
+              erc1155Target: transfer,
+            }),
+          )
+        }
+        break
+      }
+    }
+    return actions
+  }
+
+  // target 未指定の場合は単一 action 生成
+  return [
+    generateActionsWithTarget({
+      chain,
+      transaction,
+      relatedAddresses,
+      generator,
+      source,
+    }),
+  ]
+}
+
+const generateActionsWithTarget = ({
+  chain,
+  transaction,
+  relatedAddresses,
+  generator,
+  source,
+  erc20Target,
+  erc721Target,
+  erc1155Target,
+}: {
+  readonly chain: Chain
+  readonly transaction: TransactionDecoded
+  readonly relatedAddresses: Set<LowerHex>
+  readonly generator: Generator
+  readonly source: string
+  readonly erc20Target?: Erc20TokenTransfer
+  readonly erc721Target?: Erc721TokenTransfer
+  readonly erc1155Target?: Erc1155TokenTransfer
+}): Action => {
+  return {
+    source,
+    order: 0,
+    type: generator.type,
+    timestamp: transaction.timestamp,
+    evidence: 'contract',
+    comment:
+      generator.comment === undefined
+        ? undefined
+        : getAllValue({
+            schema: generator.comment,
+            transaction,
+            relatedAddresses,
+          }),
+    app: transaction.to?.app ?? transaction.from.app,
+    transfers: generator.transfers.flatMap((schema) =>
+      generateTransfers({
+        schema,
+        chain,
+        transaction,
+        relatedAddresses,
+        erc20Target,
+        erc721Target,
+        erc1155Target,
+      }),
+    ),
+    crossId:
+      generator.crossId === undefined
+        ? undefined
+        : getAllValue({
+            schema: generator.crossId,
+            transaction,
+            relatedAddresses,
+          }),
+    crossType: generator.crossType,
+    loanId:
+      generator.loanId === undefined
+        ? undefined
+        : getAllValue({
+            schema: generator.loanId,
+            transaction,
+            relatedAddresses,
+          }),
+    target: generateValueTarget({
+      transaction,
+      relatedAddresses,
+      schema: generator.valueTarget,
+    }),
+  }
+}
+
+const generateValueTarget = ({
+  transaction,
+  relatedAddresses,
+  schema,
+}: {
+  readonly transaction: TransactionDecoded
+  readonly relatedAddresses: Set<LowerHex>
+  readonly schema: Generator['valueTarget']
+}): Nft | undefined => {
+  if (schema === undefined) {
+    return undefined
+  }
+
+  let currentIndex = -1
+  switch (schema.type) {
+    case 'erc721': {
+      for (const transfer of transaction.erc721Transfers) {
+        const matched = checkTransferIsMatchErc721Pattern({
+          transfer,
+          schema: schema,
+          transaction,
+          relatedAddresses,
+        })
+        if (matched) {
+          currentIndex += 1
+          if (currentIndex === schema.index) {
+            return transfer.token
+          }
+        }
+      }
+      break
+    }
+    case 'erc1155': {
+      for (const transfer of transaction.erc1155Transfers) {
+        const matched = checkTransferIsMatchErc1155Pattern({
+          transfer,
+          schema: schema,
+          transaction,
+          relatedAddresses,
+        })
+        if (matched) {
+          currentIndex += 1
+          if (currentIndex === schema.index) {
+            return transfer.token
+          }
+        }
+      }
+      break
+    }
+  }
+  throw new Error('Matched ERC721 or ERC1155 transfer is not found')
+}

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

@@ -0,0 +1,72 @@
+import {
+  type Action,
+  type Transfer,
+  checkIfActionsIsValid,
+} from '@0xtorch/core'
+import type { Chain } from '../../../../chain'
+import type { LowerHex, TransactionDecoded } from '../../../../types'
+import { generateActions } from './generateActions'
+import type { JsonAnalyzer } from './type'
+import { verifyTxSatisfiesCondition } from './verifyTxSatisfiesCondition'
+
+type CreateActionsByJsonAnalyzerParameters = {
+  readonly chain: Chain
+  readonly transaction: TransactionDecoded
+  readonly relatedAddresses: Set<LowerHex>
+  readonly accountIds: Set<string>
+  readonly jsonAnalyzers: readonly JsonAnalyzer[]
+  readonly transfers: readonly Transfer[]
+  readonly source: string
+}
+
+export const createActionsByJsonAnalyzer = ({
+  chain,
+  transaction,
+  relatedAddresses,
+  accountIds,
+  jsonAnalyzers,
+  transfers,
+  source,
+}: CreateActionsByJsonAnalyzerParameters): readonly Action[] | undefined => {
+  // JSON 毎に処理
+  for (const { condition, generators } of jsonAnalyzers) {
+    // condition に合致するか確認
+    const verified = verifyTxSatisfiesCondition({
+      transaction,
+      relatedAddresses,
+      condition,
+    })
+    if (!verified) {
+      continue
+    }
+
+    // generator 毎に action 生成
+    // action 生成中にエラーが発生した場合は catch して次の JSON Analyzer に進む
+    const actions: Action[] = []
+    try {
+      for (const generator of generators) {
+        actions.push(
+          ...generateActions({
+            chain,
+            transaction,
+            relatedAddresses,
+            source,
+            generator,
+          }),
+        )
+      }
+    } catch (error) {
+      console.debug(error)
+      continue
+    }
+
+    // validation して問題なければ action を返す
+    if (!checkIfActionsIsValid({ actions, accountIds, transfers })) {
+      continue
+    }
+    return actions
+  }
+
+  // 全ての処理で action が生成されない場合は undefined を返す
+  return undefined
+}