@0xtorch/evm 0.0.10 → 0.0.12

package/analyzer/createAccountActionByAction/buyNft.ts

@@ -1,106 +0,0 @@
-import type {
-  AccountAction,
-  AccountActionType,
-  CryptoCurrencyPrice,
-  NormalActionBuyNft,
-} from '@0xtorch/core'
-import type {
-  EvmAccount,
-  LowerHex,
-  TransactionDecoded,
-  TransactionSource,
-} from '../../types'
-import { toLowerHex } from '../../types'
-
-export const createAccountActionByActionBuyNft = <
-  Price extends CryptoCurrencyPrice | undefined,
->(
-  action: NormalActionBuyNft<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 の場合は buy-nft として扱う
-    return {
-      type: 'AccountAction',
-      action: 'buy-nft',
-      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/createAccountActionByAction.ts

@@ -1,181 +0,0 @@
-import type {
-  AccountAction,
-  AccountActionType,
-  ActionType,
-  CryptoCurrencyPrice,
-  NormalAction,
-  NormalActionAddLiquidity,
-  NormalActionAtomicArbitrage,
-  NormalActionBridgeFrom,
-  NormalActionBridgeTo,
-  NormalActionBuyNft,
-  NormalActionDeposit,
-  NormalActionDepositWithBond,
-  NormalActionFreeMintNft,
-  NormalActionRemoveLiquidity,
-  NormalActionSpam,
-  NormalActionTrade,
-  NormalActionTransactionFee,
-  NormalActionTransfer,
-  NormalActionWithdraw,
-  NormalActionWithdrawWithBond,
-} from '@0xtorch/core'
-import type {
-  EvmAccount,
-  LowerHex,
-  TransactionDecoded,
-  TransactionSource,
-} from '../../types'
-import { createAccountActionByActionAddLiquidity } from './addLiquidity'
-import { createAccountActionByActionAtomicArbitrage } from './atomicArbitrage'
-import { createAccountActionByActionBridgeFrom } from './bridgeFrom'
-import { createAccountActionByActionBridgeTo } from './bridgeTo'
-import { createAccountActionByActionBuyNft } from './buyNft'
-import { createAccountActionByActionDeposit } from './deposit'
-import { createAccountActionByActionDepositWithBond } from './depositWithBond'
-import { createAccountActionByActionFreeMintNft } from './freeMintNft'
-import { createAccountActionByActionRemoveLiquidty } from './removeLiquidity'
-import { createAccountActionByActionSpam } from './spam'
-import { createAccountActionByActionTrade } from './trade'
-import { createAccountActionByActionTransactionFee } from './transactionFee'
-import { createAccountActionByActionTransfer } from './transfer'
-import { createAccountActionByActionWithdraw } from './withdraw'
-import { createAccountActionByActionWithdrawWithBond } from './withdrawWithBond'
-
-export const createAccountActionByAction = <
-  Price extends CryptoCurrencyPrice | undefined,
->(
-  action: NormalAction<ActionType, EvmAccount | undefined, Price>,
-  transaction: TransactionDecoded<Price>,
-  accountAddresses: readonly LowerHex[],
-):
-  | AccountAction<
-      AccountActionType,
-      TransactionSource,
-      EvmAccount | undefined,
-      Price
-    >
-  | undefined => {
-  switch (action.action) {
-    case 'add-liquidity': {
-      // TODO action の validation をする
-      return createAccountActionByActionAddLiquidity(
-        action as NormalActionAddLiquidity<EvmAccount, Price>,
-        transaction,
-        accountAddresses,
-      )
-    }
-    case 'atomic-arbitrage': {
-      // TODO action の validation をする
-      return createAccountActionByActionAtomicArbitrage(
-        action as NormalActionAtomicArbitrage<EvmAccount, Price>,
-        transaction,
-        accountAddresses,
-      )
-    }
-    case 'bridge-from': {
-      // TODO action の validation をする
-      return createAccountActionByActionBridgeFrom(
-        action as NormalActionBridgeFrom<EvmAccount, Price>,
-        transaction,
-        accountAddresses,
-      )
-    }
-    case 'bridge-to': {
-      // TODO action の validation をする
-      return createAccountActionByActionBridgeTo(
-        action as NormalActionBridgeTo<EvmAccount, Price>,
-        transaction,
-        accountAddresses,
-      )
-    }
-    case 'buy-nft': {
-      // TODO action の validation をする
-      return createAccountActionByActionBuyNft(
-        action as NormalActionBuyNft<EvmAccount, Price>,
-        transaction,
-        accountAddresses,
-      )
-    }
-    case 'deposit': {
-      // TODO action の validation をする
-      return createAccountActionByActionDeposit(
-        action as NormalActionDeposit<EvmAccount, Price>,
-        transaction,
-        accountAddresses,
-      )
-    }
-    case 'deposit-with-bond': {
-      // TODO action の validation をする
-      return createAccountActionByActionDepositWithBond(
-        action as NormalActionDepositWithBond<EvmAccount, Price>,
-        transaction,
-        accountAddresses,
-      )
-    }
-    case 'free-mint-nft': {
-      // TODO action の validation をする
-      return createAccountActionByActionFreeMintNft(
-        action as NormalActionFreeMintNft<EvmAccount>,
-        transaction,
-        accountAddresses,
-      )
-    }
-    case 'remove-liquidity': {
-      // TODO action の validation をする
-      return createAccountActionByActionRemoveLiquidty(
-        action as NormalActionRemoveLiquidity<EvmAccount, Price>,
-        transaction,
-        accountAddresses,
-      )
-    }
-    case 'spam': {
-      // TODO action の validation をする
-      return createAccountActionByActionSpam(
-        action as NormalActionSpam<EvmAccount, Price>,
-        transaction,
-        accountAddresses,
-      )
-    }
-    case 'trade': {
-      // TODO action の validation をする
-      return createAccountActionByActionTrade(
-        action as NormalActionTrade<EvmAccount, Price>,
-        transaction,
-        accountAddresses,
-      )
-    }
-    case 'transaction-fee': {
-      // TODO action の validation をする
-      return createAccountActionByActionTransactionFee(
-        action as NormalActionTransactionFee<EvmAccount | undefined, Price>,
-        transaction,
-        accountAddresses,
-      )
-    }
-    case 'transfer': {
-      // TODO action の validation をする
-      return createAccountActionByActionTransfer(
-        action as NormalActionTransfer<EvmAccount, Price>,
-        transaction,
-        accountAddresses,
-      )
-    }
-    case 'withdraw': {
-      // TODO action の validation をする
-      return createAccountActionByActionWithdraw(
-        action as NormalActionWithdraw<EvmAccount, Price>,
-        transaction,
-        accountAddresses,
-      )
-    }
-    case 'withdraw-with-bond': {
-      // TODO action の validation をする
-      return createAccountActionByActionWithdrawWithBond(
-        action as NormalActionWithdrawWithBond<EvmAccount, Price>,
-        transaction,
-        accountAddresses,
-      )
-    }
-  }
-}

package/analyzer/createAccountActionByAction/deposit.ts

@@ -1,64 +0,0 @@
-import type {
-  AccountAction,
-  AccountActionType,
-  CryptoCurrencyPrice,
-  NormalActionDeposit,
-} from '@0xtorch/core'
-import type {
-  EvmAccount,
-  LowerHex,
-  TransactionDecoded,
-  TransactionSource,
-} from '../../types'
-import { toLowerHex } from '../../types'
-
-export const createAccountActionByActionDeposit = <
-  Price extends CryptoCurrencyPrice | undefined,
->(
-  action: NormalActionDeposit<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.from.address)) {
-    return {
-      type: 'AccountAction',
-      action: 'deposit',
-      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.from.address,
-          direction: 'out',
-        },
-      ],
-    }
-  } else if (accountAddresses.includes(transfer.to.address)) {
-    // TODO deposit の受け取り側は borrow として扱った方が良さそう
-    return undefined
-  } else {
-    return undefined
-  }
-}

package/analyzer/createAccountActionByAction/depositWithBond.ts

@@ -1,60 +0,0 @@
-import type {
-  AccountAction,
-  AccountActionType,
-  CryptoCurrencyPrice,
-  NormalActionDepositWithBond,
-} from '@0xtorch/core'
-import type {
-  EvmAccount,
-  LowerHex,
-  TransactionDecoded,
-  TransactionSource,
-} from '../../types'
-import { toLowerHex } from '../../types'
-
-export const createAccountActionByActionDepositWithBond = <
-  Price extends CryptoCurrencyPrice | undefined,
->(
-  action: NormalActionDepositWithBond<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: 'deposit-with-bond',
-        source,
-        evidence: action.evidence,
-        timestamp: action.timestamp,
-        order: 0,
-        comment: action.comment,
-        app: action.app,
-        transfers: action.transfers,
-      }
-    : undefined
-}

package/analyzer/createAccountActionByAction/freeMintNft.ts

@@ -1,54 +0,0 @@
-import type {
-  AccountAction,
-  AccountActionType,
-  CryptoCurrencyPrice,
-  NormalActionFreeMintNft,
-} from '@0xtorch/core'
-import type {
-  EvmAccount,
-  LowerHex,
-  TransactionDecoded,
-  TransactionSource,
-} from '../../types'
-import { toLowerHex } from '../../types'
-
-export const createAccountActionByActionFreeMintNft = <
-  Price extends CryptoCurrencyPrice | undefined,
->(
-  action: NormalActionFreeMintNft<EvmAccount>,
-  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]
-  return accountAddresses.includes(transfer.to.address)
-    ? {
-        type: 'AccountAction',
-        action: 'free-mint-nft',
-        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',
-            price: undefined as Price,
-          },
-        ],
-      }
-    : undefined
-}

package/analyzer/createAccountActionByAction/index.ts

@@ -1 +0,0 @@
-export { createAccountActionByAction } from './createAccountActionByAction'

package/analyzer/createAccountActionByAction/removeLiquidity.ts

@@ -1,60 +0,0 @@
-import type {
-  AccountAction,
-  AccountActionType,
-  CryptoCurrencyPrice,
-  NormalActionRemoveLiquidity,
-} from '@0xtorch/core'
-import type {
-  EvmAccount,
-  LowerHex,
-  TransactionDecoded,
-  TransactionSource,
-} from '../../types'
-import { toLowerHex } from '../../types'
-
-export const createAccountActionByActionRemoveLiquidty = <
-  Price extends CryptoCurrencyPrice | undefined,
->(
-  action: NormalActionRemoveLiquidity<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) {
-    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: 'remove-liquidity',
-        source,
-        evidence: action.evidence,
-        timestamp: action.timestamp,
-        order: 0,
-        comment: action.comment,
-        app: action.app,
-        transfers: action.transfers,
-      }
-    : undefined
-}

package/analyzer/createAccountActionByAction/spam.ts

@@ -1,79 +0,0 @@
-import type {
-  AccountAction,
-  AccountActionType,
-  CryptoCurrencyPrice,
-  NormalActionSpam,
-} from '@0xtorch/core'
-import type {
-  EvmAccount,
-  LowerHex,
-  TransactionDecoded,
-  TransactionSource,
-} from '../../types'
-import { toLowerHex } from '../../types'
-
-export const createAccountActionByActionSpam = <
-  Price extends CryptoCurrencyPrice | undefined,
->(
-  action: NormalActionSpam<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 undefined
-  } else if (accountAddresses.includes(transfer.from.address)) {
-    return {
-      type: 'AccountAction',
-      action: 'spam',
-      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: 'spam',
-      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
-  }
-}