@0xtorch/evm 0.0.110 → 0.0.112

package/_types/logic/analyzeTransaction/createActions/json/simpleValue.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"simpleValue.d.ts","sourceRoot":"","sources":["../../../../../logic/analyzeTransaction/createActions/json/simpleValue.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAC5B,OAAO,KAAK,EAKV,QAAQ,EACR,kBAAkB,EACnB,MAAM,mBAAmB,CAAA;AAG1B,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAA;AAEjD,eAAO,MAAM,cAAc,+CAIxB;IACD,QAAQ,CAAC,MAAM,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA;IAClD,QAAQ,CAAC,WAAW,EAAE,kBAAkB,CAAA;IACxC,QAAQ,CAAC,gBAAgB,EAAE,GAAG,CAAC,QAAQ,CAAC,CAAA;CACzC,KAAG,MAoXH,CAAA"}
+{"version":3,"file":"simpleValue.d.ts","sourceRoot":"","sources":["../../../../../logic/analyzeTransaction/createActions/json/simpleValue.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAC5B,OAAO,KAAK,EAKV,QAAQ,EACR,kBAAkB,EACnB,MAAM,mBAAmB,CAAA;AAG1B,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAA;AAEjD,eAAO,MAAM,cAAc,+CAIxB;IACD,QAAQ,CAAC,MAAM,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA;IAClD,QAAQ,CAAC,WAAW,EAAE,kBAAkB,CAAA;IACxC,QAAQ,CAAC,gBAAgB,EAAE,GAAG,CAAC,QAAQ,CAAC,CAAA;CACzC,KAAG,MAuXH,CAAA"}

package/_types/logic/analyzeTransaction/createActions/json/transferGenerator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"transferGenerator.d.ts","sourceRoot":"","sources":["../../../../../logic/analyzeTransaction/createActions/json/transferGenerator.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAA;AAC7C,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAC5B,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAA;AAC9C,OAAO,KAAK,EACV,kBAAkB,EAClB,mBAAmB,EACnB,oBAAoB,EACpB,QAAQ,EACR,kBAAkB,EACnB,MAAM,mBAAmB,CAAA;AAU1B,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,UAAU,CAAA;AAEvD,eAAO,MAAM,iBAAiB,gGAQ3B;IACD,QAAQ,CAAC,MAAM,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAA;IACxD,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAA;IACrB,QAAQ,CAAC,WAAW,EAAE,kBAAkB,CAAA;IACxC,QAAQ,CAAC,gBAAgB,EAAE,GAAG,CAAC,QAAQ,CAAC,CAAA;IACxC,QAAQ,CAAC,WAAW,CAAC,EAAE,kBAAkB,CAAA;IACzC,QAAQ,CAAC,YAAY,CAAC,EAAE,mBAAmB,CAAA;IAC3C,QAAQ,CAAC,aAAa,CAAC,EAAE,oBAAoB,CAAA;CAC9C,KAAG,SAAS,QAAQ,EAgMpB,CAAA"}
+{"version":3,"file":"transferGenerator.d.ts","sourceRoot":"","sources":["../../../../../logic/analyzeTransaction/createActions/json/transferGenerator.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAA;AAC7C,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAC5B,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAA;AAC9C,OAAO,KAAK,EACV,kBAAkB,EAClB,mBAAmB,EACnB,oBAAoB,EACpB,QAAQ,EACR,kBAAkB,EACnB,MAAM,mBAAmB,CAAA;AAU1B,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,UAAU,CAAA;AAEvD,eAAO,MAAM,iBAAiB,gGAQ3B;IACD,QAAQ,CAAC,MAAM,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAA;IACxD,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAA;IACrB,QAAQ,CAAC,WAAW,EAAE,kBAAkB,CAAA;IACxC,QAAQ,CAAC,gBAAgB,EAAE,GAAG,CAAC,QAAQ,CAAC,CAAA;IACxC,QAAQ,CAAC,WAAW,CAAC,EAAE,kBAAkB,CAAA;IACzC,QAAQ,CAAC,YAAY,CAAC,EAAE,mBAAmB,CAAA;IAC3C,QAAQ,CAAC,aAAa,CAAC,EAAE,oBAAoB,CAAA;CAC9C,KAAG,SAAS,QAAQ,EAiMpB,CAAA"}

package/_types/logic/analyzeTransaction/createActions/json/verifyTxSatisfiesCondition.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"verifyTxSatisfiesCondition.d.ts","sourceRoot":"","sources":["../../../../../logic/analyzeTransaction/createActions/json/verifyTxSatisfiesCondition.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAKV,QAAQ,EACR,kBAAkB,EACnB,MAAM,mBAAmB,CAAA;AAiB1B,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,QAAQ,CAAA;AAEvC,KAAK,oCAAoC,GAAG;IAC1C,QAAQ,CAAC,WAAW,EAAE,kBAAkB,CAAA;IACxC,QAAQ,CAAC,gBAAgB,EAAE,GAAG,CAAC,QAAQ,CAAC,CAAA;IACxC,QAAQ,CAAC,SAAS,EAAE,SAAS,CAAA;CAC9B,CAAA;AAED,eAAO,MAAM,0BAA0B,kDAIpC,oCAAoC,KAAG,OA4RzC,CAAA"}
+{"version":3,"file":"verifyTxSatisfiesCondition.d.ts","sourceRoot":"","sources":["../../../../../logic/analyzeTransaction/createActions/json/verifyTxSatisfiesCondition.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAKV,QAAQ,EACR,kBAAkB,EACnB,MAAM,mBAAmB,CAAA;AAiB1B,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,QAAQ,CAAA;AAEvC,KAAK,oCAAoC,GAAG;IAC1C,QAAQ,CAAC,WAAW,EAAE,kBAAkB,CAAA;IACxC,QAAQ,CAAC,gBAAgB,EAAE,GAAG,CAAC,QAAQ,CAAC,CAAA;IACxC,QAAQ,CAAC,SAAS,EAAE,SAAS,CAAA;CAC9B,CAAA;AAED,eAAO,MAAM,0BAA0B,kDAIpC,oCAAoC,KAAG,OA6RzC,CAAA"}

package/_types/logic/getAddressIndexData.d.ts

@@ -1,4 +1,5 @@
 import type { Chain } from '../chain';
+import type { Erc20Transfer } from '../types';
 import type { LowerHex } from '../types/hex';
 import type { InternalTransaction } from '../types/internalTransaction';
 import type { TransactionIndex } from '../types/transactionIndex';
@@ -9,8 +10,9 @@ type GetAddressIndexDataParameters = {
     toBlock?: number;
 };
 type GetAddressIndexDataReturnTypes = {
-    readonly transactionIndexes: readonly TransactionIndex[];
-    readonly internalTransactions: readonly InternalTransaction[];
+    transactionIndexes: readonly TransactionIndex[];
+    internalTransactions: readonly InternalTransaction[];
+    erc20Transfers: readonly Erc20Transfer[];
 };
 export declare const getAddressIndexData: ({ chain, address, fromBlock, toBlock, }: GetAddressIndexDataParameters) => Promise<GetAddressIndexDataReturnTypes>;
 export {};

package/_types/logic/getAddressIndexData.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getAddressIndexData.d.ts","sourceRoot":"","sources":["../../logic/getAddressIndexData.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,UAAU,CAAA;AACrC,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA;AAC5C,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,8BAA8B,CAAA;AACvE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAA;AAEjE,KAAK,6BAA6B,GAAG;IACnC,KAAK,EAAE,KAAK,CAAA;IACZ,OAAO,EAAE,QAAQ,CAAA;IACjB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB,CAAA;AAED,KAAK,8BAA8B,GAAG;IACpC,QAAQ,CAAC,kBAAkB,EAAE,SAAS,gBAAgB,EAAE,CAAA;IACxD,QAAQ,CAAC,oBAAoB,EAAE,SAAS,mBAAmB,EAAE,CAAA;CAC9D,CAAA;AAED,eAAO,MAAM,mBAAmB,4CAK7B,6BAA6B,KAAG,OAAO,CAAC,8BAA8B,CA6CxE,CAAA"}
+{"version":3,"file":"getAddressIndexData.d.ts","sourceRoot":"","sources":["../../logic/getAddressIndexData.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,UAAU,CAAA;AACrC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,UAAU,CAAA;AAC7C,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA;AAC5C,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,8BAA8B,CAAA;AACvE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAA;AAEjE,KAAK,6BAA6B,GAAG;IACnC,KAAK,EAAE,KAAK,CAAA;IACZ,OAAO,EAAE,QAAQ,CAAA;IACjB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB,CAAA;AAED,KAAK,8BAA8B,GAAG;IACpC,kBAAkB,EAAE,SAAS,gBAAgB,EAAE,CAAA;IAC/C,oBAAoB,EAAE,SAAS,mBAAmB,EAAE,CAAA;IACpD,cAAc,EAAE,SAAS,aAAa,EAAE,CAAA;CACzC,CAAA;AAED,eAAO,MAAM,mBAAmB,4CAK7B,6BAA6B,KAAG,OAAO,CAAC,8BAA8B,CAiDxE,CAAA"}

package/_types/logic/getTransactionDetail/index.d.ts

@@ -7,7 +7,9 @@ type GetTransactionDetailParameters = {
     timestamp?: number;
     internalTransactions?: readonly InternalTransaction[];
     timeout?: number;
+    input?: LowerHex;
+    value?: bigint;
 };
-export declare const getTransactionDetail: ({ chain, hash, timestamp: optionalTimestamp, internalTransactions, timeout, }: GetTransactionDetailParameters) => Promise<TransactionDetail>;
+export declare const getTransactionDetail: ({ chain, hash, timestamp: optionalTimestamp, internalTransactions, timeout, input, value, }: GetTransactionDetailParameters) => Promise<TransactionDetail>;
 export {};
 //# sourceMappingURL=index.d.ts.map

package/_types/logic/getTransactionDetail/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../logic/getTransactionDetail/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,aAAa,CAAA;AACxC,OAAO,EACL,KAAK,mBAAmB,EACxB,KAAK,QAAQ,EAEd,MAAM,aAAa,CAAA;AACpB,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,+BAA+B,CAAA;AAGtE,KAAK,8BAA8B,GAAG;IACpC,KAAK,EAAE,KAAK,CAAA;IACZ,IAAI,EAAE,QAAQ,CAAA;IACd,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,oBAAoB,CAAC,EAAE,SAAS,mBAAmB,EAAE,CAAA;IACrD,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB,CAAA;AAED,eAAO,MAAM,oBAAoB,kFAM9B,8BAA8B,KAAG,OAAO,CAAC,iBAAiB,CAiD5D,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../logic/getTransactionDetail/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,aAAa,CAAA;AACxC,OAAO,EACL,KAAK,mBAAmB,EACxB,KAAK,QAAQ,EAEd,MAAM,aAAa,CAAA;AACpB,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,+BAA+B,CAAA;AAGtE,KAAK,8BAA8B,GAAG;IACpC,KAAK,EAAE,KAAK,CAAA;IACZ,IAAI,EAAE,QAAQ,CAAA;IACd,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,oBAAoB,CAAC,EAAE,SAAS,mBAAmB,EAAE,CAAA;IACrD,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,KAAK,CAAC,EAAE,QAAQ,CAAA;IAChB,KAAK,CAAC,EAAE,MAAM,CAAA;CACf,CAAA;AAED,eAAO,MAAM,oBAAoB,gGAQ9B,8BAA8B,KAAG,OAAO,CAAC,iBAAiB,CAsD5D,CAAA"}

package/_types/types/transactionIndex.d.ts

@@ -1,5 +1,5 @@
 import type { z } from 'zod';
-declare const transactionIndexSchema: z.ZodObject<Pick<{
+declare const transactionIndexSchema: z.ZodObject<z.objectUtil.extendShape<Pick<{
     blockNumber: z.ZodNumber;
     chainId: z.ZodNumber;
     contractAddress: z.ZodOptional<z.ZodEffects<z.ZodString, `0x${Lowercase<string>}`, string>>;
@@ -147,14 +147,21 @@ declare const transactionIndexSchema: z.ZodObject<Pick<{
     timestamp: z.ZodNumber;
     to: z.ZodOptional<z.ZodEffects<z.ZodString, `0x${Lowercase<string>}`, string>>;
     value: z.ZodEffects<z.ZodString, bigint, string>;
-}, "hash" | "blockNumber" | "timestamp">, "strip", z.ZodTypeAny, {
+}, "hash" | "blockNumber" | "timestamp">, {
+    input: z.ZodOptional<z.ZodEffects<z.ZodString, `0x${Lowercase<string>}`, string>>;
+    value: z.ZodOptional<z.ZodEffects<z.ZodString, bigint, string>>;
+}>, "strip", z.ZodTypeAny, {
     hash: `0x${Lowercase<string>}`;
     blockNumber: number;
     timestamp: number;
+    value?: bigint | undefined;
+    input?: `0x${Lowercase<string>}` | undefined;
 }, {
     hash: string;
     blockNumber: number;
     timestamp: number;
+    value?: string | undefined;
+    input?: string | undefined;
 }>;
 export type TransactionIndex = z.infer<typeof transactionIndexSchema>;
 export {};

package/_types/types/transactionIndex.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"transactionIndex.d.ts","sourceRoot":"","sources":["../../types/transactionIndex.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAG5B,QAAA,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAI1B,CAAA;AAEF,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA"}
+{"version":3,"file":"transactionIndex.d.ts","sourceRoot":"","sources":["../../types/transactionIndex.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAI5B,QAAA,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EASxB,CAAA;AAEJ,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA"}

package/explorer/blockscout/create.ts

@@ -1,4 +1,4 @@
-import type { LowerHex } from '../../types'
+import type { Erc20Transfer, LowerHex } from '../../types'
 import type { InternalTransactionWithIndex } from '../../types/internalTransaction'
 import type { TransactionIndex } from '../../types/transactionIndex'
 import { createInternalTransactionId } from '../../utils/createInternalTransactionId'
@@ -104,29 +104,37 @@ export const createBlockscout = ({
       headers,
     }) => {
       const indexes = new Map<LowerHex, TransactionIndex>()
+      const erc20Transfers: Erc20Transfer[] = []
       let startblock = fromBlock
       const endblock = toBlock
       const maxPageSize = 10_000
       while (true) {
-        const result = await getTokenTransferEventsByAddress({
-          client,
-          address,
-          startblock,
-          endblock,
-          headers,
-        })
-        for (const index of result) {
+        const { indexes: resultIndexes, erc20Transfers: resultErc20Transfers } =
+          await getTokenTransferEventsByAddress({
+            client,
+            address,
+            startblock,
+            endblock,
+            headers,
+          })
+        for (const index of resultIndexes) {
           if (!indexes.has(index.hash)) {
             indexes.set(index.hash, index)
           }
         }
-        if (result.length < maxPageSize) {
+        erc20Transfers.push(...resultErc20Transfers)
+        if (resultIndexes.length < maxPageSize) {
           break
         }
-        const maxBlockNumber = Math.max(...result.map((x) => x.blockNumber))
+        const maxBlockNumber = Math.max(
+          ...resultIndexes.map((x) => x.blockNumber),
+        )
         startblock = maxBlockNumber
       }
-      return [...indexes.values()]
+      return {
+        indexes: [...indexes.values()],
+        erc20Transfers,
+      }
     },
     getBlockNumberOfTimestamp: ({ timestamp, headers }) =>
       getBlockNumberByTimestamp({

package/explorer/blockscout/getTokenTransferEventsByAddress.ts

@@ -1,5 +1,6 @@
 import { z } from 'zod'
-import { lowerHexSchema } from '../../types/primitive'
+import type { Erc20Transfer } from '../../types'
+import { bigintTextSchema, lowerHexSchema } from '../../types/primitive'
 import type { TransactionIndex } from '../../types/transactionIndex'
 import type { BlockscoutClient } from './client'
 
@@ -18,6 +19,21 @@ const transferSchema = z.object({
   blockNumber: z.string().regex(/^\d+$/).transform(Number),
   hash: lowerHexSchema,
   timeStamp: z.string().regex(/^\d+$/).transform(Number),
+  contractAddress: lowerHexSchema,
+  from: lowerHexSchema,
+  to: lowerHexSchema,
+  logIndex: z.string().regex(/^\d+$/).transform(Number),
+  tokenDecimal: z
+    .union([
+      z.literal('').transform(() => undefined),
+      z.string().regex(/^\d+$/).transform(Number),
+    ])
+    .nullable()
+    .optional(),
+  value: z
+    .union([z.literal('').transform(() => undefined), bigintTextSchema])
+    .nullable()
+    .optional(),
 })
 const resultSchema = z.array(transferSchema)
 
@@ -31,9 +47,10 @@ export const getTokenTransferEventsByAddress = async ({
   offset = 10_000,
   sort = 'asc',
   headers,
-}: GetTokenTransferEventsByAddressParameters): Promise<
-  readonly TransactionIndex[]
-> => {
+}: GetTokenTransferEventsByAddressParameters): Promise<{
+  indexes: readonly TransactionIndex[]
+  erc20Transfers: readonly Erc20Transfer[]
+}> => {
   try {
     const result = await client.get({
       path: '',
@@ -54,17 +71,42 @@ export const getTokenTransferEventsByAddress = async ({
       resultSchema,
       headers,
     })
-    return result.map((v) => ({
-      blockNumber: v.blockNumber,
-      hash: v.hash,
-      timestamp: v.timeStamp * 1000,
-    }))
+    const indexes: TransactionIndex[] = []
+    const transfers: Erc20Transfer[] = []
+    for (const data of result) {
+      indexes.push({
+        blockNumber: data.blockNumber,
+        hash: data.hash,
+        timestamp: data.timeStamp * 1000,
+      })
+      if (
+        data.tokenDecimal !== null &&
+        data.tokenDecimal !== undefined &&
+        data.value !== null &&
+        data.value !== undefined
+      ) {
+        transfers.push({
+          address: data.contractAddress,
+          from: data.from,
+          logIndex: data.logIndex,
+          to: data.to,
+          value: data.value,
+        })
+      }
+    }
+    return {
+      indexes,
+      erc20Transfers: transfers,
+    }
   } catch (error) {
     if (
       error instanceof Error &&
       error.message === 'No token transfers found'
     ) {
-      return []
+      return {
+        indexes: [],
+        erc20Transfers: [],
+      }
     }
     throw error
   }

package/explorer/blockscout/getTransactionsByAddress.ts

@@ -1,6 +1,6 @@
 import { z } from 'zod'
 import type { Hex } from '../../types'
-import { lowerHexSchema } from '../../types/primitive'
+import { bigintTextSchema, lowerHexSchema } from '../../types/primitive'
 import type { TransactionIndex } from '../../types/transactionIndex'
 import type { BlockscoutClient } from './client'
 
@@ -19,6 +19,8 @@ const transactionSchema = z.object({
   blockNumber: z.string().regex(/^\d+$/).transform(Number),
   hash: lowerHexSchema,
   timeStamp: z.string().regex(/^\d+$/).transform(Number),
+  input: lowerHexSchema,
+  value: bigintTextSchema,
 })
 const resultSchema = z.array(transactionSchema)
 
@@ -57,6 +59,8 @@ export const getTransactionsByAddress = async ({
       blockNumber: v.blockNumber,
       hash: v.hash,
       timestamp: v.timeStamp * 1000,
+      input: v.input,
+      value: v.value,
     }))
   } catch (error) {
     if (error instanceof Error && error.message === 'No transactions found') {

package/explorer/etherscan/client.ts

@@ -130,7 +130,12 @@ export const createEtherscanClient = ({
           await new Promise((resolve) => setTimeout(resolve, 5000))
           return get({ path, query, resultSchema }, repeat + 1)
         }
-        if (error.message.includes('429')) {
+        if (
+          error.message.includes('429') ||
+          error.message.includes(
+            'Unexpected error, timeout or server too busy. Please try again later',
+          )
+        ) {
           console.debug(error)
           await new Promise((resolve) => setTimeout(resolve, 10_000))
           return await get({ path, query, resultSchema }, repeat + 1)

package/explorer/etherscan/create.ts

@@ -1,4 +1,4 @@
-import type { LowerHex } from '../../types'
+import type { Erc20Transfer, LowerHex } from '../../types'
 import type { InternalTransactionWithIndex } from '../../types/internalTransaction'
 import type { TransactionIndex } from '../../types/transactionIndex'
 import { createInternalTransactionId } from '../../utils/createInternalTransactionId'
@@ -114,28 +114,33 @@ export const createEtherscan = ({
       headers,
     }) => {
       const indexes = new Map<LowerHex, TransactionIndex>()
+      const erc20Transfers: Erc20Transfer[] = []
       const endblock = toBlock
 
       // ERC20
       let startblock = fromBlock
       while (true) {
-        const result = await getListOfErc20TokenTransferEventsByAddress({
-          client,
-          address,
-          startblock,
-          endblock,
-          offset: pageSize,
-          headers,
-        })
-        for (const index of result) {
+        const { indexes: resultIndexes, erc20Transfers: resultErc20Transfers } =
+          await getListOfErc20TokenTransferEventsByAddress({
+            client,
+            address,
+            startblock,
+            endblock,
+            offset: pageSize,
+            headers,
+          })
+        for (const index of resultIndexes) {
           if (!indexes.has(index.hash)) {
             indexes.set(index.hash, index)
           }
         }
-        if (result.length < pageSize) {
+        erc20Transfers.push(...resultErc20Transfers)
+        if (resultIndexes.length < pageSize) {
           break
         }
-        const maxBlockNumber = Math.max(...result.map((x) => x.blockNumber))
+        const maxBlockNumber = Math.max(
+          ...resultIndexes.map((x) => x.blockNumber),
+        )
         startblock = maxBlockNumber
       }
 
@@ -185,7 +190,10 @@ export const createEtherscan = ({
         startblock = maxBlockNumber
       }
 
-      return [...indexes.values()]
+      return {
+        indexes: [...indexes.values()],
+        erc20Transfers,
+      }
     },
     getBlockNumberOfTimestamp: ({ timestamp, headers }): Promise<number> =>
       getBlockNumberByTimestamp({

package/explorer/etherscan/getListOfErc20TokenTransferEventsByAddress.ts

@@ -1,5 +1,6 @@
 import { z } from 'zod'
-import { lowerHexSchema } from '../../types/primitive'
+import type { Erc20Transfer } from '../../types'
+import { bigintTextSchema, lowerHexSchema } from '../../types/primitive'
 import type { TransactionIndex } from '../../types/transactionIndex'
 import type { EtherscanClient } from './client'
 
@@ -18,6 +19,10 @@ const transferSchema = z.object({
   blockNumber: z.string().regex(/^\d+$/).transform(Number),
   hash: lowerHexSchema,
   timeStamp: z.string().regex(/^\d+$/).transform(Number),
+  contractAddress: lowerHexSchema,
+  from: lowerHexSchema,
+  to: lowerHexSchema,
+  value: bigintTextSchema,
 })
 const resultSchema = z.array(transferSchema)
 
@@ -31,9 +36,10 @@ export const getListOfErc20TokenTransferEventsByAddress = async ({
   offset = 10_000,
   sort = 'asc',
   headers,
-}: GetListOfErc20TokenTransferEventsByAddressParameters): Promise<
-  TransactionIndex[]
-> => {
+}: GetListOfErc20TokenTransferEventsByAddressParameters): Promise<{
+  indexes: readonly TransactionIndex[]
+  erc20Transfers: readonly Erc20Transfer[]
+}> => {
   try {
     const result = await client.get({
       path: '',
@@ -54,14 +60,32 @@ export const getListOfErc20TokenTransferEventsByAddress = async ({
       resultSchema,
       headers,
     })
-    return result.map((v) => ({
-      blockNumber: v.blockNumber,
-      hash: v.hash,
-      timestamp: v.timeStamp * 1000,
-    }))
+    const indexes: TransactionIndex[] = []
+    const transfers: Erc20Transfer[] = []
+    for (const data of result) {
+      indexes.push({
+        blockNumber: data.blockNumber,
+        hash: data.hash,
+        timestamp: data.timeStamp * 1000,
+      })
+      transfers.push({
+        address: data.contractAddress,
+        from: data.from,
+        logIndex: 0,
+        to: data.to,
+        value: data.value,
+      })
+    }
+    return {
+      indexes,
+      erc20Transfers: transfers,
+    }
   } catch (error) {
     if (error instanceof Error && error.message === 'No transactions found') {
-      return []
+      return {
+        indexes: [],
+        erc20Transfers: [],
+      }
     }
     throw error
   }

package/explorer/etherscan/getListOfNormalTransactionsByAddress.ts

@@ -1,6 +1,6 @@
 import { z } from 'zod'
 import type { Hex } from '../../types'
-import { lowerHexSchema } from '../../types/primitive'
+import { bigintTextSchema, lowerHexSchema } from '../../types/primitive'
 import type { TransactionIndex } from '../../types/transactionIndex'
 import type { EtherscanClient } from './client'
 
@@ -19,6 +19,8 @@ const transactionSchema = z.object({
   blockNumber: z.string().regex(/^\d+$/).transform(Number),
   hash: lowerHexSchema,
   timeStamp: z.string().regex(/^\d+$/).transform(Number),
+  input: lowerHexSchema,
+  value: bigintTextSchema,
 })
 const resultSchema = z.array(transactionSchema)
 
@@ -59,6 +61,8 @@ export const getListOfNormalTransactionsByAddress = async ({
       blockNumber: v.blockNumber,
       hash: v.hash,
       timestamp: v.timeStamp * 1000,
+      input: v.input,
+      value: v.value,
     }))
   } catch (error) {
     if (error instanceof Error && error.message === 'No transactions found') {

package/explorer/moralis/create.ts

@@ -1,4 +1,5 @@
 import {
+  type Erc20Transfer,
   type InternalTransactionWithIndex,
   type LowerHex,
   type TransactionIndex,
@@ -123,6 +124,7 @@ export const createMoralisExplorer = ({
               hash: transaction.hash,
               blockNumber: transaction.block_number,
               timestamp: transaction.block_timestamp,
+              value: transaction.value,
             }
             indexes.set(data.hash, data)
           }
@@ -140,9 +142,10 @@ export const createMoralisExplorer = ({
       fromBlock,
       toBlock,
       headers,
-    }): Promise<TransactionIndex[]> => {
+    }) => {
       const lowerAddress = toLowerHex(address)
       const indexes = new Map<LowerHex, TransactionIndex>()
+      const erc20Transfers: Erc20Transfer[] = []
 
       let count = 0
       let cursor: string | undefined = undefined
@@ -165,9 +168,20 @@ export const createMoralisExplorer = ({
               hash: transaction.hash,
               blockNumber: transaction.block_number,
               timestamp: transaction.block_timestamp,
+              value: transaction.value,
             }
             indexes.set(data.hash, data)
           }
+
+          for (const transfer of transaction.erc20_transfers) {
+            erc20Transfers.push({
+              address: transfer.address,
+              from: transfer.from_address,
+              logIndex: transfer.log_index,
+              to: transfer.to_address,
+              value: transfer.value,
+            })
+          }
         }
 
         if (result.result.length < limit) {
@@ -175,7 +189,10 @@ export const createMoralisExplorer = ({
         }
       }
 
-      return [...indexes.values()]
+      return {
+        indexes: [...indexes.values()],
+        erc20Transfers,
+      }
     },
     getBlockNumberOfTimestamp: (): Promise<number> => {
       throw new Error('Function not implemented.')

package/explorer/moralis/getWalletTransactionHistory.ts

@@ -80,7 +80,9 @@ const transactionSchema = z.object({
       to_address: lowerHexSchema,
       // "to_address_label": null,
       // "address": "0xc99a6a985ed2cac1ef41640596c5a5f9f4e19ef5",
+      address: lowerHexSchema,
       // "log_index": 37,
+      log_index: z.number().int(),
       // "value": "6851147569444444",
       value: bigintTextSchema,
       // "possible_spam": false,

package/explorer/types.ts

@@ -1,4 +1,4 @@
-import type { Hex, LowerHex } from '../types'
+import type { Erc20Transfer, Hex, LowerHex } from '../types'
 import type { InternalTransactionWithIndex } from '../types/internalTransaction'
 import type { Log } from '../types/log'
 import type { TransactionIndex } from '../types/transactionIndex'
@@ -50,7 +50,10 @@ type FunctionGetAddressTokenTransferIndexes = (parameters: {
   fromBlock?: number
   toBlock?: number
   headers?: Record<string, string>
-}) => Promise<TransactionIndex[]>
+}) => Promise<{
+  indexes: TransactionIndex[]
+  erc20Transfers: Erc20Transfer[]
+}>
 
 type FunctionGetBlockNumberOfTimestamp = (parameters: {
   /** Unix timestamp in milliseconds */

package/logic/analyzeTransaction/createActions/json/allValue.ts

@@ -48,6 +48,7 @@ export const getAllValue = ({
     case 'function':
     case 'value':
     case 'chain-id':
+    case 'tx-hash':
     case 'from':
     case 'to':
     case 'log':

package/logic/analyzeTransaction/createActions/json/erc1155Pattern.ts

@@ -95,6 +95,7 @@ export const checkTransferIsMatchErc1155Pattern = ({
         case 'join':
         case 'slice':
         case 'chain-id':
+        case 'tx-hash':
         case 'from':
         case 'to':
         case 'log':

package/logic/analyzeTransaction/createActions/json/erc20Pattern.ts

@@ -85,6 +85,7 @@ export const checkTransferIsMatchErc20Pattern = ({
         case 'join':
         case 'slice':
         case 'chain-id':
+        case 'tx-hash':
         case 'log':
         case 'erc20':
         case 'erc721':

package/logic/analyzeTransaction/createActions/json/internalTransferGenerator.ts

@@ -129,6 +129,7 @@ const checkInternalTransactionIsMatchPattern = ({
         case 'slice':
         case 'math':
         case 'chain-id':
+        case 'tx-hash':
         case 'from':
         case 'to':
         case 'log':

package/logic/analyzeTransaction/createActions/json/join.ts

@@ -42,6 +42,7 @@ export const getJoinValue = ({
       case 'function':
       case 'value':
       case 'chain-id':
+      case 'tx-hash':
       case 'from':
       case 'to':
       case 'log':

package/logic/analyzeTransaction/createActions/json/schema.ts

@@ -40,6 +40,10 @@ const chainIdValueSchema = z.object({
   type: z.literal('chain-id'),
 })
 
+const txHashValueSchema = z.object({
+  type: z.literal('tx-hash'),
+})
+
 const fromValueSchema = z.object({
   type: z.literal('from'),
 })
@@ -141,6 +145,7 @@ const erc1155ValueSchema = z.object({
 export const simpleValueSchema = z.union([
   z.string(),
   chainIdValueSchema,
+  txHashValueSchema,
   fromValueSchema,
   toValueSchema,
   valueValueSchema,

package/logic/analyzeTransaction/createActions/json/simpleValue.ts

@@ -30,6 +30,9 @@ export const getSimpleValue = ({
     case 'chain-id': {
       return transaction.chainId.toString()
     }
+    case 'tx-hash': {
+      return transaction.hash
+    }
     case 'from': {
       return transaction.from.address
     }

package/logic/analyzeTransaction/createActions/json/transferGenerator.ts

@@ -91,6 +91,7 @@ export const generateTransfers = ({
             case 'join':
             case 'slice':
             case 'chain-id':
+            case 'tx-hash':
             case 'log':
             case 'erc20':
             case 'erc721':

package/logic/analyzeTransaction/createActions/json/verifyTxSatisfiesCondition.ts

@@ -167,6 +167,7 @@ export const verifyTxSatisfiesCondition = ({
           case 'slice':
           case 'join':
           case 'chain-id':
+          case 'tx-hash':
           case 'log':
           case 'erc20':
           case 'erc721':
@@ -409,6 +410,7 @@ const verifyLogsSatisfiesExactCondition = ({
           case 'join':
           case 'slice':
           case 'chain-id':
+          case 'tx-hash':
           case 'log':
           case 'erc20':
           case 'erc721':
@@ -520,6 +522,7 @@ const verifyLogsSatisfiesSomeCondition = ({
             case 'join':
             case 'slice':
             case 'chain-id':
+            case 'tx-hash':
             case 'log':
             case 'erc20':
             case 'erc721':