@0xtorch/evm 0.0.74 → 0.0.76

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

@@ -0,0 +1,141 @@
+import { createBigDecimal } from '@0xtorch/big-decimal'
+import type { Transfer } from '@0xtorch/core'
+import type { z } from 'zod'
+import type { Chain } from '../../../../chain'
+import type {
+  InternalTransaction,
+  LowerHex,
+  TransactionDecoded,
+} from '../../../../types'
+import { createEvmAddressId } from '../../../../utils'
+import { getAllValue } from './allValue'
+import { checkValueIsArrayIn } from './arrayIn'
+import { checkValueIsBetweenBigInt } from './betweenBigInt'
+import type { internalTransferGeneratorSchema } from './schema'
+
+export const generateTransfersByInternalTransactions = ({
+  schema,
+  chain,
+  transaction,
+  relatedAddresses,
+}: {
+  readonly schema: z.infer<typeof internalTransferGeneratorSchema>
+  readonly chain: Chain
+  readonly transaction: TransactionDecoded
+  readonly relatedAddresses: Set<LowerHex>
+}): readonly Transfer[] => {
+  const transfers: Transfer[] = []
+  let currentIndex = -1
+  for (const internalTransaction of transaction.internalTransactions) {
+    const matched = checkInternalTransactionIsMatchPattern({
+      internalTransaction,
+      schema,
+      transaction,
+      relatedAddresses,
+    })
+    if (matched) {
+      currentIndex += 1
+      if (schema.index === undefined || currentIndex === schema.index) {
+        transfers.push({
+          direction: schema.direction,
+          from: createEvmAddressId({
+            chainId: transaction.chainId,
+            address: internalTransaction.from,
+          }),
+          to:
+            internalTransaction.to === undefined
+              ? undefined
+              : createEvmAddressId({
+                  chainId: transaction.chainId,
+                  address: internalTransaction.to,
+                }),
+          asset: chain.nativeToken.currency,
+          amount: createBigDecimal(
+            internalTransaction.value,
+            chain.nativeToken.decimals,
+          ),
+        })
+      }
+      if (currentIndex === schema.index) {
+        return transfers
+      }
+    }
+  }
+  if (schema.index === undefined) {
+    return transfers
+  }
+  throw new Error('Matched internal transaction is not found')
+}
+
+const checkInternalTransactionIsMatchPattern = ({
+  internalTransaction,
+  schema,
+  transaction,
+  relatedAddresses,
+}: {
+  readonly internalTransaction: InternalTransaction
+  readonly schema: z.infer<typeof internalTransferGeneratorSchema>
+  readonly transaction: TransactionDecoded
+  readonly relatedAddresses: Set<LowerHex>
+}): boolean => {
+  // from
+  if (
+    schema.from !== undefined &&
+    !checkValueIsArrayIn({
+      value: internalTransaction.from,
+      schema: schema.from,
+      transaction,
+      relatedAddresses,
+    })
+  ) {
+    return false
+  }
+
+  // to
+  if (
+    schema.to !== undefined &&
+    !checkValueIsArrayIn({
+      value: internalTransaction.to ?? '',
+      schema: schema.to,
+      transaction,
+      relatedAddresses,
+    })
+  ) {
+    return false
+  }
+
+  // value
+  if (schema.value !== undefined) {
+    if (typeof schema.value === 'string') {
+      if (internalTransaction.value.toString() !== schema.value) {
+        return false
+      }
+    } else {
+      switch (schema.value.type) {
+        case 'between': {
+          if (
+            !checkValueIsBetweenBigInt({
+              value: internalTransaction.value,
+              schema: schema.value,
+            })
+          ) {
+            return false
+          }
+          break
+        }
+        default: {
+          const value = getAllValue({
+            schema: schema.value,
+            transaction,
+            relatedAddresses,
+          })
+          if (internalTransaction.value.toString() !== value) {
+            return false
+          }
+        }
+      }
+    }
+  }
+
+  return true
+}

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

@@ -0,0 +1,54 @@
+import type { z } from 'zod'
+import type { LowerHex, TransactionDecoded } from '../../../../types'
+import { getMathValue } from './math'
+import type { joinValueSchema } from './schema'
+import { getSimpleValue } from './simpleValue'
+import { getSliceValue } from './slice'
+
+export const getJoinValue = ({
+  schema,
+  transaction,
+  relatedAddresses,
+}: {
+  readonly schema: z.infer<typeof joinValueSchema>
+  readonly transaction: TransactionDecoded
+  readonly relatedAddresses: Set<LowerHex>
+}): string => {
+  let joinValue = ''
+  for (const value of schema.values) {
+    if (typeof value === 'string') {
+      joinValue += value
+      continue
+    }
+    switch (value.type) {
+      case 'math': {
+        // math value
+        joinValue += getMathValue({
+          schema: value,
+          transaction,
+          relatedAddresses,
+        }).toString()
+        break
+      }
+      case 'slice': {
+        // slice value
+        joinValue += getSliceValue({
+          schema: value,
+          transaction,
+          relatedAddresses,
+        })
+        break
+      }
+      default: {
+        // simple value
+        joinValue += getSimpleValue({
+          schema: value,
+          transaction,
+          relatedAddresses,
+        })
+        break
+      }
+    }
+  }
+  return joinValue
+}

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

@@ -0,0 +1,96 @@
+import type { z } from 'zod'
+import type { LowerHex, TransactionDecoded } from '../../../../types'
+import type { mathValueSchema } from './schema'
+import { getSimpleValue } from './simpleValue'
+
+export const getMathValue = ({
+  schema,
+  transaction,
+  relatedAddresses,
+}: {
+  readonly schema: z.infer<typeof mathValueSchema>
+  readonly transaction: TransactionDecoded
+  readonly relatedAddresses: Set<LowerHex>
+}): bigint => {
+  const firstValue = schema.values[0]
+  let current = BigInt(
+    getSimpleValue({ schema: firstValue, transaction, relatedAddresses }),
+  )
+  let operator: '+' | '-' | '*' | '/' | undefined
+  let args: bigint[] = []
+  for (const value of schema.values.slice(1)) {
+    if (value === '+') {
+      if (operator !== undefined) {
+        current = calculate(operator, current, args)
+        args = []
+      }
+      operator = '+'
+      continue
+    }
+    if (value === '-') {
+      if (operator !== undefined) {
+        current = calculate(operator, current, args)
+        args = []
+      }
+      operator = '-'
+      continue
+    }
+    if (value === '*') {
+      if (operator !== undefined) {
+        current = calculate(operator, current, args)
+        args = []
+      }
+      operator = '*'
+      continue
+    }
+    if (value === '/') {
+      if (operator !== undefined) {
+        current = calculate(operator, current, args)
+        args = []
+      }
+      operator = '/'
+      continue
+    }
+    args.push(
+      BigInt(getSimpleValue({ schema: value, transaction, relatedAddresses })),
+    )
+  }
+  if (operator !== undefined) {
+    current = calculate(operator, current, args)
+  }
+  return current
+}
+
+const calculate = (
+  operator: '+' | '-' | '*' | '/',
+  current: bigint,
+  args: bigint[],
+): bigint => {
+  let newValue = current
+  switch (operator) {
+    case '+': {
+      for (const arg of args) {
+        newValue += arg
+      }
+      return newValue
+    }
+    case '-': {
+      for (const arg of args) {
+        newValue -= arg
+      }
+      return newValue
+    }
+    case '*': {
+      for (const arg of args) {
+        newValue *= arg
+      }
+      return newValue
+    }
+    case '/': {
+      for (const arg of args) {
+        newValue /= arg
+      }
+      return newValue
+    }
+  }
+}