@0xtorch/evm 0.0.11 → 0.0.12

package/analyzer/createAccountActionByAction/trade.ts

@@ -1,105 +0,0 @@
-import type {
-  AccountAction,
-  AccountActionType,
-  CryptoCurrencyPrice,
-  NormalActionTrade,
-} from '@0xtorch/core'
-import type {
-  EvmAccount,
-  LowerHex,
-  TransactionDecoded,
-  TransactionSource,
-} from '../../types'
-import { toLowerHex } from '../../types'
-
-export const createAccountActionByActionTrade = <
-  Price extends CryptoCurrencyPrice | undefined,
->(
-  action: NormalActionTrade<EvmAccount, Price>,
-  transaction: TransactionDecoded<Price>,
-  accountAddresses: readonly LowerHex[],
-):
-  | AccountAction<
-      AccountActionType,
-      TransactionSource,
-      EvmAccount | undefined,
-      Price
-    >
-  | undefined => {
-  const transfersIn = action.transfers.filter(
-    (transfer) => transfer.direction === 'in',
-  )
-  const transfersOut = action.transfers.filter(
-    (transfer) => transfer.direction === 'out',
-  )
-  if (transfersIn.length === 0 || transfersOut.length === 0) {
-    throw new Error('invalid action')
-  }
-
-  const source =
-    `evm_${transaction.chainId}_${toLowerHex(transaction.transactionHash)}` as const
-  if (
-    transfersIn.every((transfer) =>
-      accountAddresses.includes(transfer.to.address),
-    ) &&
-    transfersOut.every((transfer) =>
-      accountAddresses.includes(transfer.from.address),
-    )
-  ) {
-    // transfers の両側全てが自分の address の場合は trade として扱う
-    return {
-      type: 'AccountAction',
-      action: 'trade',
-      source,
-      evidence: action.evidence,
-      timestamp: action.timestamp,
-      order: 0,
-      comment: action.comment,
-      app: action.app,
-      transfers: action.transfers,
-    }
-  } else if (
-    transfersIn.every((transfer) =>
-      accountAddresses.includes(transfer.to.address),
-    ) &&
-    transfersOut.every(
-      (transfer) => !accountAddresses.includes(transfer.from.address),
-    )
-  ) {
-    // transfers の in 側全て自分の address , out側全てが自分の address でない場合は swap-income として扱う
-    return {
-      type: 'AccountAction',
-      action: 'swap-income',
-      source,
-      evidence: action.evidence,
-      timestamp: action.timestamp,
-      order: 0,
-      comment: action.comment,
-      app: action.app,
-      transfers: transfersIn,
-    }
-  } else if (
-    transfersOut.every((transfer) =>
-      accountAddresses.includes(transfer.from.address),
-    ) &&
-    transfersIn.every(
-      (transfer) => !accountAddresses.includes(transfer.to.address),
-    )
-  ) {
-    // transfers の out 側全てが自分の address , in 側全てが自分の address でない場合は swap-transfer として扱う
-    return {
-      type: 'AccountAction',
-      action: 'swap-transfer',
-      source,
-      evidence: action.evidence,
-      timestamp: action.timestamp,
-      order: 0,
-      comment: action.comment,
-      app: action.app,
-      transfers: transfersOut,
-    }
-  } else {
-    // それ以外の場合は分析不能として undefined を返す
-    return undefined
-  }
-}

package/analyzer/createAccountActionByAction/transactionFee.ts

@@ -1,51 +0,0 @@
-import type {
-  AccountAction,
-  AccountActionType,
-  CryptoCurrencyPrice,
-  NormalActionTransactionFee,
-} from '@0xtorch/core'
-import type {
-  EvmAccount,
-  LowerHex,
-  TransactionDecoded,
-  TransactionSource,
-} from '../../types'
-import { toLowerHex } from '../../types'
-
-export const createAccountActionByActionTransactionFee = <
-  Price extends CryptoCurrencyPrice | undefined,
->(
-  action: NormalActionTransactionFee<EvmAccount | undefined, Price>,
-  transaction: TransactionDecoded<Price>,
-  accountAddresses: readonly LowerHex[],
-):
-  | AccountAction<
-      AccountActionType,
-      TransactionSource,
-      EvmAccount | undefined,
-      Price
-    >
-  | undefined => {
-  if (action.transfers.length !== 1) {
-    return undefined
-  }
-  const transferFrom = action.transfers[0].from?.address
-  if (transferFrom === undefined) {
-    return undefined
-  }
-  if (!accountAddresses.includes(transferFrom)) {
-    return undefined
-  }
-
-  return {
-    type: 'AccountAction',
-    action: 'transaction-fee',
-    source: `evm_${transaction.chainId}_${toLowerHex(transaction.hash)}`,
-    evidence: action.evidence,
-    timestamp: action.timestamp,
-    order: 0,
-    comment: action.comment,
-    app: action.app,
-    transfers: action.transfers,
-  }
-}

package/analyzer/createAccountActionByAction/transfer.ts

@@ -1,95 +0,0 @@
-import type {
-  AccountAction,
-  AccountActionType,
-  CryptoCurrencyPrice,
-  NormalActionTransfer,
-} from '@0xtorch/core'
-import type {
-  EvmAccount,
-  LowerHex,
-  TransactionDecoded,
-  TransactionSource,
-} from '../../types'
-import { toLowerHex } from '../../types'
-
-export const createAccountActionByActionTransfer = <
-  Price extends CryptoCurrencyPrice | undefined,
->(
-  action: NormalActionTransfer<EvmAccount, Price>,
-  transaction: TransactionDecoded<Price>,
-  accountAddresses: readonly LowerHex[],
-):
-  | AccountAction<
-      AccountActionType,
-      TransactionSource,
-      EvmAccount | undefined,
-      Price
-    >
-  | undefined => {
-  if (action.transfers.length !== 1) {
-    throw new Error('invalid action')
-  }
-  const source =
-    `evm_${transaction.chainId}_${toLowerHex(transaction.transactionHash)}` as const
-  const transfer = action.transfers[0]
-  if (
-    accountAddresses.includes(transfer.from.address) &&
-    accountAddresses.includes(transfer.to.address)
-  ) {
-    return {
-      type: 'AccountAction',
-      action: 'move',
-      source,
-      evidence: 'system-rule',
-      timestamp: action.timestamp,
-      order: 0,
-      comment: action.comment,
-      app: action.app,
-      transfers: [
-        {
-          ...transfer,
-          target: '',
-          direction: 'none',
-        },
-      ],
-    }
-  } else if (accountAddresses.includes(transfer.from.address)) {
-    return {
-      type: 'AccountAction',
-      action: 'transfer',
-      source,
-      evidence: action.evidence,
-      timestamp: action.timestamp,
-      order: 0,
-      comment: action.comment,
-      app: action.app,
-      transfers: [
-        {
-          ...transfer,
-          target: transfer.from.address,
-          direction: 'out',
-        },
-      ],
-    }
-  } else if (accountAddresses.includes(transfer.to.address)) {
-    return {
-      type: 'AccountAction',
-      action: 'income',
-      source,
-      evidence: action.evidence,
-      timestamp: action.timestamp,
-      order: 0,
-      comment: action.comment,
-      app: action.app,
-      transfers: [
-        {
-          ...transfer,
-          target: transfer.to.address,
-          direction: 'in',
-        },
-      ],
-    }
-  } else {
-    return undefined
-  }
-}

package/analyzer/createAccountActionByAction/withdraw.ts

@@ -1,61 +0,0 @@
-import type {
-  AccountAction,
-  AccountActionType,
-  CryptoCurrencyPrice,
-  NormalActionWithdraw,
-} from '@0xtorch/core'
-import type {
-  EvmAccount,
-  LowerHex,
-  TransactionDecoded,
-  TransactionSource,
-} from '../../types'
-import { toLowerHex } from '../../types'
-
-export const createAccountActionByActionWithdraw = <
-  Price extends CryptoCurrencyPrice | undefined,
->(
-  action: NormalActionWithdraw<EvmAccount, Price>,
-  transaction: TransactionDecoded<Price>,
-  accountAddresses: readonly LowerHex[],
-):
-  | AccountAction<
-      AccountActionType,
-      TransactionSource,
-      EvmAccount | undefined,
-      Price
-    >
-  | undefined => {
-  if (action.transfers.length !== 1) {
-    throw new Error('invalid action')
-  }
-
-  const transfer = action.transfers[0]
-  if (
-    accountAddresses.includes(transfer.from.address) &&
-    accountAddresses.includes(transfer.to.address)
-  ) {
-    return undefined
-  } else if (accountAddresses.includes(transfer.to.address)) {
-    return {
-      type: 'AccountAction',
-      action: 'withdraw',
-      source:
-        `evm_${transaction.chainId}_${toLowerHex(transaction.transactionHash)}` as const,
-      evidence: action.evidence,
-      timestamp: action.timestamp,
-      order: 0,
-      comment: action.comment,
-      app: action.app,
-      transfers: [
-        {
-          ...transfer,
-          target: transfer.to.address,
-          direction: 'in',
-        },
-      ],
-    }
-  } else {
-    return undefined
-  }
-}

package/analyzer/createAccountActionByAction/withdrawWithBond.ts

@@ -1,60 +0,0 @@
-import type {
-  AccountAction,
-  AccountActionType,
-  CryptoCurrencyPrice,
-  NormalActionWithdrawWithBond,
-} from '@0xtorch/core'
-import type {
-  EvmAccount,
-  LowerHex,
-  TransactionDecoded,
-  TransactionSource,
-} from '../../types'
-import { toLowerHex } from '../../types'
-
-export const createAccountActionByActionWithdrawWithBond = <
-  Price extends CryptoCurrencyPrice | undefined,
->(
-  action: NormalActionWithdrawWithBond<EvmAccount, Price>,
-  transaction: TransactionDecoded<Price>,
-  accountAddresses: readonly LowerHex[],
-):
-  | AccountAction<
-      AccountActionType,
-      TransactionSource,
-      EvmAccount | undefined,
-      Price
-    >
-  | undefined => {
-  const transfersIn = action.transfers.filter(
-    (transfer) => transfer.direction === 'in',
-  )
-  const transfersOut = action.transfers.filter(
-    (transfer) => transfer.direction === 'out',
-  )
-  if (transfersIn.length === 0 || transfersOut.length === 0) {
-    throw new Error('invalid action')
-  }
-
-  const source =
-    `evm_${transaction.chainId}_${toLowerHex(transaction.transactionHash)}` as const
-
-  return transfersIn.every((transfer) =>
-    accountAddresses.includes(transfer.to.address),
-  ) &&
-    transfersOut.every((transfer) =>
-      accountAddresses.includes(transfer.from.address),
-    )
-    ? {
-        type: 'AccountAction',
-        action: 'withdraw-with-bond',
-        source,
-        evidence: action.evidence,
-        timestamp: action.timestamp,
-        order: 0,
-        comment: action.comment,
-        app: action.app,
-        transfers: action.transfers,
-      }
-    : undefined
-}

package/analyzer/json/generatorAnyLog.ts

@@ -1,207 +0,0 @@
-import { createBigDecimal } from '@0xtorch/big-decimal'
-import type {
-  ActionType,
-  CryptoCurrencyPrice,
-  NormalAction,
-} from '@0xtorch/core'
-import type { Chain } from '../../chains'
-import { createEvmAccount } from '../../creates/createEvmAccount'
-import type {
-  EvmAccount,
-  LogData,
-  LowerHex,
-  TransactionDecoded,
-} from '../../types'
-import { isHex, toLowerHex } from '../../types'
-import type {
-  ActionGeneratorAnyLog,
-  ActionGeneratorAnyLogAddress,
-  ActionGeneratorAnyLogAmount,
-} from './types'
-
-export const generateActionsByAnyLogGenerator = <
-  Price extends CryptoCurrencyPrice | undefined,
->(
-  generator: ActionGeneratorAnyLog,
-  chain: Chain,
-  transaction: TransactionDecoded<Price>,
-): NormalAction<ActionType, EvmAccount, Price>[] => {
-  const { chainId, block, app, nativeTokenPrice, logs } = transaction
-
-  const getTarget = (from: LowerHex, to: LowerHex) => {
-    switch (generator.target) {
-      case 'from': {
-        return from
-      }
-      case 'to': {
-        return to
-      }
-      case 'none': {
-        return ''
-      }
-    }
-  }
-  const getDirection = () => {
-    switch (generator.target) {
-      case 'from': {
-        return 'out'
-      }
-      case 'to': {
-        return 'in'
-      }
-      case 'none': {
-        return 'none'
-      }
-    }
-  }
-  const direction = getDirection()
-
-  const targetLogs = logs.filter(
-    (log) =>
-      log.log.topics[0] === generator.signature &&
-      log.log.topics.length - 1 === generator.indexedCount,
-  )
-
-  switch (generator.token.token) {
-    case 'native': {
-      return targetLogs.map((log) => {
-        const from = getAddress(generator.from, log, transaction)
-        const to = getAddress(generator.to, log, transaction)
-        return {
-          type: 'NormalAction',
-          action: generator.action,
-          evidence: 'contract',
-          timestamp: Number(block.timestamp) * 1000,
-          comment: generator.comment,
-          app,
-          transfers: [
-            {
-              target: getTarget(from, to),
-              direction,
-              from: createEvmAccount({ address: from, chainId }),
-              to: createEvmAccount({ address: to, chainId }),
-              asset: chain.nativeToken.currency,
-              amount: createBigDecimal(
-                getAmount(generator.amount, log, transaction),
-                chain.nativeToken.decimals,
-              ),
-              price: nativeTokenPrice,
-            },
-          ],
-        }
-      })
-    }
-  }
-}
-
-const getAddress = <Price extends CryptoCurrencyPrice | undefined>(
-  generator: ActionGeneratorAnyLogAddress,
-  targetLog: LogData,
-  transaction: TransactionDecoded<Price>,
-): LowerHex => {
-  switch (generator.type) {
-    case 'from': {
-      return toLowerHex(transaction.from)
-    }
-    case 'to': {
-      if (transaction.to === null) {
-        throw new Error('Transaction.to is null')
-      }
-      return toLowerHex(transaction.to)
-    }
-    case 'fix-value': {
-      return generator.value
-    }
-    case 'target': {
-      if (
-        targetLog.type === 'LogOriginal' ||
-        targetLog.log.args.length <= generator.argIndex
-      ) {
-        throw new Error('Invalid target log')
-      }
-      const value = String(targetLog.log.args[generator.argIndex].value)
-      if (isHex(value)) {
-        return toLowerHex(value)
-      } else {
-        throw new Error('Invalid target log')
-      }
-    }
-    case 'log': {
-      const log = transaction.logs.filter(
-        (log) =>
-          log.log.topics[0] === generator.signature &&
-          log.log.topics.length - 1 === generator.indexedCount,
-      )[generator.index]
-      if (
-        log === undefined ||
-        log.type === 'LogOriginal' ||
-        log.log.args.length <= generator.argIndex
-      ) {
-        throw new Error('Invalid log')
-      }
-      const value = String(log.log.args[generator.argIndex].value)
-      if (isHex(value)) {
-        return toLowerHex(value)
-      } else {
-        throw new Error('Invalid log')
-      }
-    }
-  }
-}
-
-const getAmount = <Price extends CryptoCurrencyPrice | undefined>(
-  generator: ActionGeneratorAnyLogAmount,
-  targetLog: LogData,
-  transaction: TransactionDecoded<Price>,
-): bigint => {
-  switch (generator.type) {
-    case 'value': {
-      return transaction.value
-    }
-    case 'fix-value': {
-      return generator.value
-    }
-    case 'target': {
-      if (
-        targetLog.type === 'LogOriginal' ||
-        targetLog.log.args.length <= generator.argIndex
-      ) {
-        throw new Error('Invalid target log')
-      }
-      const value = targetLog.log.args[generator.argIndex].value
-      if (typeof value === 'bigint') {
-        return value
-      } else if (typeof value === 'string') {
-        return BigInt(value)
-      } else if (typeof value === 'number') {
-        return BigInt(value)
-      } else {
-        throw new TypeError('Invalid target log')
-      }
-    }
-    case 'log': {
-      const log = transaction.logs.filter(
-        (log) =>
-          log.log.topics[0] === generator.signature &&
-          log.log.topics.length - 1 === generator.indexedCount,
-      )[generator.index]
-      if (
-        log === undefined ||
-        log.type === 'LogOriginal' ||
-        log.log.args.length <= generator.argIndex
-      ) {
-        throw new Error('Invalid log')
-      }
-      const value = log.log.args[generator.argIndex].value
-      if (typeof value === 'bigint') {
-        return value
-      } else if (typeof value === 'string') {
-        return BigInt(value)
-      } else if (typeof value === 'number') {
-        return BigInt(value)
-      } else {
-        throw new TypeError('Invalid log')
-      }
-    }
-  }
-}

package/analyzer/json/generatorAnyTokenTransfer.ts

@@ -1,118 +0,0 @@
-import { createBigDecimal } from '@0xtorch/big-decimal'
-import type {
-  ActionType,
-  CryptoCurrencyPrice,
-  NormalAction,
-} from '@0xtorch/core'
-import { createEvmAccount } from '../../creates/createEvmAccount'
-import type { EvmAccount, LowerHex, TransactionDecoded } from '../../types'
-import type { ActionGeneratorAnyTokenTransfer } from './types'
-
-export const generateActionsByAnyTokenTransferGenerator = <
-  Price extends CryptoCurrencyPrice | undefined,
->(
-  generator: ActionGeneratorAnyTokenTransfer,
-  transaction: TransactionDecoded<Price>,
-): NormalAction<ActionType, EvmAccount, Price>[] => {
-  const {
-    chainId,
-    block,
-    app,
-    erc20Transfers,
-    erc721Transfers,
-    erc1155Transfers,
-  } = transaction
-  const getTarget = (from: LowerHex, to: LowerHex) => {
-    switch (generator.target) {
-      case 'from': {
-        return from
-      }
-      case 'to': {
-        return to
-      }
-      case 'none': {
-        return ''
-      }
-    }
-  }
-  const getDirection = () => {
-    switch (generator.target) {
-      case 'from': {
-        return 'out'
-      }
-      case 'to': {
-        return 'in'
-      }
-      case 'none': {
-        return 'none'
-      }
-    }
-  }
-  const direction = getDirection()
-
-  switch (generator.token) {
-    case 'erc1155': {
-      return erc1155Transfers.map((transfer) => ({
-        type: 'NormalAction',
-        action: generator.action,
-        evidence: 'contract',
-        timestamp: Number(block.timestamp) * 1000,
-        comment: generator.comment,
-        app,
-        transfers: [
-          {
-            target: getTarget(transfer.from, transfer.to),
-            direction,
-            from: createEvmAccount({ address: transfer.from, chainId }),
-            to: createEvmAccount({ address: transfer.to, chainId }),
-            asset: transfer.nft,
-            amount: createBigDecimal(transfer.value),
-            price: undefined as Price,
-          },
-        ],
-      }))
-    }
-    case 'erc20': {
-      return erc20Transfers.map((transfer) => ({
-        type: 'NormalAction',
-        action: generator.action,
-        evidence: 'contract',
-        timestamp: Number(block.timestamp) * 1000,
-        comment: generator.comment,
-        app,
-        transfers: [
-          {
-            target: getTarget(transfer.from, transfer.to),
-            direction,
-            from: createEvmAccount({ address: transfer.from, chainId }),
-            to: createEvmAccount({ address: transfer.to, chainId }),
-            asset: transfer.token.currency,
-            amount: createBigDecimal(transfer.value, transfer.token.decimals),
-            price: transfer.price,
-          },
-        ],
-      }))
-    }
-    case 'erc721': {
-      return erc721Transfers.map((transfer) => ({
-        type: 'NormalAction',
-        action: generator.action,
-        evidence: 'contract',
-        timestamp: Number(block.timestamp) * 1000,
-        comment: generator.comment,
-        app,
-        transfers: [
-          {
-            target: getTarget(transfer.from, transfer.to),
-            direction,
-            from: createEvmAccount({ address: transfer.from, chainId }),
-            to: createEvmAccount({ address: transfer.to, chainId }),
-            asset: transfer.nft,
-            amount: createBigDecimal(1n),
-            price: undefined as Price,
-          },
-        ],
-      }))
-    }
-  }
-}