@0xtorch/evm 0.0.1

package/src/analyzer/createAccountActionByAction/buyNft.ts

@@ -0,0 +1,106 @@
+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/src/analyzer/createAccountActionByAction/createAccountActionByAction.ts

@@ -0,0 +1,181 @@
+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/src/analyzer/createAccountActionByAction/deposit.ts

@@ -0,0 +1,64 @@
+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/src/analyzer/createAccountActionByAction/depositWithBond.ts

@@ -0,0 +1,60 @@
+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/src/analyzer/createAccountActionByAction/freeMintNft.ts

@@ -0,0 +1,54 @@
+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/src/analyzer/createAccountActionByAction/index.ts

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

package/src/analyzer/createAccountActionByAction/removeLiquidity.ts

@@ -0,0 +1,60 @@
+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/src/analyzer/createAccountActionByAction/spam.ts

@@ -0,0 +1,79 @@
+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
+  }
+}