@0xtorch/evm 0.0.11 → 0.0.12

package/analyzer/json/generatorSpecificTokenTransfer.ts

@@ -1,425 +0,0 @@
-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
-      }
-    }
-  })
-}