@0xtorch/evm 0.0.11 → 0.0.13

package/analyzer/json/condition/argumentValue.ts

@@ -0,0 +1,43 @@
+import type { CryptoCurrencyPrice } from '@0xtorch/core'
+import type { TransactionDecoded } from '../../../types'
+import { toLowerHex } from '../../../types'
+import { getLogArgumentRawComponent } from '../components/logArgumentRaw'
+import type { LogArgumentValueCondition, Target } from '../types'
+
+type GetValueByLogArgumentValueConditionParameters<
+  Price extends CryptoCurrencyPrice | undefined,
+> = {
+  readonly condition: LogArgumentValueCondition
+  readonly transaction: TransactionDecoded<Price>
+} & Target<Price>
+
+export const getValueByLogArgumentValueCondition = <
+  Price extends CryptoCurrencyPrice | undefined,
+>({
+  condition,
+  transaction,
+  targetsLog = [],
+}: GetValueByLogArgumentValueConditionParameters<Price>): Lowercase<string> => {
+  if (typeof condition === 'string') {
+    return condition
+  }
+  switch (condition.type) {
+    case 'from': {
+      return toLowerHex(transaction.from)
+    }
+    case 'to': {
+      return transaction.to === null ? '' : toLowerHex(transaction.to)
+    }
+    case 'value': {
+      return transaction.value.toString() as Lowercase<string>
+    }
+    case 'log': {
+      const argumentValue = getLogArgumentRawComponent({
+        component: condition,
+        transaction,
+        targetsLog,
+      })
+      return String(argumentValue).toLowerCase() as Lowercase<string>
+    }
+  }
+}

package/analyzer/json/condition/index.ts

@@ -0,0 +1,3 @@
+export { getAddressByAddressCondition } from './address'
+export { getValueByLogArgumentValueCondition } from './argumentValue'
+export { getValueByValueCondition } from './value'

package/analyzer/json/condition/value.ts

@@ -0,0 +1,76 @@
+import type { CryptoCurrencyPrice } from '@0xtorch/core'
+import type { TransactionDecoded } from '../../../types'
+import { getErc1155RawComponent } from '../components/erc1155Raw'
+import { getErc20RawComponent } from '../components/erc20Raw'
+import { getInternalRawComponent } from '../components/internalRaw'
+import { getLogArgumentRawComponent } from '../components/logArgumentRaw'
+import type { Target, ValueCondition } from '../types'
+
+type GetValueByValueConditionParameters<
+  Price extends CryptoCurrencyPrice | undefined,
+> = {
+  readonly condition: ValueCondition
+  readonly transaction: TransactionDecoded<Price>
+} & Target<Price>
+
+export const getValueByValueCondition = <
+  Price extends CryptoCurrencyPrice | undefined,
+>({
+  condition,
+  transaction,
+  targetsErc20 = [],
+  targetsErc1155 = [],
+  targetsInternal = [],
+  targetsLog = [],
+}: GetValueByValueConditionParameters<Price>): 'plus' | bigint => {
+  if (typeof condition === 'string') {
+    return condition
+  } else if (typeof condition === 'bigint') {
+    return condition
+  }
+  switch (condition.type) {
+    case 'value': {
+      return transaction.value
+    }
+    case 'erc20': {
+      const transfer = getErc20RawComponent({
+        component: condition,
+        transaction,
+        targetsErc20,
+      })
+      return transfer.value
+    }
+    case 'erc1155': {
+      const transfer = getErc1155RawComponent({
+        component: condition,
+        transaction,
+        targetsErc1155,
+      })
+      return transfer.value
+    }
+    case 'internal': {
+      const internal = getInternalRawComponent({
+        component: condition,
+        transaction,
+        targetsInternal,
+      })
+      return internal.value
+    }
+    case 'log': {
+      const argument = getLogArgumentRawComponent({
+        component: condition,
+        transaction,
+        targetsLog,
+      })
+      if (typeof argument === 'bigint') {
+        return argument
+      } else if (typeof argument === 'number') {
+        return BigInt(Math.floor(argument))
+      } else if (typeof argument === 'string' && /^-?\d+$/.test(argument)) {
+        return BigInt(argument)
+      } else {
+        throw new TypeError('argument is not bigint')
+      }
+    }
+  }
+}