@0xtorch/evm 0.0.10 → 0.0.12

package/analyzer/json/types.ts

@@ -1,239 +1,143 @@
-import type { ActionType } from '@0xtorch/core'
-import type { LowerHex } from '../../types'
+import type { CryptoCurrencyPrice } from '@0xtorch/core'
+import type { z } from 'zod'
+import type {
+  Erc1155Transfer,
+  Erc20Transfer,
+  Erc721Transfer,
+  InternalTransaction,
+  LogData,
+} from '../../types'
+import type {
+  actionGeneratorAnyLogAddressSchema,
+  actionGeneratorAnyLogAmountSchema,
+  actionGeneratorAnyLogSchema,
+  actionGeneratorAnyTokenTransferSchema,
+  actionGeneratorSpecificTokenTransferSchema,
+  actionTransferGeneratorFromTokenTransferSchema,
+  actionTransferGeneratorFromTokenTransferWithConditionSchema,
+  evmAnalyzerSchema,
+  parameterBaseSchema,
+  parameterSchema,
+  tokenTransferConditionAddressSchema,
+} from './schemas'
+import type {
+  actionGeneratorSchema,
+  addressConditionSchema,
+  commentComponentSchema,
+  erc1155ComponentSchema,
+  erc1155RawComponentSchema,
+  erc20ComponentSchema,
+  erc20RawComponentSchema,
+  erc721ComponentSchema,
+  erc721RawComponentSchema,
+  idComponentSchema,
+  internalComponentSchema,
+  internalRawComponentSchema,
+  logArgumentComponentSchema,
+  logArgumentRawComponentSchema,
+  logArgumentValueConditionSchema,
+  transferComponentSchema,
+  transferCustomAddressComponentSchema,
+  transferCustomAmountComponentSchema,
+  transferCustomAssetComponentSchema,
+  valueConditionSchema,
+} from './schemas/generator'
 
 // normal action 変換用の mapper object
-export type AnalyzeRule = {
-  readonly chainId: number | undefined
-  readonly from: LowerHex[] | undefined
-  readonly to: LowerHex[] | undefined
-  readonly value: 'plus' | 'zero' | undefined
-  readonly functionSignature: LowerHex
-  readonly functionInterface: string | undefined
-  readonly logsPatterns: readonly LogsPattern[]
-  readonly internalsPatterns: readonly InternalsPattern[] | undefined
-  readonly parameterMatchPatterns: readonly ParameterMatchPattern[] | undefined
-  readonly generators: readonly ActionGenerator[]
-}
+export type AnalyzeRule = z.infer<typeof evmAnalyzerSchema>
 
-type ParameterMatchPattern = {
-  readonly base: ParameterBase
-  readonly compare: ParameterIndex
-}
+export type ParameterBase = z.infer<typeof parameterBaseSchema>
 
-export type ParameterBase =
-  | ParameterIndexDefault
-  | ParameterIndexFunction
-  | ParameterBaseLog
-  | ParameterBaseInternal
-
-type ParameterBaseLog = {
-  readonly type: 'log'
-  readonly signature: LowerHex
-  readonly indexedCount: number
-  readonly index: number
-  readonly argIndex: number
-}
+export type ParameterIndex = z.infer<typeof parameterSchema>
 
-type ParameterBaseInternal = {
-  readonly type: 'internal'
-  readonly index: number
-  readonly key: 'from' | 'to' | 'value'
-}
+// // 一旦 token transfer の index 指定で生成できるようにするが、後から他の方法でも生成できるようにする
+export type ActionGenerator = z.infer<typeof actionGeneratorSchema>
 
-export type ParameterIndex =
-  | ParameterIndexDefault
-  | ParameterIndexFunction
-  | ParameterIndexLog
-  | ParameterIndexInternal
+/** 指定した token type の 全ての token transfer を個別に指定した action として生成する generator */
+export type ActionGeneratorAnyTokenTransfer = z.infer<
+  typeof actionGeneratorAnyTokenTransferSchema
+>
 
-type ParameterIndexDefault = {
-  readonly type: 'from' | 'to' | 'value'
-}
-type ParameterIndexFunction = {
-  readonly type: 'function'
-  readonly argIndex: number
-}
-type ParameterIndexLog = {
-  readonly type: 'log'
-  readonly signature: LowerHex
-  readonly indexedCount: number
-  readonly index: 'some' | 'every' | number
-  readonly argIndex: number
-}
-type ParameterIndexInternal = {
-  readonly type: 'internal'
-  readonly index: 'some' | 'every' | number
-  readonly key: 'from' | 'to' | 'value'
-}
+/** 指定した全ての log を個別に指定した action として生成する generator */
+export type ActionGeneratorAnyLog = z.infer<typeof actionGeneratorAnyLogSchema>
 
-type LogsPattern = LogsPatternExact | LogsPatternPartial
-type LogsPatternExact = {
-  readonly matchType: 'exact'
-  readonly items: readonly {
-    readonly signature: LowerHex
-    readonly indexedCount: number
-    readonly args:
-      | readonly {
-          readonly type: 'to-lower-string-value'
-          readonly index: number
-          readonly value: string
-        }[]
-      | undefined
-    // TODO 別の log と同一の値か、みたいなところも理想としては条件として渡したい
-  }[]
-}
-type LogsPatternPartial = {
-  readonly matchType: 'partial'
-  readonly signature: LowerHex
-  readonly indexedCount: number
-  /** undefined の場合は 1つ以上の任意の数の一致する log を持つ */
-  readonly logCount: number | undefined
-  readonly args:
-    | readonly {
-        readonly type: 'to-lower-string-value'
-        readonly index: number
-        readonly value: string
-      }[]
-    | undefined
-  // TODO 別の log と同一の値か、みたいなところも理想としては条件として渡したい
-}
+export type ActionGeneratorAnyLogAddress = z.infer<
+  typeof actionGeneratorAnyLogAddressSchema
+>
 
-type InternalsPattern = InternalsPatternPartial
+export type ActionGeneratorAnyLogAmount = z.infer<
+  typeof actionGeneratorAnyLogAmountSchema
+>
 
-type InternalsPatternPartial = {
-  readonly type: 'partial'
-  readonly from: LowerHex | undefined
-  readonly to: LowerHex | undefined
-  readonly value: 'plus' | 'zero' | undefined
-  /** undefined の場合は 1つ以上の任意の数の一致する internal transaction を持つ */
-  readonly count: number | undefined
-}
+/** 個別の token transfer 毎に指定した action を生成する generator */
+export type ActionGeneratorSpecificTokenTransfer = z.infer<
+  typeof actionGeneratorSpecificTokenTransferSchema
+>
 
-// 一旦 token transfer の index 指定で生成できるようにするが、後から他の方法でも生成できるようにする
-type ActionGenerator =
-  | ActionGeneratorAnyTokenTransfer
-  | ActionGeneratorAnyLog
-  | ActionGeneratorSpecificTokenTransfer
+export type ActionTransferGeneratorFromTokenTransfer = z.infer<
+  typeof actionTransferGeneratorFromTokenTransferSchema
+>
 
-/** 指定した token type の 全ての token transfer を個別に指定した action として生成する generator */
-export type ActionGeneratorAnyTokenTransfer = {
-  readonly type: 'any-token-transfer'
-  readonly token: 'erc20' | 'erc721' | 'erc1155'
-  readonly action: ActionType
-  readonly comment: string | undefined
-  readonly target: 'from' | 'to' | 'none'
-}
+export type ActionTransferGeneratorFromTokenTransferWithCondition = z.infer<
+  typeof actionTransferGeneratorFromTokenTransferWithConditionSchema
+>
 
-/** 指定した全ての log を個別に指定した action として生成する generator */
-export type ActionGeneratorAnyLog = {
-  readonly type: 'any-log'
-  readonly action: ActionType
-  readonly comment: string | undefined
-  readonly target: 'from' | 'to' | 'none'
-  readonly signature: LowerHex
-  readonly indexedCount: number
-  readonly token: ActionGeneratorAnyLogToken
-  readonly from: ActionGeneratorAnyLogAddress
-  readonly to: ActionGeneratorAnyLogAddress
-  readonly amount: ActionGeneratorAnyLogAmount
-}
+export type TokenTransferConditionAddress = z.infer<
+  typeof tokenTransferConditionAddressSchema
+>
 
-type ActionGeneratorAnyLogToken = ActionGeneratorAnyLogTokenNative
+export type LogArgumentRawComponent = z.infer<
+  typeof logArgumentRawComponentSchema
+>
 
-type ActionGeneratorAnyLogTokenNative = {
-  readonly token: 'native'
-}
+export type Erc20RawComponent = z.infer<typeof erc20RawComponentSchema>
 
-export type ActionGeneratorAnyLogAddress =
-  | ActionGeneratorAnyLogAddressDefault
-  | ActionGeneratorAnyLogAddressFixValue
-  | ActionGeneratorAnyLogAddressTarget
-  | ActionGeneratorAnyLogAddressLog
+export type Erc721RawComponent = z.infer<typeof erc721RawComponentSchema>
 
-type ActionGeneratorAnyLogAddressDefault = {
-  readonly type: 'from' | 'to'
-}
+export type Erc1155RawComponent = z.infer<typeof erc1155RawComponentSchema>
 
-type ActionGeneratorAnyLogAddressFixValue = {
-  readonly type: 'fix-value'
-  readonly value: LowerHex
-}
+export type InternalRawComponent = z.infer<typeof internalRawComponentSchema>
 
-type ActionGeneratorAnyLogAddressTarget = {
-  readonly type: 'target'
-  readonly argIndex: number
-}
+export type LogArgumentComponent = z.infer<typeof logArgumentComponentSchema>
 
-type ActionGeneratorAnyLogAddressLog = {
-  readonly type: 'log'
-  readonly signature: LowerHex
-  readonly indexedCount: number
-  readonly index: number
-  readonly argIndex: number
-}
+export type Erc20Component = z.infer<typeof erc20ComponentSchema>
 
-export type ActionGeneratorAnyLogAmount =
-  | ActionGeneratorAnyLogAmountDefault
-  | ActionGeneratorAnyLogAmountFixValue
-  | ActionGeneratorAnyLogAmountTarget
-  | ActionGeneratorAnyLogAmountLog
+export type Erc721Component = z.infer<typeof erc721ComponentSchema>
 
-type ActionGeneratorAnyLogAmountDefault = {
-  readonly type: 'value'
-}
+export type Erc1155Component = z.infer<typeof erc1155ComponentSchema>
 
-type ActionGeneratorAnyLogAmountFixValue = {
-  readonly type: 'fix-value'
-  readonly value: bigint
-}
+export type InternalComponent = z.infer<typeof internalComponentSchema>
 
-type ActionGeneratorAnyLogAmountTarget = {
-  readonly type: 'target'
-  readonly argIndex: number
-}
+export type CommentComponent = z.infer<typeof commentComponentSchema>
 
-type ActionGeneratorAnyLogAmountLog = {
-  readonly type: 'log'
-  readonly signature: LowerHex
-  readonly indexedCount: number
-  readonly index: number
-  readonly argIndex: number
-}
+export type IdComponent = z.infer<typeof idComponentSchema>
 
-/** 個別の token transfer 毎に指定した action を生成する generator */
-export type ActionGeneratorSpecificTokenTransfer = {
-  readonly type: 'specific-token-transfer'
-  readonly action: ActionType
-  readonly comment: string | undefined
-  readonly transfers: readonly ActionTransferGenerator[]
-}
+export type AddressCondition = z.infer<typeof addressConditionSchema>
 
-type ActionTransferGenerator =
-  | ActionTransferGeneratorFromTokenTransfer
-  | ActionTransferGeneratorFromTokenTransferWithCondition
+export type ValueCondition = z.infer<typeof valueConditionSchema>
 
-export type ActionTransferGeneratorFromTokenTransfer = {
-  readonly type: 'token-transfer'
-  readonly token: 'erc20' | 'erc721' | 'erc1155' | 'value' | 'internal'
-  readonly transferIndex: 'any' | number
-  readonly target: 'from' | 'to' | 'none'
-}
+export type LogArgumentValueCondition = z.infer<
+  typeof logArgumentValueConditionSchema
+>
 
-export type ActionTransferGeneratorFromTokenTransferWithCondition = {
-  readonly type: 'token-transfer-with-condition'
-  readonly token: 'erc20' | 'erc721' | 'erc1155' | 'internal'
-  readonly conditions: readonly TokenTransferCondition[]
-  readonly target: 'from' | 'to' | 'none'
-}
+export type TransferCustomAddressComponent = z.infer<
+  typeof transferCustomAddressComponentSchema
+>
 
-type TokenTransferCondition = TokenTransferConditionAddress
+export type TransferCustomAssetComponent = z.infer<
+  typeof transferCustomAssetComponentSchema
+>
 
-export type TokenTransferConditionAddress = {
-  readonly type: 'from' | 'to'
-  readonly condition: ConditionAddress
-}
+export type TransferCustomAmountComponent = z.infer<
+  typeof transferCustomAmountComponentSchema
+>
 
-type ConditionAddress =
-  | ActionGeneratorAnyLogAddressDefault
-  | ActionGeneratorAnyLogAddressFixValue
-  | ActionGeneratorAnyLogAddressLog
+export type TransferComponent = z.infer<typeof transferComponentSchema>
+
+export type Target<Price extends CryptoCurrencyPrice | undefined> = {
+  readonly targetsErc20?: readonly Erc20Transfer<Price>[]
+  readonly targetsErc721?: readonly Erc721Transfer[]
+  readonly targetsErc1155?: readonly Erc1155Transfer[]
+  readonly targetsInternal?: readonly InternalTransaction<Price>[]
+  readonly targetsLog?: readonly LogData[]
+}

package/analyzer/parsers/transfer.ts

@@ -0,0 +1,301 @@
+import { createBigDecimal } from '@0xtorch/big-decimal'
+import type {
+  CryptoCurrencyPrice,
+  TransferCryptoCurrencyIn,
+  TransferCryptoCurrencyNone,
+  TransferCryptoCurrencyOut,
+  TransferNftIn,
+  TransferNftNone,
+  TransferNftOut,
+} from '@0xtorch/core'
+import type { Chain } from '../../chains'
+import type {
+  Erc1155Transfer,
+  Erc20Transfer,
+  Erc721Transfer,
+  InternalTransaction,
+  TransactionDecoded,
+} from '../../types'
+import { toLowerHex } from '../../types'
+import { createEvmAddressId } from '../../utils'
+
+type ParseTransactionValueToActionTransferParameters = {
+  readonly chain: Chain
+  readonly transaction: TransactionDecoded<CryptoCurrencyPrice | undefined>
+}
+
+const parseTransactionValueToActionTransfer = ({
+  chain,
+  transaction: { from, to, value, nativeTokenPrice },
+}: ParseTransactionValueToActionTransferParameters): Omit<
+  | TransferCryptoCurrencyIn
+  | TransferCryptoCurrencyOut
+  | TransferCryptoCurrencyNone,
+  'direction'
+> => ({
+  from: createEvmAddressId({
+    chainId: chain.id,
+    address: toLowerHex(from),
+  }),
+  to: createEvmAddressId({
+    chainId: chain.id,
+    address: to === null ? '0x' : toLowerHex(to),
+  }),
+  price: nativeTokenPrice,
+  asset: chain.nativeToken.currency,
+  amount: createBigDecimal(value, chain.nativeToken.decimals),
+})
+
+export const parseTransactionValueToActionTransferIn = ({
+  chain,
+  transaction,
+}: ParseTransactionValueToActionTransferParameters): TransferCryptoCurrencyIn => ({
+  ...parseTransactionValueToActionTransfer({ chain, transaction }),
+  direction: 'in',
+})
+
+export const parseTransactionValueToActionTransferOut = ({
+  chain,
+  transaction,
+}: ParseTransactionValueToActionTransferParameters): TransferCryptoCurrencyOut => ({
+  ...parseTransactionValueToActionTransfer({ chain, transaction }),
+  direction: 'out',
+})
+
+export const parseTransactionValueToActionTransferNone = ({
+  chain,
+  transaction,
+}: ParseTransactionValueToActionTransferParameters): TransferCryptoCurrencyNone => ({
+  ...parseTransactionValueToActionTransfer({ chain, transaction }),
+  direction: 'none',
+})
+
+type ParseTransactionGasToActionTransferParameters = {
+  readonly chain: Chain
+  readonly transaction: TransactionDecoded<CryptoCurrencyPrice | undefined>
+}
+
+const parseTransactionGasToActionTransfer = ({
+  chain,
+  transaction: { from, gasUsed, effectiveGasPrice, nativeTokenPrice },
+}: ParseTransactionGasToActionTransferParameters): Omit<
+  | TransferCryptoCurrencyIn
+  | TransferCryptoCurrencyOut
+  | TransferCryptoCurrencyNone,
+  'direction'
+> => ({
+  from: createEvmAddressId({
+    chainId: chain.id,
+    address: toLowerHex(from),
+  }),
+  to: undefined,
+  price: nativeTokenPrice,
+  asset: chain.nativeToken.currency,
+  amount: createBigDecimal(
+    gasUsed * effectiveGasPrice,
+    chain.nativeToken.decimals,
+  ),
+})
+
+export const parseTransactionGasToActionTransferOut = ({
+  chain,
+  transaction,
+}: ParseTransactionGasToActionTransferParameters): TransferCryptoCurrencyOut => ({
+  ...parseTransactionGasToActionTransfer({ chain, transaction }),
+  direction: 'out',
+})
+
+export const parseTransactionGasToActionTransferNone = ({
+  chain,
+  transaction,
+}: ParseTransactionGasToActionTransferParameters): TransferCryptoCurrencyNone => ({
+  ...parseTransactionGasToActionTransfer({ chain, transaction }),
+  direction: 'none',
+})
+
+type ParseInternalTransactionToActionTransferParameters = {
+  readonly chain: Chain
+  readonly internalTransaction: InternalTransaction<
+    CryptoCurrencyPrice | undefined
+  >
+}
+
+const parseInternalTransactionToActionTransfer = ({
+  chain,
+  internalTransaction,
+}: ParseInternalTransactionToActionTransferParameters): Omit<
+  | TransferCryptoCurrencyIn
+  | TransferCryptoCurrencyOut
+  | TransferCryptoCurrencyNone,
+  'direction'
+> => ({
+  from: createEvmAddressId({
+    chainId: chain.id,
+    address: internalTransaction.from,
+  }),
+  to: createEvmAddressId({
+    chainId: chain.id,
+    address: internalTransaction.to ?? '0x',
+  }),
+  price: internalTransaction.price,
+  asset: internalTransaction.currency,
+  amount: createBigDecimal(
+    internalTransaction.value,
+    chain.nativeToken.decimals,
+  ),
+})
+
+export const parseInternalTransactionToActionTransferIn = ({
+  chain,
+  internalTransaction,
+}: ParseInternalTransactionToActionTransferParameters): TransferCryptoCurrencyIn => ({
+  ...parseInternalTransactionToActionTransfer({ chain, internalTransaction }),
+  direction: 'in',
+})
+
+export const parseInternalTransactionToActionTransferOut = ({
+  chain,
+  internalTransaction,
+}: ParseInternalTransactionToActionTransferParameters): TransferCryptoCurrencyOut => ({
+  ...parseInternalTransactionToActionTransfer({ chain, internalTransaction }),
+  direction: 'out',
+})
+
+export const parseInternalTransactionToActionTransferNone = ({
+  chain,
+  internalTransaction,
+}: ParseInternalTransactionToActionTransferParameters): TransferCryptoCurrencyNone => ({
+  ...parseInternalTransactionToActionTransfer({ chain, internalTransaction }),
+  direction: 'none',
+})
+
+type ParseErc20TransferToActionTransferParameters = {
+  readonly chainId: number
+  readonly transfer: Erc20Transfer<CryptoCurrencyPrice | undefined>
+}
+
+const parseErc20TransferToActionTransfer = ({
+  chainId,
+  transfer,
+}: ParseErc20TransferToActionTransferParameters): Omit<
+  | TransferCryptoCurrencyIn
+  | TransferCryptoCurrencyOut
+  | TransferCryptoCurrencyNone,
+  'direction'
+> => ({
+  from: createEvmAddressId({ chainId, address: transfer.from }),
+  to: createEvmAddressId({ chainId, address: transfer.to }),
+  price: transfer.price,
+  asset: transfer.token.currency,
+  amount: createBigDecimal(transfer.value, transfer.token.decimals),
+})
+
+export const parseErc20TransferToActionTransferIn = ({
+  chainId,
+  transfer,
+}: ParseErc20TransferToActionTransferParameters): TransferCryptoCurrencyIn => ({
+  ...parseErc20TransferToActionTransfer({ chainId, transfer }),
+  direction: 'in',
+})
+
+export const parseErc20TransferToActionTransferOut = ({
+  chainId,
+  transfer,
+}: ParseErc20TransferToActionTransferParameters): TransferCryptoCurrencyOut => ({
+  ...parseErc20TransferToActionTransfer({ chainId, transfer }),
+  direction: 'out',
+})
+
+export const parseErc20TransferToActionTransferNone = ({
+  chainId,
+  transfer,
+}: ParseErc20TransferToActionTransferParameters): TransferCryptoCurrencyNone => ({
+  ...parseErc20TransferToActionTransfer({ chainId, transfer }),
+  direction: 'none',
+})
+
+type ParseErc721TransferToActionTransferParameters = {
+  readonly chainId: number
+  readonly transfer: Erc721Transfer
+}
+
+const parseErc721TransferToActionTransfer = ({
+  chainId,
+  transfer,
+}: ParseErc721TransferToActionTransferParameters): Omit<
+  TransferNftIn | TransferNftOut | TransferNftNone,
+  'direction'
+> => ({
+  from: createEvmAddressId({ chainId, address: transfer.from }),
+  to: createEvmAddressId({ chainId, address: transfer.to }),
+  price: undefined,
+  asset: transfer.nft,
+  amount: createBigDecimal(1n),
+})
+
+export const parseErc721TransferToActionTransferIn = ({
+  chainId,
+  transfer,
+}: ParseErc721TransferToActionTransferParameters): TransferNftIn => ({
+  ...parseErc721TransferToActionTransfer({ chainId, transfer }),
+  direction: 'in',
+})
+
+export const parseErc721TransferToActionTransferOut = ({
+  chainId,
+  transfer,
+}: ParseErc721TransferToActionTransferParameters): TransferNftOut => ({
+  ...parseErc721TransferToActionTransfer({ chainId, transfer }),
+  direction: 'out',
+})
+
+export const parseErc721TransferToActionTransferNone = ({
+  chainId,
+  transfer,
+}: ParseErc721TransferToActionTransferParameters): TransferNftNone => ({
+  ...parseErc721TransferToActionTransfer({ chainId, transfer }),
+  direction: 'none',
+})
+
+type ParseErc1155TransferToActionTransferParameters = {
+  readonly chainId: number
+  readonly transfer: Erc1155Transfer
+}
+
+const parseErc1155TransferToActionTransfer = ({
+  chainId,
+  transfer,
+}: ParseErc1155TransferToActionTransferParameters): Omit<
+  TransferNftIn | TransferNftOut | TransferNftNone,
+  'direction'
+> => ({
+  from: createEvmAddressId({ chainId, address: transfer.from }),
+  to: createEvmAddressId({ chainId, address: transfer.to }),
+  price: undefined,
+  asset: transfer.nft,
+  amount: createBigDecimal(transfer.value),
+})
+
+export const parseErc1155TransferToActionTransferIn = ({
+  chainId,
+  transfer,
+}: ParseErc1155TransferToActionTransferParameters): TransferNftIn => ({
+  ...parseErc1155TransferToActionTransfer({ chainId, transfer }),
+  direction: 'in',
+})
+
+export const parseErc1155TransferToActionTransferOut = ({
+  chainId,
+  transfer,
+}: ParseErc1155TransferToActionTransferParameters): TransferNftOut => ({
+  ...parseErc1155TransferToActionTransfer({ chainId, transfer }),
+  direction: 'out',
+})
+
+export const parseErc1155TransferToActionTransferNone = ({
+  chainId,
+  transfer,
+}: ParseErc1155TransferToActionTransferParameters): TransferNftNone => ({
+  ...parseErc1155TransferToActionTransfer({ chainId, transfer }),
+  direction: 'none',
+})