@0xtorch/evm 0.0.74 → 0.0.76

package/index.ts

@@ -81,6 +81,16 @@ export { getAddressIndexData } from './logic/getAddressIndexData'
 export { getTransactionDetail } from './logic/getTransactionDetail'
 export { analyzeTransaction } from './logic/analyzeTransaction'
 export { createActions } from './logic/analyzeTransaction/createActions'
+export {
+  analyzerSchema,
+  conditionSchema,
+  generatorSchema,
+} from './logic/analyzeTransaction/createActions/json/schema'
+export type {
+  JsonAnalyzer,
+  Condition,
+  Generator,
+} from './logic/analyzeTransaction/createActions/json/type'
 export { decodeTransaction } from './logic/analyzeTransaction/decodeTransaction'
 export {
   isEvmAccountId,

package/logic/analyzeTransaction/createActions/fail.ts

@@ -1,27 +1,23 @@
 import type { Action } from '@0xtorch/core'
+import type { LowerHex } from '../../../types'
 import type { TransactionDecoded } from '../../../types/transactionDecoded'
-import { createEvmAddressId } from '../../../utils'
 
 type CreateActionsByFailAnalyzerParameters = {
   transaction: TransactionDecoded
-  accountIds: Set<string>
+  relatedAddresses: Set<LowerHex>
   source: string
 }
 
 export const createActionsByFailAnalyzer = ({
   transaction,
-  accountIds,
+  relatedAddresses,
   source,
 }: CreateActionsByFailAnalyzerParameters): readonly Action[] | undefined => {
   if (transaction.status !== 'reverted') {
     return undefined
   }
 
-  const fromId = createEvmAddressId({
-    chainId: transaction.chainId,
-    address: transaction.from.address,
-  })
-  if (!accountIds.has(fromId)) {
+  if (!relatedAddresses.has(transaction.from.address)) {
     return undefined
   }
 

package/logic/analyzeTransaction/createActions/gas.ts

@@ -1,20 +1,21 @@
 import { createBigDecimal } from '@0xtorch/big-decimal'
 import type { Action } from '@0xtorch/core'
 import type { Chain } from '../../../chain'
+import type { LowerHex } from '../../../types'
 import type { TransactionDecoded } from '../../../types/transactionDecoded'
 import { createEvmAddressId } from '../../../utils'
 
 type CreateActionsByGasAnalyzerParameters = {
   chain: Chain
   transaction: TransactionDecoded
-  accountIds: Set<string>
+  relatedAddresses: Set<LowerHex>
   source: string
 }
 
 export const createActionsByGasAnalyzer = ({
   chain,
   transaction,
-  accountIds,
+  relatedAddresses,
   source,
 }: CreateActionsByGasAnalyzerParameters): readonly Action[] | undefined => {
   // gas fee が 0 の場合は、 undefined を返す
@@ -22,14 +23,14 @@ export const createActionsByGasAnalyzer = ({
     return undefined
   }
 
-  // from address が accountIds に含まれていない場合は、 undefined を返す
+  // from address が related addresses に含まれていない場合は、 undefined を返す
+  if (!relatedAddresses.has(transaction.from.address)) {
+    return undefined
+  }
   const fromId = createEvmAddressId({
     chainId: transaction.chainId,
     address: transaction.from.address,
   })
-  if (!accountIds.has(fromId)) {
-    return undefined
-  }
 
   // transaction gas fee から action 作成
   return [

package/logic/analyzeTransaction/createActions/general.ts

@@ -6,10 +6,10 @@ import {
 import type { TransactionDecoded } from '../../../types/transactionDecoded'
 
 type CreateActionsByGasAnalyzerParameters = {
-  transaction: TransactionDecoded
-  transfers: readonly Transfer[]
-  accountIds: Set<string>
-  source: string
+  readonly transaction: TransactionDecoded
+  readonly transfers: readonly Transfer[]
+  readonly accountIds: Set<string>
+  readonly source: string
 }
 
 export const createActionsByGeneralAnalyzer = ({

package/logic/analyzeTransaction/createActions/index.ts

@@ -1,25 +1,28 @@
 import type { Action } from '@0xtorch/core'
 import type { Chain } from '../../../chain'
+import type { LowerHex } from '../../../types'
 import type { TransactionDecoded } from '../../../types/transactionDecoded'
-import { createEvmActionSource } from '../../../utils'
+import { createEvmActionSource, createEvmAddressId } from '../../../utils'
 import { createActionsByFailAnalyzer } from './fail'
 import { createActionsByGasAnalyzer } from './gas'
 import { createActionsByGeneralAnalyzer } from './general'
+import { createActionsByJsonAnalyzer } from './json'
+import type { JsonAnalyzer } from './json/type'
 import { createActionsBySpamAnalyzer } from './spam'
 import { createTokenTransfers } from './utils/createTokenTransfers'
 
 type CreateActionsParameters = {
   chain: Chain
   transaction: TransactionDecoded
-  accountIds: Set<string>
-  // TODO
-  jsonAnalyzers: readonly unknown[]
+  relatedAddresses: Set<LowerHex>
+  jsonAnalyzers: readonly JsonAnalyzer[]
 }
 
 export const createActions = ({
   chain,
   transaction,
-  accountIds,
+  relatedAddresses,
+  jsonAnalyzers,
 }: CreateActionsParameters): readonly Action[] => {
   const actions: Action[] = []
   const source = createEvmActionSource({
@@ -31,7 +34,7 @@ export const createActions = ({
   const actionsByGasAnalyzer = createActionsByGasAnalyzer({
     chain,
     transaction,
-    accountIds,
+    relatedAddresses,
     source,
   })
   if (actionsByGasAnalyzer !== undefined) {
@@ -41,7 +44,7 @@ export const createActions = ({
   // [some] fail analyzer
   const actionsByFailAnalyzer = createActionsByFailAnalyzer({
     transaction,
-    accountIds,
+    relatedAddresses,
     source,
   })
   if (actionsByFailAnalyzer !== undefined) {
@@ -49,16 +52,41 @@ export const createActions = ({
     return resetAccountActionsOrder(actions)
   }
 
-  const transfers = createTokenTransfers({ chain, transaction, accountIds })
+  const transfers = createTokenTransfers({
+    chain,
+    transaction,
+    relatedAddresses,
+  })
+  const accountIds = new Set(
+    [...relatedAddresses].map((address) =>
+      createEvmAddressId({
+        chainId: transaction.chainId,
+        address,
+      }),
+    ),
+  )
 
-  // TODO
   // [some] json analyzer
+  const actionsByJsonAnalyzer = createActionsByJsonAnalyzer({
+    chain,
+    transaction,
+    relatedAddresses,
+    accountIds,
+    jsonAnalyzers,
+    transfers,
+    source,
+  })
+  if (actionsByJsonAnalyzer !== undefined) {
+    actions.push(...actionsByJsonAnalyzer)
+    return resetAccountActionsOrder(actions)
+  }
 
   // [some] spam analyzer
   const actionsBySpamAnalyzer = createActionsBySpamAnalyzer({
     transaction,
     transfers,
     accountIds,
+    relatedAddresses,
     source,
   })
   if (actionsBySpamAnalyzer !== undefined) {

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

@@ -0,0 +1,57 @@
+import type { z } from 'zod'
+import type { LowerHex, TransactionDecoded } from '../../../../types'
+import type { addressInSchema } from './schema'
+
+export const checkValueIsAddressIn = ({
+  value,
+  schema,
+  transaction,
+  relatedAddresses,
+}: {
+  readonly value: string
+  readonly schema: z.infer<typeof addressInSchema>
+  readonly transaction: TransactionDecoded
+  readonly relatedAddresses: Set<LowerHex>
+}): boolean => {
+  const valuesSet = getAddressInValues({
+    schema,
+    transaction,
+    relatedAddresses,
+  })
+  if (schema.not === true) {
+    return !valuesSet.has(value)
+  }
+  return valuesSet.has(value)
+}
+
+const getAddressInValues = ({
+  schema,
+  transaction,
+  relatedAddresses,
+}: {
+  readonly schema: z.infer<typeof addressInSchema>
+  readonly transaction: TransactionDecoded
+  readonly relatedAddresses: Set<LowerHex>
+}): Set<string> => {
+  const set = new Set<string>()
+
+  for (const value of schema.values) {
+    if (value === 'related') {
+      for (const address of relatedAddresses) {
+        set.add(address)
+      }
+      continue
+    }
+    if (value === 'from') {
+      set.add(transaction.from.address)
+      continue
+    }
+    if (value === 'to') {
+      set.add(transaction.to?.address ?? '')
+      continue
+    }
+    set.add(value)
+  }
+
+  return set
+}

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

@@ -0,0 +1,41 @@
+import type { z } from 'zod'
+import type { LowerHex, TransactionDecoded } from '../../../../types'
+import { getJoinValue } from './join'
+import { getMathValue } from './math'
+import type { allValueSchema } from './schema'
+import { getSimpleValue } from './simpleValue'
+import { getSliceValue } from './slice'
+
+export const getAllValue = ({
+  schema,
+  transaction,
+  relatedAddresses,
+}: {
+  readonly schema: z.infer<typeof allValueSchema>
+  readonly transaction: TransactionDecoded
+  readonly relatedAddresses: Set<LowerHex>
+}): string => {
+  if (typeof schema === 'string') {
+    // simple value
+    return getSimpleValue({ schema, transaction, relatedAddresses })
+  }
+
+  switch (schema.type) {
+    case 'math': {
+      // math value
+      return getMathValue({ schema, transaction, relatedAddresses }).toString()
+    }
+    case 'slice': {
+      // slice value
+      return getSliceValue({ schema, transaction, relatedAddresses })
+    }
+    case 'join': {
+      // join value
+      return getJoinValue({ schema, transaction, relatedAddresses })
+    }
+    default: {
+      // simple value
+      return getSimpleValue({ schema, transaction, relatedAddresses })
+    }
+  }
+}

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

@@ -0,0 +1,51 @@
+import type { z } from 'zod'
+import type { LowerHex, TransactionDecoded } from '../../../../types'
+import { getAllValue } from './allValue'
+import type { arrayInSchema } from './schema'
+
+export const checkValueIsArrayIn = ({
+  value,
+  schema,
+  transaction,
+  relatedAddresses,
+}: {
+  readonly value: string
+  readonly schema: z.infer<typeof arrayInSchema>
+  readonly transaction: TransactionDecoded
+  readonly relatedAddresses: Set<LowerHex>
+}): boolean => {
+  const valuesSet = getArrayInValues({
+    schema,
+    transaction,
+    relatedAddresses,
+  })
+  if (schema.not === true) {
+    return !valuesSet.has(value)
+  }
+  return valuesSet.has(value)
+}
+
+const getArrayInValues = ({
+  schema,
+  transaction,
+  relatedAddresses,
+}: {
+  readonly schema: z.infer<typeof arrayInSchema>
+  readonly transaction: TransactionDecoded
+  readonly relatedAddresses: Set<LowerHex>
+}): Set<string> => {
+  const set = new Set<string>()
+
+  for (const value of schema.values) {
+    // related
+    if (value === 'related') {
+      for (const address of relatedAddresses) {
+        set.add(address)
+      }
+      continue
+    }
+    // all value
+    set.add(getAllValue({ schema: value, transaction, relatedAddresses }))
+  }
+  return set
+}

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

@@ -0,0 +1,18 @@
+import type { z } from 'zod'
+import type { betweenBigIntSchema } from './schema'
+
+export const checkValueIsBetweenBigInt = ({
+  value,
+  schema,
+}: {
+  readonly value: bigint
+  readonly schema: z.infer<typeof betweenBigIntSchema>
+}): boolean => {
+  if (schema.min !== undefined && value < schema.min) {
+    return false
+  }
+  if (schema.max !== undefined && value > schema.max) {
+    return false
+  }
+  return true
+}

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

@@ -0,0 +1,166 @@
+import { createBigDecimal } from '@0xtorch/big-decimal'
+import type { CryptoCurrency, Nft, Transfer } from '@0xtorch/core'
+import type { z } from 'zod'
+import type { Chain } from '../../../../chain'
+import {
+  type LowerHex,
+  type TransactionDecoded,
+  isHex,
+  toLowerHex,
+} from '../../../../types'
+import { createEvmAddressId } from '../../../../utils'
+import { getAllValue } from './allValue'
+import { checkTransferIsMatchErc20Pattern } from './erc20Pattern'
+import { checkTransferIsMatchErc721Pattern } from './erc721Pattern'
+import { checkTransferIsMatchErc1155Pattern } from './erc1155Pattern'
+import type { customTransferGeneratorSchema } from './schema'
+
+export const generateCustomTransfer = ({
+  schema,
+  chain,
+  transaction,
+  relatedAddresses,
+}: {
+  readonly schema: z.infer<typeof customTransferGeneratorSchema>
+  readonly chain: Chain
+  readonly transaction: TransactionDecoded
+  readonly relatedAddresses: Set<LowerHex>
+}): Transfer => {
+  const fromText =
+    schema.from === undefined
+      ? undefined
+      : getAllValue({
+          schema: schema.from,
+          transaction,
+          relatedAddresses,
+        })
+  const from =
+    fromText === undefined || !isHex(fromText)
+      ? undefined
+      : createEvmAddressId({
+          chainId: transaction.chainId,
+          address: toLowerHex(fromText),
+        })
+
+  const toText =
+    schema.to === undefined
+      ? undefined
+      : getAllValue({
+          schema: schema.to,
+          transaction,
+          relatedAddresses,
+        })
+  const to =
+    toText === undefined || !isHex(toText)
+      ? undefined
+      : createEvmAddressId({
+          chainId: transaction.chainId,
+          address: toLowerHex(toText),
+        })
+
+  const { asset, decimals } = getAssetWithDecimals({
+    schema: schema.asset,
+    chain,
+    transaction,
+    relatedAddresses,
+  })
+
+  const amountText = getAllValue({
+    schema: schema.amount,
+    transaction,
+    relatedAddresses,
+  })
+  const amount = createBigDecimal(BigInt(amountText), decimals)
+
+  return {
+    direction: schema.direction,
+    from,
+    to,
+    asset,
+    amount,
+  }
+}
+
+const getAssetWithDecimals = ({
+  schema,
+  chain,
+  transaction,
+  relatedAddresses,
+}: {
+  readonly schema: z.infer<typeof customTransferGeneratorSchema>['asset']
+  readonly chain: Chain
+  readonly transaction: TransactionDecoded
+  readonly relatedAddresses: Set<LowerHex>
+}): { readonly asset: CryptoCurrency | Nft; readonly decimals: number } => {
+  switch (schema.type) {
+    case 'native': {
+      return {
+        asset: chain.nativeToken.currency,
+        decimals: chain.nativeToken.decimals,
+      }
+    }
+    case 'erc20': {
+      let currentIndex = -1
+      for (const transfer of transaction.erc20Transfers) {
+        const matched = checkTransferIsMatchErc20Pattern({
+          transfer,
+          schema,
+          transaction,
+          relatedAddresses,
+        })
+        if (matched) {
+          currentIndex += 1
+          if (currentIndex === schema.index) {
+            return {
+              asset: transfer.token.currency,
+              decimals: transfer.token.decimals,
+            }
+          }
+        }
+      }
+      throw new Error('Matched ERC20 transfer is not found')
+    }
+    case 'erc721': {
+      let currentIndex = -1
+      for (const transfer of transaction.erc721Transfers) {
+        const matched = checkTransferIsMatchErc721Pattern({
+          transfer,
+          schema,
+          transaction,
+          relatedAddresses,
+        })
+        if (matched) {
+          currentIndex += 1
+          if (currentIndex === schema.index) {
+            return {
+              asset: transfer.token,
+              decimals: 0,
+            }
+          }
+        }
+      }
+      throw new Error('Matched ERC721 transfer is not found')
+    }
+    case 'erc1155': {
+      let currentIndex = -1
+      for (const transfer of transaction.erc1155Transfers) {
+        const matched = checkTransferIsMatchErc1155Pattern({
+          transfer,
+          schema,
+          transaction,
+          relatedAddresses,
+        })
+        if (matched) {
+          currentIndex += 1
+          if (currentIndex === schema.index) {
+            return {
+              asset: transfer.token,
+              decimals: 0,
+            }
+          }
+        }
+      }
+      throw new Error('Matched ERC1155 transfer is not found')
+    }
+  }
+}

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

@@ -0,0 +1,108 @@
+import type { z } from 'zod'
+import type {
+  Erc1155TokenTransfer,
+  LowerHex,
+  TransactionDecoded,
+} from '../../../../types'
+import { getAllValue } from './allValue'
+import { checkValueIsArrayIn } from './arrayIn'
+import { checkValueIsBetweenBigInt } from './betweenBigInt'
+import type { erc1155TransferPatternSchema } from './schema'
+
+export const checkTransferIsMatchErc1155Pattern = ({
+  transfer,
+  schema,
+  transaction,
+  relatedAddresses,
+}: {
+  readonly transfer: Erc1155TokenTransfer
+  readonly schema: z.infer<typeof erc1155TransferPatternSchema>
+  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
+  }
+
+  // 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
+}