@0xtorch/evm 0.0.1

package/src/analyzer/axieMarketplace/analyze.ts

@@ -0,0 +1,326 @@
+import { createBigDecimal } from '@0xtorch/big-decimal'
+import type {
+  AccountActionBuyNft,
+  AccountActionSellNft,
+  CryptoCurrencyPrice,
+  NormalActionTrade,
+} from '@0xtorch/core'
+import { createEvmAccount } from '../../creates/createEvmAccount'
+import type { EvmAccount, TransactionSource } from '../../types'
+import { toLowerHex } from '../../types'
+import type { AnalyzeParameters, AnalyzeReturnType } from '../types'
+
+export const analyzeAxieMarketplace = <
+  Price extends CryptoCurrencyPrice | undefined,
+>({
+  chain,
+  transaction,
+  accountAddresses,
+}: AnalyzeParameters<Price>): Promise<AnalyzeReturnType<Price> | undefined> => {
+  const {
+    transactionHash,
+    from,
+    to,
+    value,
+    input,
+    app,
+    erc20Transfers,
+    erc721Transfers,
+    erc1155Transfers,
+    internalTransactions,
+    block,
+    logs,
+    nativeTokenPrice,
+  } = transaction
+  const timestamp = Number(block.timestamp) * 1000
+  const accountAddressSet = new Set(accountAddresses)
+
+  if (input.slice(0, 10) !== '0x95a4ec00') {
+    return Promise.resolve(undefined)
+  }
+  const orderMatchedEventSignature =
+    '0x968d1942d9971cb9c45c722957d854c38f327206399d12ae49ca2f9c5dd06fda'
+  const orderMatchedLogs = logs.filter(
+    (log) => log.log.topics[0] === orderMatchedEventSignature,
+  )
+  if (orderMatchedLogs.length !== 1) {
+    return Promise.resolve(undefined)
+  }
+
+  const relatedErc20Transfers = erc20Transfers.filter(
+    (transfer) =>
+      (accountAddressSet.has(transfer.from) ||
+        accountAddressSet.has(transfer.to)) &&
+      transfer.value > 0,
+  )
+  const relatedErc721Transfers = erc721Transfers.filter(
+    (transfer) =>
+      accountAddressSet.has(transfer.from) ||
+      accountAddressSet.has(transfer.to),
+  )
+  const relatedErc1155Transfers = erc1155Transfers.filter(
+    (transfer) =>
+      accountAddressSet.has(transfer.from) ||
+      accountAddressSet.has(transfer.to),
+  )
+  const relatedInternalTransactions = [
+    ...(value === 0n || to === null
+      ? []
+      : [
+          {
+            type: 'InternalTransaction' as const,
+            transactionHash,
+            from: toLowerHex(from),
+            to: toLowerHex(to),
+            contractAddress: undefined,
+            txType: '',
+            value,
+            gas: 0n,
+            gasUsed: 0n,
+            isError: false,
+            input: undefined,
+            currency: chain.nativeToken.currency,
+            price: nativeTokenPrice,
+          },
+        ]),
+    ...internalTransactions,
+  ].filter(
+    (internalTransaction) =>
+      (accountAddressSet.has(internalTransaction.from) ||
+        accountAddressSet.has(internalTransaction.to ?? '0x')) &&
+      internalTransaction.value > 0,
+  )
+
+  if (
+    relatedErc20Transfers.length === 0 &&
+    relatedInternalTransactions.length === 0
+  ) {
+    return Promise.resolve(undefined)
+  }
+  if (
+    relatedErc721Transfers.length === 0 &&
+    relatedErc1155Transfers.length === 0
+  ) {
+    return Promise.resolve(undefined)
+  }
+
+  // NFT Buy
+  if (
+    relatedErc20Transfers.every((transfer) =>
+      accountAddressSet.has(transfer.from),
+    ) &&
+    relatedInternalTransactions.every((internalTransaction) =>
+      accountAddressSet.has(internalTransaction.from),
+    ) &&
+    relatedErc721Transfers.every((transfer) =>
+      accountAddressSet.has(transfer.to),
+    ) &&
+    relatedErc1155Transfers.every((transfer) =>
+      accountAddressSet.has(transfer.to),
+    )
+  ) {
+    const normalAction: NormalActionTrade<EvmAccount, Price> = {
+      type: 'NormalAction',
+      action: 'trade',
+      evidence: 'contract',
+      timestamp,
+      comment: undefined,
+      app,
+      transfers: [
+        ...relatedErc721Transfers.map((transfer) => ({
+          target: transfer.to,
+          direction: 'in' as const,
+          from: createEvmAccount({
+            address: transfer.from,
+            chainId: chain.id,
+          }),
+          to: createEvmAccount({
+            address: transfer.to,
+            chainId: chain.id,
+          }),
+          asset: transfer.nft,
+          amount: createBigDecimal(1n),
+          price: undefined as Price,
+        })),
+        ...relatedErc1155Transfers.map((transfer) => ({
+          target: transfer.to,
+          direction: 'in' as const,
+          from: createEvmAccount({
+            address: transfer.from,
+            chainId: chain.id,
+          }),
+          to: createEvmAccount({
+            address: transfer.to,
+            chainId: chain.id,
+          }),
+          asset: transfer.nft,
+          amount: createBigDecimal(transfer.value),
+          price: undefined as Price,
+        })),
+        ...relatedInternalTransactions.map((internalTransaction) => ({
+          target: internalTransaction.from,
+          direction: 'out' as const,
+          from: createEvmAccount({
+            address: internalTransaction.from,
+            chainId: chain.id,
+          }),
+          to: createEvmAccount({
+            address: internalTransaction.to ?? '0x',
+            chainId: chain.id,
+          }),
+          asset: chain.nativeToken.currency,
+          amount: createBigDecimal(
+            internalTransaction.value,
+            chain.nativeToken.decimals,
+          ),
+          price: nativeTokenPrice,
+        })),
+        ...relatedErc20Transfers.map((transfer) => ({
+          target: transfer.from,
+          direction: 'out' as const,
+          from: createEvmAccount({
+            address: transfer.from,
+            chainId: chain.id,
+          }),
+          to: createEvmAccount({
+            address: transfer.to,
+            chainId: chain.id,
+          }),
+          asset: transfer.token.currency,
+          amount: createBigDecimal(transfer.value, transfer.token.decimals),
+          price: transfer.price,
+        })),
+      ],
+    }
+    const accountAction: AccountActionBuyNft<
+      EvmAccount,
+      TransactionSource,
+      Price
+    > = {
+      type: 'AccountAction',
+      action: 'buy-nft',
+      source: `evm_${chain.id}_${toLowerHex(transactionHash)}`,
+      evidence: 'contract',
+      timestamp,
+      order: 0,
+      comment: normalAction.comment,
+      app,
+      transfers: normalAction.transfers,
+    }
+    return Promise.resolve({
+      actions: [normalAction],
+      accountActions: [accountAction],
+    })
+  }
+
+  // NFT Sell
+  if (
+    relatedErc20Transfers.every((transfer) =>
+      accountAddressSet.has(transfer.to),
+    ) &&
+    relatedInternalTransactions.every((internalTransaction) =>
+      accountAddressSet.has(internalTransaction.to ?? '0x'),
+    ) &&
+    relatedErc721Transfers.every((transfer) =>
+      accountAddressSet.has(transfer.from),
+    ) &&
+    relatedErc1155Transfers.every((transfer) =>
+      accountAddressSet.has(transfer.from),
+    )
+  ) {
+    const normalAction: NormalActionTrade<EvmAccount, Price> = {
+      type: 'NormalAction',
+      action: 'trade',
+      evidence: 'contract',
+      timestamp,
+      comment: undefined,
+      app,
+      transfers: [
+        ...relatedInternalTransactions.map((internalTransaction) => ({
+          target: internalTransaction.to ?? '0x',
+          direction: 'in' as const,
+          from: createEvmAccount({
+            address: internalTransaction.from,
+            chainId: chain.id,
+          }),
+          to: createEvmAccount({
+            address: internalTransaction.to ?? '0x',
+            chainId: chain.id,
+          }),
+          asset: chain.nativeToken.currency,
+          amount: createBigDecimal(
+            internalTransaction.value,
+            chain.nativeToken.decimals,
+          ),
+          price: nativeTokenPrice,
+        })),
+        ...relatedErc20Transfers.map((transfer) => ({
+          target: transfer.to ?? '0x',
+          direction: 'in' as const,
+          from: createEvmAccount({
+            address: transfer.from,
+            chainId: chain.id,
+          }),
+          to: createEvmAccount({
+            address: transfer.to,
+            chainId: chain.id,
+          }),
+          asset: transfer.token.currency,
+          amount: createBigDecimal(transfer.value, transfer.token.decimals),
+          price: transfer.price,
+        })),
+        ...relatedErc721Transfers.map((transfer) => ({
+          target: transfer.from,
+          direction: 'out' as const,
+          from: createEvmAccount({
+            address: transfer.from,
+            chainId: chain.id,
+          }),
+          to: createEvmAccount({
+            address: transfer.to,
+            chainId: chain.id,
+          }),
+          asset: transfer.nft,
+          amount: createBigDecimal(1n),
+          price: undefined as Price,
+        })),
+        ...relatedErc1155Transfers.map((transfer) => ({
+          target: transfer.from,
+          direction: 'out' as const,
+          from: createEvmAccount({
+            address: transfer.from,
+            chainId: chain.id,
+          }),
+          to: createEvmAccount({
+            address: transfer.to,
+            chainId: chain.id,
+          }),
+          asset: transfer.nft,
+          amount: createBigDecimal(transfer.value),
+          price: undefined as Price,
+        })),
+      ],
+    }
+    const accountAction: AccountActionSellNft<
+      EvmAccount,
+      TransactionSource,
+      Price
+    > = {
+      type: 'AccountAction',
+      action: 'sell-nft',
+      source: `evm_${chain.id}_${toLowerHex(transactionHash)}`,
+      evidence: 'contract',
+      timestamp,
+      order: 0,
+      comment: normalAction.comment,
+      app,
+      transfers: normalAction.transfers,
+    }
+    return Promise.resolve({
+      actions: [normalAction],
+      accountActions: [accountAction],
+    })
+  }
+
+  return Promise.resolve(undefined)
+}

package/src/analyzer/axieMarketplace/index.ts

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

package/src/analyzer/createAccountActionByAction/addLiquidity.ts

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

package/src/analyzer/createAccountActionByAction/atomicArbitrage.ts

@@ -0,0 +1,115 @@
+import { createBigDecimal, greaterThan } from '@0xtorch/big-decimal'
+import type {
+  AccountAction,
+  AccountActionType,
+  CryptoCurrencyPrice,
+  NormalActionAtomicArbitrage,
+} from '@0xtorch/core'
+import type {
+  EvmAccount,
+  LowerHex,
+  TransactionDecoded,
+  TransactionSource,
+} from '../../types'
+import { toLowerHex } from '../../types'
+
+export const createAccountActionByActionAtomicArbitrage = <
+  Price extends CryptoCurrencyPrice | undefined,
+>(
+  action: NormalActionAtomicArbitrage<EvmAccount, Price>,
+  transaction: TransactionDecoded<Price>,
+  accountAddresses: readonly LowerHex[],
+):
+  | AccountAction<
+      AccountActionType,
+      TransactionSource,
+      EvmAccount | undefined,
+      Price
+    >
+  | undefined => {
+  if (action.transfers.length !== 2) {
+    throw new Error('invalid action')
+  }
+  const transferIn = action.transfers.find(
+    (transfer) => transfer.direction === 'in',
+  )
+  const transferOut = action.transfers.find(
+    (transfer) => transfer.direction === 'out',
+  )
+  if (transferIn === undefined || transferOut === undefined) {
+    throw new Error('invalid action')
+  }
+
+  const source =
+    `evm_${transaction.chainId}_${toLowerHex(transaction.transactionHash)}` as const
+  if (
+    accountAddresses.includes(transferIn.to.address) &&
+    accountAddresses.includes(transferOut.from.address)
+  ) {
+    // transfers の両側が自分の address の場合は atomic-arbitrage として扱う
+    return {
+      type: 'AccountAction',
+      action: 'atomic-arbitrage',
+      source,
+      evidence: action.evidence,
+      timestamp: action.timestamp,
+      order: 0,
+      comment: action.comment,
+      app: action.app,
+      transfers: [
+        {
+          target: transferIn.to.address,
+          direction: greaterThan(transferIn.amount, transferOut.amount)
+            ? 'in'
+            : 'out',
+          from: greaterThan(transferIn.amount, transferOut.amount)
+            ? undefined
+            : transferIn.to,
+          to: greaterThan(transferIn.amount, transferOut.amount)
+            ? transferIn.to
+            : undefined,
+          asset: transferIn.asset,
+          amount: greaterThan(transferIn.amount, transferOut.amount)
+            ? createBigDecimal(
+                transferIn.amount.value - transferOut.amount.value,
+                transferIn.amount.decimals,
+              )
+            : createBigDecimal(
+                transferOut.amount.value - transferIn.amount.value,
+                transferIn.amount.decimals,
+              ),
+          price: transferIn.price,
+        },
+      ],
+    }
+  } else if (accountAddresses.includes(transferIn.to.address)) {
+    // transfers の in 側が自分の 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: [transferIn],
+    }
+  } else if (accountAddresses.includes(transferOut.from.address)) {
+    // transfers の out 側が自分の 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: [transferOut],
+    }
+  } else {
+    // transfers の両側が自分の address でない場合は undefined を返す
+    return undefined
+  }
+}

package/src/analyzer/createAccountActionByAction/bridgeFrom.ts

@@ -0,0 +1,61 @@
+import type {
+  AccountAction,
+  AccountActionType,
+  CryptoCurrencyPrice,
+  NormalActionBridgeFrom,
+} from '@0xtorch/core'
+import type {
+  EvmAccount,
+  LowerHex,
+  TransactionDecoded,
+  TransactionSource,
+} from '../../types'
+import { toLowerHex } from '../../types'
+
+export const createAccountActionByActionBridgeFrom = <
+  Price extends CryptoCurrencyPrice | undefined,
+>(
+  action: NormalActionBridgeFrom<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: 'bridge-from',
+      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 {
+    return undefined
+  }
+}

package/src/analyzer/createAccountActionByAction/bridgeTo.ts

@@ -0,0 +1,61 @@
+import type {
+  AccountAction,
+  AccountActionType,
+  CryptoCurrencyPrice,
+  NormalActionBridgeTo,
+} from '@0xtorch/core'
+import type {
+  EvmAccount,
+  LowerHex,
+  TransactionDecoded,
+  TransactionSource,
+} from '../../types'
+import { toLowerHex } from '../../types'
+
+export const createAccountActionByActionBridgeTo = <
+  Price extends CryptoCurrencyPrice | undefined,
+>(
+  action: NormalActionBridgeTo<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: 'bridge-to',
+      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
+  }
+}