@0xtorch/evm 0.0.1

package/src/analyzer/json/generatorSpecificTokenTransfer.ts

@@ -0,0 +1,425 @@
+import { createBigDecimal } from '@0xtorch/big-decimal'
+import type {
+  ActionType,
+  CryptoCurrencyPrice,
+  NormalAction,
+} from '@0xtorch/core'
+import type { Chain } from '../../chains'
+import { createEvmAccount } from '../../creates/createEvmAccount'
+import type { EvmAccount, LowerHex, TransactionDecoded } from '../../types'
+import { isHex, toLowerHex } from '../../types'
+import type {
+  ActionGeneratorSpecificTokenTransfer,
+  ActionTransferGeneratorFromTokenTransfer,
+  ActionTransferGeneratorFromTokenTransferWithCondition,
+  TokenTransferConditionAddress,
+} from './types'
+
+export const generateActionBySpecificTokenTransferGenerator = <
+  Price extends CryptoCurrencyPrice | undefined,
+>(
+  generator: ActionGeneratorSpecificTokenTransfer,
+  chain: Chain,
+  transaction: TransactionDecoded<Price>,
+): NormalAction<ActionType, EvmAccount, Price> => {
+  const mut_transfers: NormalAction<
+    ActionType,
+    EvmAccount,
+    Price
+  >['transfers'][number][] = []
+  for (const transfer of generator.transfers) {
+    switch (transfer.type) {
+      case 'token-transfer': {
+        const actionTransfers = generateActionTransfersFromTokenTransfer(
+          chain,
+          transaction,
+          transfer,
+        )
+        mut_transfers.push(...actionTransfers)
+        break
+      }
+      case 'token-transfer-with-condition': {
+        const actionTransfers =
+          generateActionTransfersFromTokenTransferWithCondition(
+            chain,
+            transaction,
+            transfer,
+          )
+        mut_transfers.push(...actionTransfers)
+        break
+      }
+    }
+  }
+  return {
+    type: 'NormalAction',
+    action: generator.action,
+    evidence: 'contract',
+    timestamp: Number(transaction.block.timestamp) * 1000,
+    comment: generator.comment,
+    app: transaction.app,
+    transfers: mut_transfers,
+  }
+}
+
+const generateActionTransfersFromTokenTransfer = <
+  Price extends CryptoCurrencyPrice | undefined,
+>(
+  chain: Chain,
+  transaction: TransactionDecoded<Price>,
+  generator: ActionTransferGeneratorFromTokenTransfer,
+): NormalAction<ActionType, EvmAccount, Price>['transfers'][number][] => {
+  const {
+    chainId,
+    value,
+    nativeTokenPrice,
+    erc20Transfers,
+    erc721Transfers,
+    erc1155Transfers,
+    internalTransactions,
+  } = transaction
+  const { token, transferIndex, target } = generator
+
+  const getTarget = (from: LowerHex, to: LowerHex) => {
+    switch (target) {
+      case 'from': {
+        return from
+      }
+      case 'to': {
+        return to
+      }
+      case 'none': {
+        return ''
+      }
+    }
+  }
+  const getDirection = () => {
+    switch (target) {
+      case 'from': {
+        return 'out'
+      }
+      case 'to': {
+        return 'in'
+      }
+      case 'none': {
+        return 'none'
+      }
+    }
+  }
+  const direction = getDirection()
+
+  switch (token) {
+    case 'erc1155': {
+      if (transferIndex === 'any') {
+        return erc1155Transfers.map((transfer) => ({
+          target: getTarget(transfer.from, transfer.to),
+          direction,
+          from: createEvmAccount({ address: transfer.from, chainId }),
+          to: createEvmAccount({ address: transfer.to, chainId }),
+          asset: transfer.nft,
+          amount: createBigDecimal(transfer.value),
+          price: undefined as Price,
+        }))
+      } else {
+        const transfer = erc1155Transfers[transferIndex]
+        return [
+          {
+            target: getTarget(transfer.from, transfer.to),
+            direction,
+            from: createEvmAccount({ address: transfer.from, chainId }),
+            to: createEvmAccount({ address: transfer.to, chainId }),
+            asset: transfer.nft,
+            amount: createBigDecimal(transfer.value),
+            price: undefined as Price,
+          },
+        ]
+      }
+    }
+    case 'erc20': {
+      if (transferIndex === 'any') {
+        return erc20Transfers.map((transfer) => ({
+          target: getTarget(transfer.from, transfer.to),
+          direction,
+          from: createEvmAccount({ address: transfer.from, chainId }),
+          to: createEvmAccount({ address: transfer.to, chainId }),
+          asset: transfer.token.currency,
+          amount: createBigDecimal(transfer.value, transfer.token.decimals),
+          price: transfer.price,
+        }))
+      } else {
+        const transfer = erc20Transfers[transferIndex]
+        return [
+          {
+            target: getTarget(transfer.from, transfer.to),
+            direction,
+            from: createEvmAccount({ address: transfer.from, chainId }),
+            to: createEvmAccount({ address: transfer.to, chainId }),
+            asset: transfer.token.currency,
+            amount: createBigDecimal(transfer.value, transfer.token.decimals),
+            price: transfer.price,
+          },
+        ]
+      }
+    }
+    case 'erc721': {
+      if (transferIndex === 'any') {
+        return erc721Transfers.map((transfer) => ({
+          target: getTarget(transfer.from, transfer.to),
+          direction,
+          from: createEvmAccount({ address: transfer.from, chainId }),
+          to: createEvmAccount({ address: transfer.to, chainId }),
+          asset: transfer.nft,
+          amount: createBigDecimal(1n),
+          price: undefined as Price,
+        }))
+      } else {
+        const transfer = erc721Transfers[transferIndex]
+        return [
+          {
+            target: getTarget(transfer.from, transfer.to),
+            direction,
+            from: createEvmAccount({ address: transfer.from, chainId }),
+            to: createEvmAccount({ address: transfer.to, chainId }),
+            asset: transfer.nft,
+            amount: createBigDecimal(1n),
+            price: undefined as Price,
+          },
+        ]
+      }
+    }
+    case 'value': {
+      const from = toLowerHex(transaction.from)
+      const to = transaction.to === null ? '0x' : toLowerHex(transaction.to)
+      return [
+        {
+          target: getTarget(from, to),
+          direction,
+          from: createEvmAccount({ address: from, chainId }),
+          to: createEvmAccount({ address: to, chainId }),
+          asset: chain.nativeToken.currency,
+          amount: createBigDecimal(value, chain.nativeToken.decimals),
+          price: nativeTokenPrice,
+        },
+      ]
+    }
+    case 'internal': {
+      if (transferIndex === 'any') {
+        return internalTransactions.map((transfer) => ({
+          target: getTarget(transfer.from, transfer.to ?? '0x'),
+          direction,
+          from: createEvmAccount({ address: transfer.from, chainId }),
+          to: createEvmAccount({ address: transfer.to ?? '0x', chainId }),
+          asset: chain.nativeToken.currency,
+          amount: createBigDecimal(transfer.value, chain.nativeToken.decimals),
+          price: nativeTokenPrice,
+        }))
+      } else {
+        const transfer = internalTransactions[transferIndex]
+        return [
+          {
+            target: getTarget(transfer.from, transfer.to ?? '0x'),
+            direction,
+            from: createEvmAccount({ address: transfer.from, chainId }),
+            to: createEvmAccount({ address: transfer.to ?? '0x', chainId }),
+            asset: chain.nativeToken.currency,
+            amount: createBigDecimal(
+              transfer.value,
+              chain.nativeToken.decimals,
+            ),
+            price: nativeTokenPrice,
+          },
+        ]
+      }
+    }
+  }
+}
+
+const generateActionTransfersFromTokenTransferWithCondition = <
+  Price extends CryptoCurrencyPrice | undefined,
+>(
+  chain: Chain,
+  transaction: TransactionDecoded<Price>,
+  generator: ActionTransferGeneratorFromTokenTransferWithCondition,
+): NormalAction<ActionType, EvmAccount, Price>['transfers'][number][] => {
+  const {
+    chainId,
+    nativeTokenPrice,
+    erc20Transfers,
+    erc721Transfers,
+    erc1155Transfers,
+    internalTransactions,
+  } = transaction
+  const { token, conditions, target } = generator
+
+  const getTarget = (from: LowerHex, to: LowerHex) => {
+    switch (target) {
+      case 'from': {
+        return from
+      }
+      case 'to': {
+        return to
+      }
+      case 'none': {
+        return ''
+      }
+    }
+  }
+  const getDirection = () => {
+    switch (target) {
+      case 'from': {
+        return 'out'
+      }
+      case 'to': {
+        return 'in'
+      }
+      case 'none': {
+        return 'none'
+      }
+    }
+  }
+  const direction = getDirection()
+
+  switch (token) {
+    case 'erc1155': {
+      return erc1155Transfers
+        .filter((transfer) =>
+          isMatchConditions(transfer, transaction, conditions),
+        )
+        .map((transfer) => ({
+          target: getTarget(transfer.from, transfer.to),
+          direction,
+          from: createEvmAccount({ address: transfer.from, chainId }),
+          to: createEvmAccount({ address: transfer.to, chainId }),
+          asset: transfer.nft,
+          amount: createBigDecimal(transfer.value),
+          price: undefined as Price,
+        }))
+    }
+    case 'erc20': {
+      return erc20Transfers
+        .filter((transfer) =>
+          isMatchConditions(transfer, transaction, conditions),
+        )
+        .map((transfer) => ({
+          target: getTarget(transfer.from, transfer.to),
+          direction,
+          from: createEvmAccount({ address: transfer.from, chainId }),
+          to: createEvmAccount({ address: transfer.to, chainId }),
+          asset: transfer.token.currency,
+          amount: createBigDecimal(transfer.value, transfer.token.decimals),
+          price: transfer.price,
+        }))
+    }
+    case 'erc721': {
+      return erc721Transfers
+        .filter((transfer) =>
+          isMatchConditions(transfer, transaction, conditions),
+        )
+        .map((transfer) => ({
+          target: getTarget(transfer.from, transfer.to),
+          direction,
+          from: createEvmAccount({ address: transfer.from, chainId }),
+          to: createEvmAccount({ address: transfer.to, chainId }),
+          asset: transfer.nft,
+          amount: createBigDecimal(1n),
+          price: undefined as Price,
+        }))
+    }
+    case 'internal': {
+      return internalTransactions
+        .filter((transfer) =>
+          isMatchConditions(transfer, transaction, conditions),
+        )
+        .map((transfer) => ({
+          target: getTarget(transfer.from, transfer.to ?? '0x'),
+          direction,
+          from: createEvmAccount({ address: transfer.from, chainId }),
+          to: createEvmAccount({ address: transfer.to ?? '0x', chainId }),
+          asset: chain.nativeToken.currency,
+          amount: createBigDecimal(transfer.value, chain.nativeToken.decimals),
+          price: nativeTokenPrice,
+        }))
+    }
+  }
+}
+
+const isMatchConditions = <Price extends CryptoCurrencyPrice | undefined>(
+  transfer: {
+    readonly from: LowerHex
+    readonly to: LowerHex | undefined
+  },
+  transaction: TransactionDecoded<Price>,
+  conditions: readonly TokenTransferConditionAddress[],
+): boolean => {
+  const { from, to, logs } = transaction
+  const lowerFrom = toLowerHex(from)
+  const lowerTo = toLowerHex(to ?? '0x')
+
+  return conditions.every((condition) => {
+    switch (condition.condition.type) {
+      case 'from': {
+        switch (condition.type) {
+          case 'from': {
+            return transfer.from === lowerFrom
+          }
+          case 'to': {
+            return transfer.to === lowerFrom
+          }
+        }
+        return false
+      }
+      case 'to': {
+        switch (condition.type) {
+          case 'from': {
+            return transfer.from === lowerTo
+          }
+          case 'to': {
+            return transfer.to === lowerTo
+          }
+        }
+        return false
+      }
+      case 'fix-value': {
+        switch (condition.type) {
+          case 'from': {
+            return transfer.from === condition.condition.value
+          }
+          case 'to': {
+            return transfer.to === condition.condition.value
+          }
+        }
+        return false
+      }
+      case 'log': {
+        const signature = condition.condition.signature
+        const indexedCount = condition.condition.indexedCount
+        const index = condition.condition.index
+        const log = logs.filter(
+          (log) =>
+            log.log.topics[0] === signature &&
+            log.log.topics.length - 1 === indexedCount,
+        )[index]
+        if (
+          log === undefined ||
+          log.type === 'LogOriginal' ||
+          log.log.args.length <= condition.condition.argIndex
+        ) {
+          return false
+        }
+        const value = String(log.log.args[condition.condition.argIndex].value)
+        if (!isHex(value)) {
+          return false
+        }
+        const lowerValue = toLowerHex(value)
+        switch (condition.type) {
+          case 'from': {
+            return transfer.from === lowerValue
+          }
+          case 'to': {
+            return transfer.to === lowerValue
+          }
+        }
+        return false
+      }
+    }
+  })
+}

package/src/analyzer/json/index.ts

@@ -0,0 +1 @@
+export { createAnalyzeByJsonRule } from './analyze'

package/src/analyzer/json/types.ts

@@ -0,0 +1,239 @@
+import type { ActionType } from '@0xtorch/core'
+import type { LowerHex } from '../../types'
+
+// normal action 変換用の mapper object
+export type AnalyzeRule = {
+  readonly chainId: number | undefined
+  readonly from: LowerHex[] | undefined
+  readonly to: LowerHex[] | undefined
+  readonly value: 'plus' | 'zero' | undefined
+  readonly functionSignature: LowerHex
+  readonly functionInterface: string | undefined
+  readonly logsPatterns: readonly LogsPattern[]
+  readonly internalsPatterns: readonly InternalsPattern[] | undefined
+  readonly parameterMatchPatterns: readonly ParameterMatchPattern[] | undefined
+  readonly generators: readonly ActionGenerator[]
+}
+
+type ParameterMatchPattern = {
+  readonly base: ParameterBase
+  readonly compare: ParameterIndex
+}
+
+export type ParameterBase =
+  | ParameterIndexDefault
+  | ParameterIndexFunction
+  | ParameterBaseLog
+  | ParameterBaseInternal
+
+type ParameterBaseLog = {
+  readonly type: 'log'
+  readonly signature: LowerHex
+  readonly indexedCount: number
+  readonly index: number
+  readonly argIndex: number
+}
+
+type ParameterBaseInternal = {
+  readonly type: 'internal'
+  readonly index: number
+  readonly key: 'from' | 'to' | 'value'
+}
+
+export type ParameterIndex =
+  | ParameterIndexDefault
+  | ParameterIndexFunction
+  | ParameterIndexLog
+  | ParameterIndexInternal
+
+type ParameterIndexDefault = {
+  readonly type: 'from' | 'to' | 'value'
+}
+type ParameterIndexFunction = {
+  readonly type: 'function'
+  readonly argIndex: number
+}
+type ParameterIndexLog = {
+  readonly type: 'log'
+  readonly signature: LowerHex
+  readonly indexedCount: number
+  readonly index: 'some' | 'every' | number
+  readonly argIndex: number
+}
+type ParameterIndexInternal = {
+  readonly type: 'internal'
+  readonly index: 'some' | 'every' | number
+  readonly key: 'from' | 'to' | 'value'
+}
+
+type LogsPattern = LogsPatternExact | LogsPatternPartial
+type LogsPatternExact = {
+  readonly matchType: 'exact'
+  readonly items: readonly {
+    readonly signature: LowerHex
+    readonly indexedCount: number
+    readonly args:
+      | readonly {
+          readonly type: 'to-lower-string-value'
+          readonly index: number
+          readonly value: string
+        }[]
+      | undefined
+    // TODO 別の log と同一の値か、みたいなところも理想としては条件として渡したい
+  }[]
+}
+type LogsPatternPartial = {
+  readonly matchType: 'partial'
+  readonly signature: LowerHex
+  readonly indexedCount: number
+  /** undefined の場合は 1つ以上の任意の数の一致する log を持つ */
+  readonly logCount: number | undefined
+  readonly args:
+    | readonly {
+        readonly type: 'to-lower-string-value'
+        readonly index: number
+        readonly value: string
+      }[]
+    | undefined
+  // TODO 別の log と同一の値か、みたいなところも理想としては条件として渡したい
+}
+
+type InternalsPattern = InternalsPatternPartial
+
+type InternalsPatternPartial = {
+  readonly type: 'partial'
+  readonly from: LowerHex | undefined
+  readonly to: LowerHex | undefined
+  readonly value: 'plus' | 'zero' | undefined
+  /** undefined の場合は 1つ以上の任意の数の一致する internal transaction を持つ */
+  readonly count: number | undefined
+}
+
+// 一旦 token transfer の index 指定で生成できるようにするが、後から他の方法でも生成できるようにする
+type ActionGenerator =
+  | ActionGeneratorAnyTokenTransfer
+  | ActionGeneratorAnyLog
+  | ActionGeneratorSpecificTokenTransfer
+
+/** 指定した token type の 全ての token transfer を個別に指定した action として生成する generator */
+export type ActionGeneratorAnyTokenTransfer = {
+  readonly type: 'any-token-transfer'
+  readonly token: 'erc20' | 'erc721' | 'erc1155'
+  readonly action: ActionType
+  readonly comment: string | undefined
+  readonly target: 'from' | 'to' | 'none'
+}
+
+/** 指定した全ての log を個別に指定した action として生成する generator */
+export type ActionGeneratorAnyLog = {
+  readonly type: 'any-log'
+  readonly action: ActionType
+  readonly comment: string | undefined
+  readonly target: 'from' | 'to' | 'none'
+  readonly signature: LowerHex
+  readonly indexedCount: number
+  readonly token: ActionGeneratorAnyLogToken
+  readonly from: ActionGeneratorAnyLogAddress
+  readonly to: ActionGeneratorAnyLogAddress
+  readonly amount: ActionGeneratorAnyLogAmount
+}
+
+type ActionGeneratorAnyLogToken = ActionGeneratorAnyLogTokenNative
+
+type ActionGeneratorAnyLogTokenNative = {
+  readonly token: 'native'
+}
+
+export type ActionGeneratorAnyLogAddress =
+  | ActionGeneratorAnyLogAddressDefault
+  | ActionGeneratorAnyLogAddressFixValue
+  | ActionGeneratorAnyLogAddressTarget
+  | ActionGeneratorAnyLogAddressLog
+
+type ActionGeneratorAnyLogAddressDefault = {
+  readonly type: 'from' | 'to'
+}
+
+type ActionGeneratorAnyLogAddressFixValue = {
+  readonly type: 'fix-value'
+  readonly value: LowerHex
+}
+
+type ActionGeneratorAnyLogAddressTarget = {
+  readonly type: 'target'
+  readonly argIndex: number
+}
+
+type ActionGeneratorAnyLogAddressLog = {
+  readonly type: 'log'
+  readonly signature: LowerHex
+  readonly indexedCount: number
+  readonly index: number
+  readonly argIndex: number
+}
+
+export type ActionGeneratorAnyLogAmount =
+  | ActionGeneratorAnyLogAmountDefault
+  | ActionGeneratorAnyLogAmountFixValue
+  | ActionGeneratorAnyLogAmountTarget
+  | ActionGeneratorAnyLogAmountLog
+
+type ActionGeneratorAnyLogAmountDefault = {
+  readonly type: 'value'
+}
+
+type ActionGeneratorAnyLogAmountFixValue = {
+  readonly type: 'fix-value'
+  readonly value: bigint
+}
+
+type ActionGeneratorAnyLogAmountTarget = {
+  readonly type: 'target'
+  readonly argIndex: number
+}
+
+type ActionGeneratorAnyLogAmountLog = {
+  readonly type: 'log'
+  readonly signature: LowerHex
+  readonly indexedCount: number
+  readonly index: number
+  readonly argIndex: number
+}
+
+/** 個別の token transfer 毎に指定した action を生成する generator */
+export type ActionGeneratorSpecificTokenTransfer = {
+  readonly type: 'specific-token-transfer'
+  readonly action: ActionType
+  readonly comment: string | undefined
+  readonly transfers: readonly ActionTransferGenerator[]
+}
+
+type ActionTransferGenerator =
+  | ActionTransferGeneratorFromTokenTransfer
+  | ActionTransferGeneratorFromTokenTransferWithCondition
+
+export type ActionTransferGeneratorFromTokenTransfer = {
+  readonly type: 'token-transfer'
+  readonly token: 'erc20' | 'erc721' | 'erc1155' | 'value' | 'internal'
+  readonly transferIndex: 'any' | number
+  readonly target: 'from' | 'to' | 'none'
+}
+
+export type ActionTransferGeneratorFromTokenTransferWithCondition = {
+  readonly type: 'token-transfer-with-condition'
+  readonly token: 'erc20' | 'erc721' | 'erc1155' | 'internal'
+  readonly conditions: readonly TokenTransferCondition[]
+  readonly target: 'from' | 'to' | 'none'
+}
+
+type TokenTransferCondition = TokenTransferConditionAddress
+
+export type TokenTransferConditionAddress = {
+  readonly type: 'from' | 'to'
+  readonly condition: ConditionAddress
+}
+
+type ConditionAddress =
+  | ActionGeneratorAnyLogAddressDefault
+  | ActionGeneratorAnyLogAddressFixValue
+  | ActionGeneratorAnyLogAddressLog