@0xtorch/evm 0.0.11 → 0.0.12

package/analyzer/json/components/logArgumentRaw.ts

@@ -0,0 +1,57 @@
+import type { CryptoCurrencyPrice } from '@0xtorch/core'
+import type { TransactionDecoded } from '../../../types'
+import type { LogArgumentRawComponent, Target } from '../types'
+
+type GetLogArgumentRawComponentParameters<
+  Price extends CryptoCurrencyPrice | undefined,
+> = {
+  readonly component: LogArgumentRawComponent
+  readonly transaction: TransactionDecoded<Price>
+} & Target<Price>
+
+export const getLogArgumentRawComponent = <
+  Price extends CryptoCurrencyPrice | undefined,
+>({
+  component,
+  transaction,
+  targetsLog = [],
+}: GetLogArgumentRawComponentParameters<Price>): unknown => {
+  const logs = component.target === true ? targetsLog : transaction.logs
+  const filteredLogs = logs.filter((log) => {
+    if (
+      component.signature !== undefined &&
+      component.signature !== log.log.topics[0]
+    ) {
+      return false
+    }
+    if (
+      component.indexedCount !== undefined &&
+      component.indexedCount !== log.log.topics.length - 1
+    ) {
+      return false
+    }
+    if (component.args !== undefined) {
+      for (const { index, value } of component.args) {
+        if (log.type !== 'decoded' || log.log.args.length <= index) {
+          return false
+        }
+        const argument = String(log.log.args[index].value).toLowerCase()
+        if (argument !== value) {
+          return false
+        }
+      }
+    }
+    return true
+  })
+  if (filteredLogs.length <= component.index) {
+    throw new Error('filteredLogs.length <= condition.index')
+  }
+  const log = filteredLogs[component.index]
+  if (log.type !== 'decoded') {
+    throw new Error('log is not decoded')
+  }
+  if (log.log.args.length <= component.argIndex) {
+    throw new Error('log.log.args.length <= condition.argIndex')
+  }
+  return log.log.args[component.argIndex].value
+}

package/analyzer/json/components/transfer.ts

@@ -0,0 +1,531 @@
+import type { BigDecimal } from '@0xtorch/big-decimal'
+import { createBigDecimal, plus } from '@0xtorch/big-decimal'
+import type {
+  CryptoCurrency,
+  CryptoCurrencyPrice,
+  Nft,
+  Transfer,
+} from '@0xtorch/core'
+import type { Chain } from '../../../chains'
+import type { LowerHex, TransactionDecoded } from '../../../types'
+import { isHex, toLowerHex } from '../../../types'
+import { createEvmAddressId } from '../../../utils'
+import type {
+  Target,
+  TransferComponent,
+  TransferCustomAddressComponent,
+  TransferCustomAmountComponent,
+  TransferCustomAssetComponent,
+} from '../types'
+import { getErc1155Component } from './erc1155'
+import { getErc20Component } from './erc20'
+import { getErc721Component } from './erc721'
+import { getInternalComponent } from './internal'
+import { getLogArgumentComponent } from './logArgument'
+
+type CreateTransfersByTransferComponentParameters<
+  Price extends CryptoCurrencyPrice | undefined,
+> = {
+  readonly component: TransferComponent
+  readonly transaction: TransactionDecoded<Price>
+  readonly chain: Chain
+} & Target<Price>
+
+export const createTransfersByTransferComponent = <
+  Price extends CryptoCurrencyPrice | undefined,
+>({
+  component,
+  transaction,
+  chain,
+  targetsErc20 = [],
+  targetsErc721 = [],
+  targetsErc1155 = [],
+  targetsInternal = [],
+  targetsLog = [],
+}: CreateTransfersByTransferComponentParameters<Price>): readonly Transfer[] => {
+  switch (component.type) {
+    case 'value': {
+      return [
+        {
+          from: createEvmAddressId({
+            chainId: chain.id,
+            address: toLowerHex(transaction.from),
+          }),
+          to:
+            transaction.to === null
+              ? undefined
+              : createEvmAddressId({
+                  chainId: chain.id,
+                  address: toLowerHex(transaction.to),
+                }),
+          asset: chain.nativeToken.currency,
+          amount: createBigDecimal(
+            transaction.value,
+            chain.nativeToken.decimals,
+          ),
+          price: transaction.nativeTokenPrice,
+          direction: component.direction,
+        },
+      ]
+    }
+    case 'internal': {
+      const internals = getInternalComponent({
+        component,
+        transaction,
+        targetsErc20,
+        targetsErc721,
+        targetsErc1155,
+        targetsInternal,
+        targetsLog,
+      })
+      return internals.map((internal) => ({
+        from: createEvmAddressId({
+          chainId: chain.id,
+          address: internal.from,
+        }),
+        to:
+          internal.to === undefined
+            ? undefined
+            : createEvmAddressId({
+                chainId: chain.id,
+                address: internal.to,
+              }),
+        asset: chain.nativeToken.currency,
+        amount: createBigDecimal(internal.value, chain.nativeToken.decimals),
+        price: transaction.nativeTokenPrice,
+        direction: component.direction,
+      }))
+    }
+    case 'erc20': {
+      const transfers = getErc20Component({
+        component,
+        transaction,
+        targetsErc20,
+        targetsErc721,
+        targetsErc1155,
+        targetsInternal,
+        targetsLog,
+      })
+      return transfers.map((transfer) => ({
+        from: createEvmAddressId({
+          chainId: chain.id,
+          address: transfer.from,
+        }),
+        to: createEvmAddressId({
+          chainId: chain.id,
+          address: transfer.to,
+        }),
+        asset: transfer.token.currency,
+        amount: createBigDecimal(transfer.value, transfer.token.decimals),
+        price: transfer.price,
+        direction: component.direction,
+      }))
+    }
+    case 'erc721': {
+      const transfers = getErc721Component({
+        component,
+        transaction,
+        targetsErc20,
+        targetsErc721,
+        targetsErc1155,
+        targetsInternal,
+        targetsLog,
+      })
+      return transfers.map((transfer) => ({
+        from: createEvmAddressId({
+          chainId: chain.id,
+          address: transfer.from,
+        }),
+        to: createEvmAddressId({
+          chainId: chain.id,
+          address: transfer.to,
+        }),
+        asset: transfer.nft,
+        amount: createBigDecimal(1n),
+        price: undefined,
+        direction: component.direction,
+      }))
+    }
+    case 'erc1155': {
+      const transfers = getErc1155Component({
+        component,
+        transaction,
+        targetsErc20,
+        targetsErc721,
+        targetsErc1155,
+        targetsInternal,
+        targetsLog,
+      })
+      return transfers.map((transfer) => ({
+        from: createEvmAddressId({
+          chainId: chain.id,
+          address: transfer.from,
+        }),
+        to: createEvmAddressId({
+          chainId: chain.id,
+          address: transfer.to,
+        }),
+        asset: transfer.nft,
+        amount: createBigDecimal(transfer.value),
+        price: undefined,
+        direction: component.direction,
+      }))
+    }
+    case 'custom': {
+      const from = getAddressByTransferCustomAddressComponent({
+        component: component.from,
+        transaction,
+        targetsErc20,
+        targetsErc721,
+        targetsErc1155,
+        targetsInternal,
+        targetsLog,
+      })
+      const to = getAddressByTransferCustomAddressComponent({
+        component: component.to,
+        transaction,
+        targetsErc20,
+        targetsErc721,
+        targetsErc1155,
+        targetsInternal,
+        targetsLog,
+      })
+      const asset = getAssetByTransferCustomAssetComponent({
+        component: component.asset,
+        transaction,
+        chain,
+        targetsErc20,
+        targetsErc721,
+        targetsErc1155,
+        targetsInternal,
+        targetsLog,
+      })
+      const amount = component.amount
+        .map((item) =>
+          getAmountByTransferCustomAmountComponent({
+            component: item,
+            transaction,
+            chain,
+            targetsErc20,
+            targetsErc721,
+            targetsErc1155,
+            targetsInternal,
+            targetsLog,
+          }),
+        )
+        .reduce((a, b) => plus(a, b), createBigDecimal(0n))
+      return [
+        {
+          from: createEvmAddressId({
+            chainId: chain.id,
+            address: from,
+          }),
+          to: createEvmAddressId({
+            chainId: chain.id,
+            address: to,
+          }),
+          asset,
+          amount,
+          price: getPrice(asset, transaction),
+          direction: component.direction,
+        },
+      ]
+    }
+  }
+}
+
+const getPrice = <Price extends CryptoCurrencyPrice | undefined>(
+  asset: CryptoCurrency | Nft,
+  transaction: TransactionDecoded<Price>,
+): CryptoCurrencyPrice | undefined => {
+  switch (asset.type) {
+    case 'CryptoCurrency': {
+      const transfer = transaction.erc20Transfers.find(
+        (transfer) => transfer.token.currency.id === asset.id,
+      )
+      return transfer === undefined
+        ? transaction.nativeTokenPrice
+        : transfer.price
+    }
+    case 'Nft': {
+      return undefined
+    }
+  }
+}
+
+const getAddressByTransferCustomAddressComponent = <
+  Price extends CryptoCurrencyPrice | undefined,
+>({
+  component,
+  transaction,
+  targetsErc20 = [],
+  targetsErc721 = [],
+  targetsErc1155 = [],
+  targetsInternal = [],
+  targetsLog = [],
+}: {
+  readonly component: TransferCustomAddressComponent
+  readonly transaction: TransactionDecoded<Price>
+} & Target<Price>): LowerHex => {
+  if (typeof component === 'string') {
+    return component
+  }
+  switch (component.type) {
+    case 'from': {
+      return toLowerHex(transaction.from)
+    }
+    case 'to': {
+      return transaction.to === null ? '0x' : toLowerHex(transaction.to)
+    }
+    case 'erc20': {
+      const [transfer] = getErc20Component({
+        component,
+        transaction,
+        targetsErc20,
+        targetsErc721,
+        targetsErc1155,
+        targetsInternal,
+        targetsLog,
+      })
+      switch (component.key) {
+        case 'from': {
+          return transfer.from
+        }
+        case 'to': {
+          return transfer.to
+        }
+      }
+      throw new Error('Not reachable')
+    }
+    case 'erc721': {
+      const [transfer] = getErc721Component({
+        component,
+        transaction,
+        targetsErc20,
+        targetsErc721,
+        targetsErc1155,
+        targetsInternal,
+        targetsLog,
+      })
+      switch (component.key) {
+        case 'from': {
+          return transfer.from
+        }
+        case 'to': {
+          return transfer.to
+        }
+      }
+      throw new Error('Not reachable')
+    }
+    case 'erc1155': {
+      const [transfer] = getErc1155Component({
+        component,
+        transaction,
+        targetsErc20,
+        targetsErc721,
+        targetsErc1155,
+        targetsInternal,
+        targetsLog,
+      })
+      switch (component.key) {
+        case 'from': {
+          return transfer.from
+        }
+        case 'to': {
+          return transfer.to
+        }
+      }
+      throw new Error('Not reachable')
+    }
+    case 'internal': {
+      const [internal] = getInternalComponent({
+        component,
+        transaction,
+        targetsErc20,
+        targetsErc721,
+        targetsErc1155,
+        targetsInternal,
+        targetsLog,
+      })
+      switch (component.key) {
+        case 'from': {
+          return internal.from
+        }
+        case 'to': {
+          return internal.to ?? '0x'
+        }
+      }
+      throw new Error('Not reachable')
+    }
+    case 'log': {
+      const [argument] = getLogArgumentComponent({
+        component,
+        transaction,
+        targetsLog,
+      })
+      const address = String(argument)
+      if (!isHex(address)) {
+        throw new Error(`Invalid address: ${address}`)
+      }
+      return toLowerHex(address)
+    }
+  }
+}
+
+const getAssetByTransferCustomAssetComponent = <
+  Price extends CryptoCurrencyPrice | undefined,
+>({
+  component,
+  transaction,
+  chain,
+  targetsErc20 = [],
+  targetsErc721 = [],
+  targetsErc1155 = [],
+  targetsInternal = [],
+  targetsLog = [],
+}: {
+  readonly component: TransferCustomAssetComponent
+  readonly transaction: TransactionDecoded<Price>
+  readonly chain: Chain
+} & Target<Price>): CryptoCurrency | Nft => {
+  if (typeof component === 'string' && component === 'native') {
+    return chain.nativeToken.currency
+  }
+  switch (component.type) {
+    case 'erc20': {
+      const [transfer] = getErc20Component({
+        component,
+        transaction,
+        targetsErc20,
+        targetsErc721,
+        targetsErc1155,
+        targetsInternal,
+        targetsLog,
+      })
+      return transfer.token.currency
+    }
+    case 'erc721': {
+      const [transfer] = getErc721Component({
+        component,
+        transaction,
+        targetsErc20,
+        targetsErc721,
+        targetsErc1155,
+        targetsInternal,
+        targetsLog,
+      })
+      return transfer.nft
+    }
+    case 'erc1155': {
+      const [transfer] = getErc1155Component({
+        component,
+        transaction,
+        targetsErc20,
+        targetsErc721,
+        targetsErc1155,
+        targetsInternal,
+        targetsLog,
+      })
+      return transfer.nft
+    }
+  }
+}
+
+const getAmountByTransferCustomAmountComponent = <
+  Price extends CryptoCurrencyPrice | undefined,
+>({
+  component,
+  transaction,
+  chain,
+  targetsErc20 = [],
+  targetsErc721 = [],
+  targetsErc1155 = [],
+  targetsInternal = [],
+  targetsLog = [],
+}: {
+  readonly component: TransferCustomAmountComponent
+  readonly transaction: TransactionDecoded<Price>
+  readonly chain: Chain
+} & Target<Price>): BigDecimal => {
+  const { plus, value } = component
+  if ('decimals' in value) {
+    return plus
+      ? value
+      : {
+          value: value.value * -1n,
+          decimals: value.decimals,
+        }
+  }
+  switch (value.type) {
+    case 'value': {
+      const amount = createBigDecimal(
+        transaction.value,
+        chain.nativeToken.decimals,
+      )
+      return plus
+        ? amount
+        : {
+            value: amount.value * -1n,
+            decimals: amount.decimals,
+          }
+    }
+    case 'internal': {
+      const [internal] = getInternalComponent({
+        component: value,
+        transaction,
+        targetsErc20,
+        targetsErc721,
+        targetsErc1155,
+        targetsInternal,
+        targetsLog,
+      })
+      const amount = createBigDecimal(
+        internal.value,
+        chain.nativeToken.decimals,
+      )
+      return plus
+        ? amount
+        : {
+            value: amount.value * -1n,
+            decimals: amount.decimals,
+          }
+    }
+    case 'erc20': {
+      const [transfer] = getErc20Component({
+        component: value,
+        transaction,
+        targetsErc20,
+        targetsErc721,
+        targetsErc1155,
+        targetsInternal,
+        targetsLog,
+      })
+      const amount = createBigDecimal(transfer.value, transfer.token.decimals)
+      return plus
+        ? amount
+        : {
+            value: amount.value * -1n,
+            decimals: amount.decimals,
+          }
+    }
+    case 'erc1155': {
+      const [transfer] = getErc1155Component({
+        component: value,
+        transaction,
+        targetsErc20,
+        targetsErc721,
+        targetsErc1155,
+        targetsInternal,
+        targetsLog,
+      })
+      const amount = createBigDecimal(transfer.value)
+      return plus
+        ? amount
+        : {
+            value: amount.value * -1n,
+            decimals: amount.decimals,
+          }
+    }
+  }
+  throw new Error('Not reachable')
+}

package/analyzer/json/condition/address.ts

@@ -0,0 +1,124 @@
+import type { CryptoCurrencyPrice } from '@0xtorch/core'
+import type { LowerHex, TransactionDecoded } from '../../../types'
+import { isHex, toLowerHex } from '../../../types'
+import { getErc1155RawComponent } from '../components/erc1155Raw'
+import { getErc20RawComponent } from '../components/erc20Raw'
+import { getErc721RawComponent } from '../components/erc721Raw'
+import { getInternalRawComponent } from '../components/internalRaw'
+import { getLogArgumentRawComponent } from '../components/logArgumentRaw'
+import type { AddressCondition, Target } from '../types'
+
+type GetAddressByAddressCondition<
+  Price extends CryptoCurrencyPrice | undefined,
+> = {
+  readonly condition: AddressCondition
+  readonly transaction: TransactionDecoded<Price>
+} & Target<Price>
+
+export const getAddressByAddressCondition = <
+  Price extends CryptoCurrencyPrice | undefined,
+>({
+  condition,
+  transaction,
+  targetsErc20 = [],
+  targetsErc721 = [],
+  targetsErc1155 = [],
+  targetsInternal = [],
+  targetsLog = [],
+}: GetAddressByAddressCondition<Price>): LowerHex => {
+  if (typeof condition === 'string') {
+    return condition
+  }
+  switch (condition.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 'erc20': {
+      const transfer = getErc20RawComponent({
+        component: condition,
+        transaction,
+        targetsErc20,
+      })
+      switch (condition.key) {
+        case 'from': {
+          return transfer.from
+        }
+        case 'to': {
+          return transfer.to
+        }
+      }
+      throw new Error('Not reached')
+    }
+    case 'erc721': {
+      const transfer = getErc721RawComponent({
+        component: condition,
+        transaction,
+        targetsErc721,
+      })
+      switch (condition.key) {
+        case 'from': {
+          return transfer.from
+        }
+        case 'to': {
+          return transfer.to
+        }
+      }
+      throw new Error('Not reached')
+    }
+    case 'erc1155': {
+      const transfer = getErc1155RawComponent({
+        component: condition,
+        transaction,
+        targetsErc1155,
+      })
+      switch (condition.key) {
+        case 'from': {
+          return transfer.from
+        }
+        case 'to': {
+          return transfer.to
+        }
+      }
+      throw new Error('Not reached')
+    }
+    case 'internal': {
+      const internal = getInternalRawComponent({
+        component: condition,
+        transaction,
+        targetsInternal,
+      })
+      switch (condition.key) {
+        case 'from': {
+          return toLowerHex(internal.from)
+        }
+        case 'to': {
+          if (internal.to === undefined) {
+            throw new Error(
+              'filteredInternalTransactions[condition.index].to is null',
+            )
+          }
+          return internal.to
+        }
+      }
+      throw new Error('Not reached')
+    }
+    case 'log': {
+      const argumentValue = getLogArgumentRawComponent({
+        component: condition,
+        transaction,
+        targetsLog,
+      })
+      const argument = String(argumentValue)
+      if (!isHex(argument)) {
+        throw new Error('argument is not address')
+      }
+      return toLowerHex(argument)
+    }
+  }
+}