@0xtorch/evm 0.0.74 → 0.0.76

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

@@ -0,0 +1,339 @@
+import { createBigDecimal, toStringBigDecimal } from '@0xtorch/big-decimal'
+import { stringify } from '@0xtorch/core'
+import type { z } from 'zod'
+import type {
+  Erc20TokenTransfer,
+  Erc721TokenTransfer,
+  Erc1155TokenTransfer,
+  Log,
+  LowerHex,
+  TransactionDecoded,
+} from '../../../../types'
+import { checkValueIsAddressIn } from './addressIn'
+import { checkValueIsBetweenBigInt } from './betweenBigInt'
+import type { simpleValueSchema } from './schema'
+
+export const getSimpleValue = ({
+  schema,
+  transaction,
+  relatedAddresses,
+}: {
+  readonly schema: z.infer<typeof simpleValueSchema>
+  readonly transaction: TransactionDecoded
+  readonly relatedAddresses: Set<LowerHex>
+}): string => {
+  if (typeof schema === 'string') {
+    return schema
+  }
+
+  switch (schema.type) {
+    case 'from': {
+      return transaction.from.address
+    }
+    case 'to': {
+      return transaction.to?.address ?? ''
+    }
+    case 'value': {
+      return transaction.value.toString()
+    }
+    case 'function': {
+      return stringify(transaction.function?.args[schema.index].value) ?? ''
+    }
+    case 'log': {
+      const targetLogs: Log[] = []
+      for (const log of transaction.logs) {
+        // address
+        if (
+          schema.address !== undefined &&
+          !checkValueIsAddressIn({
+            value: log.address,
+            schema: schema.address,
+            transaction,
+            relatedAddresses,
+          })
+        ) {
+          continue
+        }
+
+        // signature
+        if (
+          schema.signature !== undefined &&
+          log.topics[0] !== schema.signature
+        ) {
+          continue
+        }
+
+        // indexedCount
+        if (
+          schema.indexedCount !== undefined &&
+          log.topics.length - 1 !== schema.indexedCount
+        ) {
+          continue
+        }
+
+        // args
+        if (schema.args !== undefined) {
+          continue
+        }
+
+        targetLogs.push(log)
+      }
+
+      const log = targetLogs[schema.index]
+      if (schema.value === 'address') {
+        return log.address
+      }
+      return log.args === undefined ? '' : stringify(log.args[schema.value])
+    }
+    case 'erc20': {
+      const targetTransfers: Erc20TokenTransfer[] = []
+      for (const transfer of transaction.erc20Transfers) {
+        // address
+        if (
+          schema.address !== undefined &&
+          !checkValueIsAddressIn({
+            value: transfer.address,
+            schema: schema.address,
+            transaction,
+            relatedAddresses,
+          })
+        ) {
+          continue
+        }
+
+        // from
+        if (
+          schema.from !== undefined &&
+          !checkValueIsAddressIn({
+            value: transfer.from,
+            schema: schema.from,
+            transaction,
+            relatedAddresses,
+          })
+        ) {
+          continue
+        }
+
+        // to
+        if (
+          schema.to !== undefined &&
+          !checkValueIsAddressIn({
+            value: transfer.to,
+            schema: schema.to,
+            transaction,
+            relatedAddresses,
+          })
+        ) {
+          continue
+        }
+
+        // amount
+        if (
+          schema.amount !== undefined &&
+          !checkValueIsBetweenBigInt({
+            value: transfer.value,
+            schema: schema.amount,
+          })
+        ) {
+          continue
+        }
+
+        targetTransfers.push(transfer)
+      }
+
+      const transfer = targetTransfers[schema.index]
+
+      switch (schema.value) {
+        case 'address': {
+          return transfer.address
+        }
+        case 'from': {
+          return transfer.from
+        }
+        case 'to': {
+          return transfer.to
+        }
+        case 'amount': {
+          return transfer.value.toString()
+        }
+        case 'amount-decimal': {
+          return toStringBigDecimal(
+            createBigDecimal(transfer.value, transfer.token.decimals),
+          )
+        }
+        case 'currency-id': {
+          return transfer.token.currency.id
+        }
+        case 'currency-name': {
+          return transfer.token.currency.name
+        }
+        case 'currency-symbol': {
+          return transfer.token.currency.symbol
+        }
+      }
+      throw new Error('Unexpected error')
+    }
+    case 'erc721': {
+      const targetTransfers: Erc721TokenTransfer[] = []
+      for (const transfer of transaction.erc721Transfers) {
+        // address
+        if (
+          schema.address !== undefined &&
+          !checkValueIsAddressIn({
+            value: transfer.address,
+            schema: schema.address,
+            transaction,
+            relatedAddresses,
+          })
+        ) {
+          continue
+        }
+
+        // from
+        if (
+          schema.from !== undefined &&
+          !checkValueIsAddressIn({
+            value: transfer.from,
+            schema: schema.from,
+            transaction,
+            relatedAddresses,
+          })
+        ) {
+          continue
+        }
+
+        // to
+        if (
+          schema.to !== undefined &&
+          !checkValueIsAddressIn({
+            value: transfer.to,
+            schema: schema.to,
+            transaction,
+            relatedAddresses,
+          })
+        ) {
+          continue
+        }
+
+        // id
+        if (schema.id !== undefined && transfer.tokenId !== schema.id) {
+          continue
+        }
+
+        targetTransfers.push(transfer)
+      }
+
+      const transfer = targetTransfers[schema.index]
+
+      switch (schema.value) {
+        case 'address': {
+          return transfer.address
+        }
+        case 'from': {
+          return transfer.from
+        }
+        case 'to': {
+          return transfer.to
+        }
+        case 'id': {
+          return transfer.tokenId.toString()
+        }
+        case 'nft-id': {
+          return transfer.token.id
+        }
+        case 'nft-name': {
+          return transfer.token.name ?? ''
+        }
+      }
+      throw new Error('Unexpected error')
+    }
+    case 'erc1155': {
+      const targetTransfers: Erc1155TokenTransfer[] = []
+      for (const transfer of transaction.erc1155Transfers) {
+        // address
+        if (
+          schema.address !== undefined &&
+          !checkValueIsAddressIn({
+            value: transfer.address,
+            schema: schema.address,
+            transaction,
+            relatedAddresses,
+          })
+        ) {
+          continue
+        }
+
+        // from
+        if (
+          schema.from !== undefined &&
+          !checkValueIsAddressIn({
+            value: transfer.from,
+            schema: schema.from,
+            transaction,
+            relatedAddresses,
+          })
+        ) {
+          continue
+        }
+
+        // to
+        if (
+          schema.to !== undefined &&
+          !checkValueIsAddressIn({
+            value: transfer.to,
+            schema: schema.to,
+            transaction,
+            relatedAddresses,
+          })
+        ) {
+          continue
+        }
+
+        // id
+        if (schema.id !== undefined && transfer.tokenId !== schema.id) {
+          continue
+        }
+
+        // amount
+        if (
+          schema.amount !== undefined &&
+          !checkValueIsBetweenBigInt({
+            value: transfer.value,
+            schema: schema.amount,
+          })
+        ) {
+          continue
+        }
+
+        targetTransfers.push(transfer)
+      }
+
+      const transfer = targetTransfers[schema.index]
+
+      switch (schema.value) {
+        case 'address': {
+          return transfer.address
+        }
+        case 'from': {
+          return transfer.from
+        }
+        case 'to': {
+          return transfer.to
+        }
+        case 'id': {
+          return transfer.tokenId.toString()
+        }
+        case 'amount': {
+          return transfer.value.toString()
+        }
+        case 'nft-id': {
+          return transfer.token.id
+        }
+        case 'nft-name': {
+          return transfer.token.name ?? ''
+        }
+      }
+      throw new Error('Unexpected error')
+    }
+  }
+}

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

@@ -0,0 +1,21 @@
+import type { z } from 'zod'
+import type { LowerHex, TransactionDecoded } from '../../../../types'
+import type { sliceValueSchema } from './schema'
+import { getSimpleValue } from './simpleValue'
+
+export const getSliceValue = ({
+  schema,
+  transaction,
+  relatedAddresses,
+}: {
+  readonly schema: z.infer<typeof sliceValueSchema>
+  readonly transaction: TransactionDecoded
+  readonly relatedAddresses: Set<LowerHex>
+}): string => {
+  const value = getSimpleValue({
+    schema: schema.value,
+    transaction,
+    relatedAddresses,
+  })
+  return value.slice(schema.start, schema.end)
+}

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

@@ -0,0 +1,220 @@
+import { createBigDecimal } from '@0xtorch/big-decimal'
+import type { Transfer } from '@0xtorch/core'
+import type { z } from 'zod'
+import type { Chain } from '../../../../chain'
+import type {
+  Erc20TokenTransfer,
+  Erc721TokenTransfer,
+  Erc1155TokenTransfer,
+  LowerHex,
+  TransactionDecoded,
+} from '../../../../types'
+import { createEvmAddressId } from '../../../../utils'
+import { getAllValue } from './allValue'
+import { checkValueIsArrayIn } from './arrayIn'
+import { checkValueIsBetweenBigInt } from './betweenBigInt'
+import { generateCustomTransfer } from './customTransferGenerator'
+import { generateTransfersByErc20Transfer } from './erc20TransferGenerator'
+import { generateTransfersByErc721Transfer } from './erc721TransferGenerator'
+import { generateTransfersByErc1155Transfer } from './erc1155TransferGenerator'
+import { generateTransfersByInternalTransactions } from './internalTransferGenerator'
+import type { transferGeneratorSchema } from './schema'
+
+export const generateTransfers = ({
+  schema,
+  chain,
+  transaction,
+  relatedAddresses,
+  erc20Target,
+  erc721Target,
+  erc1155Target,
+}: {
+  readonly schema: z.infer<typeof transferGeneratorSchema>
+  readonly chain: Chain
+  readonly transaction: TransactionDecoded
+  readonly relatedAddresses: Set<LowerHex>
+  readonly erc20Target?: Erc20TokenTransfer
+  readonly erc721Target?: Erc721TokenTransfer
+  readonly erc1155Target?: Erc1155TokenTransfer
+}): readonly Transfer[] => {
+  switch (schema.type) {
+    case 'value': {
+      // from
+      if (
+        schema.from !== undefined &&
+        !checkValueIsArrayIn({
+          value: transaction.from.address,
+          schema: schema.from,
+          transaction,
+          relatedAddresses,
+        })
+      ) {
+        return []
+      }
+
+      // to
+      if (
+        schema.to !== undefined &&
+        !checkValueIsArrayIn({
+          value: transaction.to?.address ?? '',
+          schema: schema.to,
+          transaction,
+          relatedAddresses,
+        })
+      ) {
+        return []
+      }
+
+      // value
+      if (schema.value !== undefined) {
+        if (typeof schema.value === 'string') {
+          if (transaction.value.toString() !== schema.value) {
+            return []
+          }
+        } else {
+          switch (schema.value.type) {
+            case 'between': {
+              if (
+                !checkValueIsBetweenBigInt({
+                  value: transaction.value,
+                  schema: schema.value,
+                })
+              ) {
+                return []
+              }
+              break
+            }
+            default: {
+              const value = getAllValue({
+                schema: schema.value,
+                transaction,
+                relatedAddresses,
+              })
+              if (transaction.value.toString() !== value) {
+                return []
+              }
+            }
+          }
+        }
+      }
+
+      return [
+        {
+          direction: schema.direction,
+          from: createEvmAddressId({
+            chainId: transaction.chainId,
+            address: transaction.from.address,
+          }),
+          to:
+            transaction.to === undefined
+              ? undefined
+              : createEvmAddressId({
+                  chainId: transaction.chainId,
+                  address: transaction.to.address,
+                }),
+          asset: chain.nativeToken.currency,
+          amount: createBigDecimal(
+            transaction.value,
+            chain.nativeToken.decimals,
+          ),
+        },
+      ]
+    }
+    case 'internal': {
+      return generateTransfersByInternalTransactions({
+        schema,
+        chain,
+        transaction,
+        relatedAddresses,
+      })
+    }
+    case 'erc20': {
+      return generateTransfersByErc20Transfer({
+        schema,
+        transaction,
+        relatedAddresses,
+      })
+    }
+    case 'erc721': {
+      return generateTransfersByErc721Transfer({
+        schema,
+        transaction,
+        relatedAddresses,
+      })
+    }
+    case 'erc1155': {
+      return generateTransfersByErc1155Transfer({
+        schema,
+        transaction,
+        relatedAddresses,
+      })
+    }
+    case 'target': {
+      if (erc20Target !== undefined) {
+        return [
+          {
+            direction: schema.direction,
+            from: createEvmAddressId({
+              chainId: transaction.chainId,
+              address: erc20Target.from,
+            }),
+            to: createEvmAddressId({
+              chainId: transaction.chainId,
+              address: erc20Target.to,
+            }),
+            asset: erc20Target.token.currency,
+            amount: createBigDecimal(
+              erc20Target.value,
+              erc20Target.token.decimals,
+            ),
+          },
+        ]
+      }
+      if (erc721Target !== undefined) {
+        return [
+          {
+            direction: schema.direction,
+            from: createEvmAddressId({
+              chainId: transaction.chainId,
+              address: erc721Target.from,
+            }),
+            to: createEvmAddressId({
+              chainId: transaction.chainId,
+              address: erc721Target.to,
+            }),
+            asset: erc721Target.token,
+            amount: createBigDecimal(1n),
+          },
+        ]
+      }
+      if (erc1155Target !== undefined) {
+        return [
+          {
+            direction: schema.direction,
+            from: createEvmAddressId({
+              chainId: transaction.chainId,
+              address: erc1155Target.from,
+            }),
+            to: createEvmAddressId({
+              chainId: transaction.chainId,
+              address: erc1155Target.to,
+            }),
+            asset: erc1155Target.token,
+            amount: createBigDecimal(erc1155Target.value),
+          },
+        ]
+      }
+      throw new Error('Target is not found')
+    }
+    case 'custom': {
+      return [
+        generateCustomTransfer({
+          schema,
+          chain,
+          transaction,
+          relatedAddresses,
+        }),
+      ]
+    }
+  }
+}

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

@@ -0,0 +1,8 @@
+import type { z } from 'zod'
+import type { analyzerSchema, conditionSchema, generatorSchema } from './schema'
+
+export type Condition = z.infer<typeof conditionSchema>
+
+export type Generator = z.infer<typeof generatorSchema>
+
+export type JsonAnalyzer = z.infer<typeof analyzerSchema>