@0xtorch/evm 0.0.104 → 0.0.106

package/explorer/moralis/create.ts

@@ -0,0 +1,205 @@
+import {
+  type InternalTransactionWithIndex,
+  type LowerHex,
+  type TransactionIndex,
+  toLowerHex,
+} from '../../types'
+import { createInternalTransactionId } from '../../utils/createInternalTransactionId'
+import type { Explorer } from '../types'
+import { createMoralisClient } from './client'
+import { getWalletTransactionHistory } from './getWalletTransactionHistory'
+
+type CreateMoralisExplorerParameters = {
+  name: string
+  baseUrl: string
+  chain: string
+  apiKey?: string
+  proxyUrl?: string
+  headers?: Record<string, string>
+}
+
+const limit = 100
+
+export const createMoralisExplorer = ({
+  name,
+  baseUrl,
+  chain,
+  apiKey,
+  proxyUrl,
+  headers,
+}: CreateMoralisExplorerParameters): Explorer => {
+  const client = createMoralisClient({
+    apiKey,
+    proxyUrl,
+    headers,
+  })
+
+  return {
+    name,
+    baseUrl,
+    getAddressInternalTransactions: async ({
+      address,
+      fromBlock,
+      toBlock,
+    }): Promise<InternalTransactionWithIndex[]> => {
+      const lowerAddress = toLowerHex(address)
+      const internalTransactions = new Map<
+        string,
+        InternalTransactionWithIndex
+      >()
+
+      let cursor: string | undefined = undefined
+      while (true) {
+        const result = await getWalletTransactionHistory({
+          client,
+          address: lowerAddress,
+          chain,
+          fromBlock,
+          toBlock,
+          cursor,
+        })
+        cursor = result.cursor
+
+        for (const transaction of result.result) {
+          for (const internalTransaction of transaction.internal_transactions) {
+            if (
+              internalTransaction.from !== lowerAddress &&
+              internalTransaction.to !== lowerAddress
+            ) {
+              continue
+            }
+            const data: InternalTransactionWithIndex = {
+              from: internalTransaction.from,
+              gas: internalTransaction.gas,
+              isError: false,
+              txHash: transaction.hash,
+              value: internalTransaction.value,
+              blockNumber: transaction.block_number,
+              timestamp: transaction.block_timestamp,
+              to: transaction.to_address,
+            }
+            const id = createInternalTransactionId(data)
+            if (!internalTransactions.has(id)) {
+              internalTransactions.set(id, data)
+            }
+          }
+        }
+
+        if (result.result.length < limit) {
+          break
+        }
+      }
+
+      return [...internalTransactions.values()]
+    },
+    getAddressTransactionIndexes: async ({
+      address,
+      fromBlock,
+      toBlock,
+    }): Promise<TransactionIndex[]> => {
+      const lowerAddress = toLowerHex(address)
+      const indexes = new Map<LowerHex, TransactionIndex>()
+
+      let cursor: string | undefined = undefined
+      while (true) {
+        const result = await getWalletTransactionHistory({
+          client,
+          address: lowerAddress,
+          chain,
+          fromBlock,
+          toBlock,
+          cursor,
+        })
+        cursor = result.cursor
+
+        for (const transaction of result.result) {
+          if (
+            transaction.from_address !== lowerAddress &&
+            transaction.to_address !== lowerAddress
+          ) {
+            continue
+          }
+          if (!indexes.has(transaction.hash)) {
+            const data: TransactionIndex = {
+              hash: transaction.hash,
+              blockNumber: transaction.block_number,
+              timestamp: transaction.block_timestamp,
+            }
+            indexes.set(data.hash, data)
+          }
+        }
+
+        if (result.result.length < limit) {
+          break
+        }
+      }
+
+      return [...indexes.values()]
+    },
+    getAddressTokenTransferIndexes: async ({
+      address,
+      fromBlock,
+      toBlock,
+    }): Promise<TransactionIndex[]> => {
+      const lowerAddress = toLowerHex(address)
+      const indexes = new Map<LowerHex, TransactionIndex>()
+
+      let cursor: string | undefined = undefined
+      while (true) {
+        const result = await getWalletTransactionHistory({
+          client,
+          address: lowerAddress,
+          chain,
+          fromBlock,
+          toBlock,
+          cursor,
+        })
+        cursor = result.cursor
+
+        for (const transaction of result.result) {
+          if (
+            transaction.erc20_transfers.every(
+              ({ from_address, to_address }) =>
+                from_address !== lowerAddress && to_address !== lowerAddress,
+            ) &&
+            transaction.nft_transfers.every(
+              ({ from_address, to_address }) =>
+                from_address !== lowerAddress && to_address !== lowerAddress,
+            )
+          ) {
+            continue
+          }
+          if (!indexes.has(transaction.hash)) {
+            const data: TransactionIndex = {
+              hash: transaction.hash,
+              blockNumber: transaction.block_number,
+              timestamp: transaction.block_timestamp,
+            }
+            indexes.set(data.hash, data)
+          }
+        }
+
+        if (result.result.length < limit) {
+          break
+        }
+      }
+
+      return [...indexes.values()]
+    },
+    getBlockNumberOfTimestamp: (): Promise<number> => {
+      throw new Error('Function not implemented.')
+    },
+    getContract: () => {
+      throw new Error('Function not implemented.')
+    },
+    getContractCreations: () => {
+      throw new Error('Function not implemented.')
+    },
+    getEventLogs: () => {
+      throw new Error('Function not implemented.')
+    },
+    getInternalTransactionOfTransaction: () => {
+      throw new Error('Function not implemented.')
+    },
+  }
+}

package/explorer/moralis/getWalletTransactionHistory.ts

@@ -0,0 +1,172 @@
+import { z } from 'zod'
+import { bigintTextSchema, lowerHexSchema } from '../../types/primitive'
+import type { MoralisClient } from './client'
+
+const transactionSchema = z.object({
+  // "hash": "0x43a8a6f44f4e5b9cc9fa7e76a2b818fc76222384eb8a2fb4e3ab854523c1fb94",
+  hash: lowerHexSchema,
+  // "nonce": "1",
+  // "transaction_index": "27",
+  // "from_address_entity": null,
+  // "from_address_entity_logo": null,
+  // "from_address": "0xecdb93a95cab09b5a259ebac8fd48d3239a5589a",
+  from_address: lowerHexSchema,
+  // "from_address_label": null,
+  // "to_address_entity": null,
+  // "to_address_entity_logo": null,
+  // "to_address": "0x213073989821f738a7ba3520c3d31a1f9ad31bbd",
+  to_address: lowerHexSchema,
+  // "to_address_label": null,
+  // "value": "0",
+  value: bigintTextSchema,
+  // "gas": "392194",
+  // "gas_price": "0",
+  // "receipt_cumulative_gas_used": "4678646",
+  // "receipt_gas_used": "169711",
+  // "receipt_contract_address": null,
+  // "receipt_status": "1",
+  // "block_timestamp": "2021-07-28T15:28:09.000Z",
+  block_timestamp: z.string().transform((x) => new Date(x).getTime()),
+  // "block_number": "5304713",
+  block_number: z.string().regex(/^\d+$/).transform(Number),
+  // "block_hash": "0xb87e4ea5f85e16461ab3242413577b0e18c50d10f6f22454d3f8da850b4135d9",
+  // "transaction_fee": "0",
+  // "method_label": "settleAuction",
+  // "summary": "Received 0.8 WETH from 0xe3...6b4b",
+  // "possible_spam": false,
+  // "category": "token receive",
+  // "nft_transfers": [],
+  nft_transfers: z.array(
+    z.object({
+      // "log_index": 132,
+      // "value": "0",
+      // "contract_type": "ERC721",
+      // "transaction_type": "Single",
+      // "token_address": "0x32950db2a7164ae833121501c797d79e7b79d74c",
+      // "token_id": "2273287",
+      // "from_address_entity": null,
+      // "from_address_entity_logo": null,
+      // "from_address": "0xecdb93a95cab09b5a259ebac8fd48d3239a5589a",
+      from_address: lowerHexSchema,
+      // "from_address_label": null,
+      // "to_address_entity": null,
+      // "to_address_entity_logo": null,
+      // "to_address": "0x36b9b408da80783a360ba847303b015d7e0e59f8",
+      to_address: lowerHexSchema,
+      // "to_address_label": null,
+      // "amount": "1",
+      amount: bigintTextSchema,
+      // "operator": null,
+      // "possible_spam": false,
+      // "verified_collection": false,
+      // "direction": "send"
+    }),
+  ),
+  // "erc20_transfers": [],
+  erc20_transfers: z.array(
+    z.object({
+      // "token_name": "Ronin Wrapped Ether",
+      // "token_symbol": "WETH",
+      // "token_logo": null,
+      // "token_decimals": "18",
+      // "from_address_entity": null,
+      // "from_address_entity_logo": null,
+      // "from_address": "0xecdb93a95cab09b5a259ebac8fd48d3239a5589a",
+      from_address: lowerHexSchema,
+      // "from_address_label": null,
+      // "to_address_entity": null,
+      // "to_address_entity_logo": null,
+      // "to_address": "0xa99cacd1427f493a95b585a5c7989a08c86a616b",
+      to_address: lowerHexSchema,
+      // "to_address_label": null,
+      // "address": "0xc99a6a985ed2cac1ef41640596c5a5f9f4e19ef5",
+      // "log_index": 37,
+      // "value": "6851147569444444",
+      value: bigintTextSchema,
+      // "possible_spam": false,
+      // "verified_contract": false,
+      // "security_score": null,
+      // "direction": "send",
+      // "value_formatted": "0.006851147569444444"
+    }),
+  ),
+  // "native_transfers": [],
+  // "internal_transactions": [],
+  internal_transactions: z.array(
+    z.object({
+      // "transaction_hash": "0x4f3c9722734098328c9c3b1fcddb9712f4dc6724c50ee2d3614aff6362eab175",
+      // "block_number": 21021408,
+      // "block_hash": "0x971595149658a4d5c2d0a2219f5019958e1a7ff2f72d7d098e144104a2a5b6a0",
+      // "type": "CALL",
+      // "from": "0x0000000000000068f116a894984e2db1123eb395",
+      from: lowerHexSchema,
+      // "to": "0x0000a26b00c1f0df003000390027140000faa719",
+      to: lowerHexSchema,
+      // "value": "1180000000000000",
+      value: bigintTextSchema,
+      // "gas": "68677",
+      gas: bigintTextSchema,
+      // "gas_used": "85",
+      // "input": "0x",
+      // "output": "0x"
+    }),
+  ),
+})
+
+const resultSchema = z.object({
+  cursor: z.string(),
+  result: z.array(transactionSchema),
+})
+
+type Result = z.infer<typeof resultSchema>
+
+const cache = new Map<string, Result>()
+
+type GetWalletTransactionHistoryParameters = {
+  client: MoralisClient
+  address: string
+  chain: string
+  fromBlock?: number
+  toBlock?: number
+  cursor?: string
+}
+
+export const getWalletTransactionHistory = async ({
+  client,
+  address,
+  chain,
+  fromBlock = 0,
+  toBlock,
+  cursor,
+}: GetWalletTransactionHistoryParameters) => {
+  const path = `/api/v2.2/wallets/${address}/history`
+  const query: Record<string, string> = {
+    chain,
+    from_block: fromBlock.toString(),
+    include_internal_transactions: 'true',
+    order: 'ASC',
+  }
+  if (toBlock !== undefined) {
+    query.to_block = toBlock.toString()
+  }
+  if (cursor !== undefined) {
+    query.cursor = cursor
+  }
+
+  const cacheKey = `${path}?${Object.entries(query)
+    .map(([k, v]) => `${k}=${v}`)
+    .join('&')}`
+  const cached = cache.get(cacheKey)
+  if (cached !== undefined) {
+    return cached
+  }
+
+  const result = await client.get({
+    path,
+    query,
+    resultSchema,
+  })
+  cache.set(cacheKey, result)
+
+  return result
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@0xtorch/evm",
-  "version": "0.0.104",
+  "version": "0.0.106",
   "description": "Cryptorch EVM extension",
   "keywords": [
     "cryptorch",