@0xtorch/evm 0.0.1

package/src/analyzer/json/generatorAnyLog.ts

@@ -0,0 +1,207 @@
+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,
+  LogData,
+  LowerHex,
+  TransactionDecoded,
+} from '../../types'
+import { isHex, toLowerHex } from '../../types'
+import type {
+  ActionGeneratorAnyLog,
+  ActionGeneratorAnyLogAddress,
+  ActionGeneratorAnyLogAmount,
+} from './types'
+
+export const generateActionsByAnyLogGenerator = <
+  Price extends CryptoCurrencyPrice | undefined,
+>(
+  generator: ActionGeneratorAnyLog,
+  chain: Chain,
+  transaction: TransactionDecoded<Price>,
+): NormalAction<ActionType, EvmAccount, Price>[] => {
+  const { chainId, block, app, nativeTokenPrice, logs } = transaction
+
+  const getTarget = (from: LowerHex, to: LowerHex) => {
+    switch (generator.target) {
+      case 'from': {
+        return from
+      }
+      case 'to': {
+        return to
+      }
+      case 'none': {
+        return ''
+      }
+    }
+  }
+  const getDirection = () => {
+    switch (generator.target) {
+      case 'from': {
+        return 'out'
+      }
+      case 'to': {
+        return 'in'
+      }
+      case 'none': {
+        return 'none'
+      }
+    }
+  }
+  const direction = getDirection()
+
+  const targetLogs = logs.filter(
+    (log) =>
+      log.log.topics[0] === generator.signature &&
+      log.log.topics.length - 1 === generator.indexedCount,
+  )
+
+  switch (generator.token.token) {
+    case 'native': {
+      return targetLogs.map((log) => {
+        const from = getAddress(generator.from, log, transaction)
+        const to = getAddress(generator.to, log, transaction)
+        return {
+          type: 'NormalAction',
+          action: generator.action,
+          evidence: 'contract',
+          timestamp: Number(block.timestamp) * 1000,
+          comment: generator.comment,
+          app,
+          transfers: [
+            {
+              target: getTarget(from, to),
+              direction,
+              from: createEvmAccount({ address: from, chainId }),
+              to: createEvmAccount({ address: to, chainId }),
+              asset: chain.nativeToken.currency,
+              amount: createBigDecimal(
+                getAmount(generator.amount, log, transaction),
+                chain.nativeToken.decimals,
+              ),
+              price: nativeTokenPrice,
+            },
+          ],
+        }
+      })
+    }
+  }
+}
+
+const getAddress = <Price extends CryptoCurrencyPrice | undefined>(
+  generator: ActionGeneratorAnyLogAddress,
+  targetLog: LogData,
+  transaction: TransactionDecoded<Price>,
+): LowerHex => {
+  switch (generator.type) {
+    case 'from': {
+      return toLowerHex(transaction.from)
+    }
+    case 'to': {
+      if (transaction.to === null) {
+        throw new Error('Transaction.to is null')
+      }
+      return toLowerHex(transaction.to)
+    }
+    case 'fix-value': {
+      return generator.value
+    }
+    case 'target': {
+      if (
+        targetLog.type === 'LogOriginal' ||
+        targetLog.log.args.length <= generator.argIndex
+      ) {
+        throw new Error('Invalid target log')
+      }
+      const value = String(targetLog.log.args[generator.argIndex].value)
+      if (isHex(value)) {
+        return toLowerHex(value)
+      } else {
+        throw new Error('Invalid target log')
+      }
+    }
+    case 'log': {
+      const log = transaction.logs.filter(
+        (log) =>
+          log.log.topics[0] === generator.signature &&
+          log.log.topics.length - 1 === generator.indexedCount,
+      )[generator.index]
+      if (
+        log === undefined ||
+        log.type === 'LogOriginal' ||
+        log.log.args.length <= generator.argIndex
+      ) {
+        throw new Error('Invalid log')
+      }
+      const value = String(log.log.args[generator.argIndex].value)
+      if (isHex(value)) {
+        return toLowerHex(value)
+      } else {
+        throw new Error('Invalid log')
+      }
+    }
+  }
+}
+
+const getAmount = <Price extends CryptoCurrencyPrice | undefined>(
+  generator: ActionGeneratorAnyLogAmount,
+  targetLog: LogData,
+  transaction: TransactionDecoded<Price>,
+): bigint => {
+  switch (generator.type) {
+    case 'value': {
+      return transaction.value
+    }
+    case 'fix-value': {
+      return generator.value
+    }
+    case 'target': {
+      if (
+        targetLog.type === 'LogOriginal' ||
+        targetLog.log.args.length <= generator.argIndex
+      ) {
+        throw new Error('Invalid target log')
+      }
+      const value = targetLog.log.args[generator.argIndex].value
+      if (typeof value === 'bigint') {
+        return value
+      } else if (typeof value === 'string') {
+        return BigInt(value)
+      } else if (typeof value === 'number') {
+        return BigInt(value)
+      } else {
+        throw new TypeError('Invalid target log')
+      }
+    }
+    case 'log': {
+      const log = transaction.logs.filter(
+        (log) =>
+          log.log.topics[0] === generator.signature &&
+          log.log.topics.length - 1 === generator.indexedCount,
+      )[generator.index]
+      if (
+        log === undefined ||
+        log.type === 'LogOriginal' ||
+        log.log.args.length <= generator.argIndex
+      ) {
+        throw new Error('Invalid log')
+      }
+      const value = log.log.args[generator.argIndex].value
+      if (typeof value === 'bigint') {
+        return value
+      } else if (typeof value === 'string') {
+        return BigInt(value)
+      } else if (typeof value === 'number') {
+        return BigInt(value)
+      } else {
+        throw new TypeError('Invalid log')
+      }
+    }
+  }
+}

package/src/analyzer/json/generatorAnyTokenTransfer.ts

@@ -0,0 +1,118 @@
+import { createBigDecimal } from '@0xtorch/big-decimal'
+import type {
+  ActionType,
+  CryptoCurrencyPrice,
+  NormalAction,
+} from '@0xtorch/core'
+import { createEvmAccount } from '../../creates/createEvmAccount'
+import type { EvmAccount, LowerHex, TransactionDecoded } from '../../types'
+import type { ActionGeneratorAnyTokenTransfer } from './types'
+
+export const generateActionsByAnyTokenTransferGenerator = <
+  Price extends CryptoCurrencyPrice | undefined,
+>(
+  generator: ActionGeneratorAnyTokenTransfer,
+  transaction: TransactionDecoded<Price>,
+): NormalAction<ActionType, EvmAccount, Price>[] => {
+  const {
+    chainId,
+    block,
+    app,
+    erc20Transfers,
+    erc721Transfers,
+    erc1155Transfers,
+  } = transaction
+  const getTarget = (from: LowerHex, to: LowerHex) => {
+    switch (generator.target) {
+      case 'from': {
+        return from
+      }
+      case 'to': {
+        return to
+      }
+      case 'none': {
+        return ''
+      }
+    }
+  }
+  const getDirection = () => {
+    switch (generator.target) {
+      case 'from': {
+        return 'out'
+      }
+      case 'to': {
+        return 'in'
+      }
+      case 'none': {
+        return 'none'
+      }
+    }
+  }
+  const direction = getDirection()
+
+  switch (generator.token) {
+    case 'erc1155': {
+      return erc1155Transfers.map((transfer) => ({
+        type: 'NormalAction',
+        action: generator.action,
+        evidence: 'contract',
+        timestamp: Number(block.timestamp) * 1000,
+        comment: generator.comment,
+        app,
+        transfers: [
+          {
+            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.map((transfer) => ({
+        type: 'NormalAction',
+        action: generator.action,
+        evidence: 'contract',
+        timestamp: Number(block.timestamp) * 1000,
+        comment: generator.comment,
+        app,
+        transfers: [
+          {
+            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.map((transfer) => ({
+        type: 'NormalAction',
+        action: generator.action,
+        evidence: 'contract',
+        timestamp: Number(block.timestamp) * 1000,
+        comment: generator.comment,
+        app,
+        transfers: [
+          {
+            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,
+          },
+        ],
+      }))
+    }
+  }
+}