@sentio/sdk 2.40.0-rc.5 → 2.40.0-rc.6

package/lib/{chunk-S727P6WP.js → chunk-SYEQKTIU.js}

@@ -23,7 +23,7 @@ import {
   u32,
   wrapConstructor,
   wrapXOFConstructorWithOpts
-} from "./chunk-USETTWR7.js";
+} from "./chunk-Z5PQR6UE.js";
 import {
   __export
 } from "./chunk-AXRHIURD.js";

package/lib/{chunk-7OBRGY7G.js → chunk-YNJXNOVA.js}

@@ -22,7 +22,7 @@ import {
   normalizeLabels,
   processGqlReceipt,
   require_lib2 as require_lib
-} from "./chunk-KA5CLZU6.js";
+} from "./chunk-7NWX3CH7.js";
 import {
   arrayify,
   bn
@@ -35,7 +35,7 @@ import {
   USER_PROCESSOR,
   errorString,
   mergeProcessResults
-} from "./chunk-USETTWR7.js";
+} from "./chunk-Z5PQR6UE.js";
 import {
   __publicField,
   __toESM

package/lib/{chunk-N4OQDWM2.js → chunk-YOLIZKGZ.js}

@@ -15,7 +15,7 @@ import {
   u32,
   u64_default,
   wrapConstructorWithOpts
-} from "./chunk-USETTWR7.js";
+} from "./chunk-Z5PQR6UE.js";
 import {
   __commonJS,
   __toESM

package/lib/{chunk-USETTWR7.js → chunk-Z5PQR6UE.js}

@@ -1,6 +1,6 @@
 import { createRequire as createRequireSdkShim } from 'module'; const require = createRequireSdkShim(import.meta.url);
 
-// ../runtime/lib/chunk-FGIYODHE.js
+// ../runtime/lib/chunk-FFU5RYDX.js
 import { createRequire as createRequireShim } from "module";
 import { AsyncLocalStorage } from "async_hooks";
 import * as process2 from "process";
@@ -47470,9 +47470,75 @@ var ProcessResult = {
   }
 };
 function createBaseEthCallParam() {
-  return { chainId: "", address: "", function: "", signature: "", args: [] };
+  return { context: void 0, calldata: "" };
 }
 var EthCallParam = {
+  encode(message, writer = import_minimal5.default.Writer.create()) {
+    if (message.context !== void 0) {
+      EthCallContext.encode(message.context, writer.uint32(10).fork()).ldelim();
+    }
+    if (message.calldata !== "") {
+      writer.uint32(18).string(message.calldata);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof import_minimal5.default.Reader ? input : import_minimal5.default.Reader.create(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseEthCallParam();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+          message.context = EthCallContext.decode(reader, reader.uint32());
+          continue;
+        case 2:
+          if (tag !== 18) {
+            break;
+          }
+          message.calldata = reader.string();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object2) {
+    return {
+      context: isSet3(object2.context) ? EthCallContext.fromJSON(object2.context) : void 0,
+      calldata: isSet3(object2.calldata) ? globalThis.String(object2.calldata) : ""
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.context !== void 0) {
+      obj.context = EthCallContext.toJSON(message.context);
+    }
+    if (message.calldata !== "") {
+      obj.calldata = message.calldata;
+    }
+    return obj;
+  },
+  create(base) {
+    return EthCallParam.fromPartial(base ?? {});
+  },
+  fromPartial(object2) {
+    const message = createBaseEthCallParam();
+    message.context = object2.context !== void 0 && object2.context !== null ? EthCallContext.fromPartial(object2.context) : void 0;
+    message.calldata = object2.calldata ?? "";
+    return message;
+  }
+};
+function createBaseEthCallContext() {
+  return { chainId: "", address: "", blockTag: "" };
+}
+var EthCallContext = {
   encode(message, writer = import_minimal5.default.Writer.create()) {
     if (message.chainId !== "") {
       writer.uint32(10).string(message.chainId);
@@ -47480,21 +47546,15 @@ var EthCallParam = {
     if (message.address !== "") {
       writer.uint32(18).string(message.address);
     }
-    if (message.function !== "") {
-      writer.uint32(26).string(message.function);
-    }
-    if (message.signature !== "") {
-      writer.uint32(34).string(message.signature);
-    }
-    for (const v of message.args) {
-      Value.encode(Value.wrap(v), writer.uint32(42).fork()).ldelim();
+    if (message.blockTag !== "") {
+      writer.uint32(26).string(message.blockTag);
     }
     return writer;
   },
   decode(input, length) {
     const reader = input instanceof import_minimal5.default.Reader ? input : import_minimal5.default.Reader.create(input);
     let end = length === void 0 ? reader.len : reader.pos + length;
-    const message = createBaseEthCallParam();
+    const message = createBaseEthCallContext();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
@@ -47514,19 +47574,7 @@ var EthCallParam = {
           if (tag !== 26) {
             break;
           }
-          message.function = reader.string();
-          continue;
-        case 4:
-          if (tag !== 34) {
-            break;
-          }
-          message.signature = reader.string();
-          continue;
-        case 5:
-          if (tag !== 42) {
-            break;
-          }
-          message.args.push(Value.unwrap(Value.decode(reader, reader.uint32())));
+          message.blockTag = reader.string();
           continue;
       }
       if ((tag & 7) === 4 || tag === 0) {
@@ -47540,9 +47588,7 @@ var EthCallParam = {
     return {
       chainId: isSet3(object2.chainId) ? globalThis.String(object2.chainId) : "",
       address: isSet3(object2.address) ? globalThis.String(object2.address) : "",
-      function: isSet3(object2.function) ? globalThis.String(object2.function) : "",
-      signature: isSet3(object2.signature) ? globalThis.String(object2.signature) : "",
-      args: globalThis.Array.isArray(object2?.args) ? [...object2.args] : []
+      blockTag: isSet3(object2.blockTag) ? globalThis.String(object2.blockTag) : ""
     };
   },
   toJSON(message) {
@@ -47553,27 +47599,19 @@ var EthCallParam = {
     if (message.address !== "") {
       obj.address = message.address;
     }
-    if (message.function !== "") {
-      obj.function = message.function;
-    }
-    if (message.signature !== "") {
-      obj.signature = message.signature;
-    }
-    if (message.args?.length) {
-      obj.args = message.args;
+    if (message.blockTag !== "") {
+      obj.blockTag = message.blockTag;
     }
     return obj;
   },
   create(base) {
-    return EthCallParam.fromPartial(base ?? {});
+    return EthCallContext.fromPartial(base ?? {});
   },
   fromPartial(object2) {
-    const message = createBaseEthCallParam();
+    const message = createBaseEthCallContext();
     message.chainId = object2.chainId ?? "";
     message.address = object2.address ?? "";
-    message.function = object2.function ?? "";
-    message.signature = object2.signature ?? "";
-    message.args = object2.args?.map((e) => e) || [];
+    message.blockTag = object2.blockTag ?? "";
     return message;
   }
 };
@@ -58358,6 +58396,13 @@ function errorString(e) {
   return e.message + "\n" + e.stack;
 }
 var USER_PROCESSOR = "user_processor";
+function makeEthCallKey(param) {
+  if (!param.context) {
+    throw new Error("null context for eth call");
+  }
+  const { chainId, address, blockTag } = param.context;
+  return `${chainId}|${address}|${blockTag}|${param.calldata}`;
+}
 var _Endpoints = class {
   concurrency = 8;
   chainQueryAPI = "";
@@ -77073,6 +77118,7 @@ var ProcessorServiceImpl = class {
   // private processorConfig: ProcessConfigResponse
   loader;
   shutdownHandler;
+  preprocessedEthCalls;
   constructor(loader, shutdownHandler) {
     this.loader = loader;
     this.shutdownHandler = shutdownHandler;
@@ -77133,7 +77179,7 @@ var ProcessorServiceImpl = class {
     };
   }
   async preprocessBindings(bindings, dbContext, options) {
-    console.log(`preprocessBindings start, bindings: ${bindings.length}`);
+    console.debug(`preprocessBindings start, bindings: ${bindings.length}`);
     const promises = [];
     for (const binding of bindings) {
       promises.push(this.preprocessBinding(binding, dbContext, options));
@@ -77144,7 +77190,7 @@ var ProcessorServiceImpl = class {
     } catch (e) {
       throw e;
     }
-    console.log(
+    console.debug(
       "ethCallParams: ",
       preprocessResults.map((r) => r.ethCallParams)
     );
@@ -77152,10 +77198,11 @@ var ProcessorServiceImpl = class {
     const providers2 = /* @__PURE__ */ new Map();
     for (const result of preprocessResults) {
       for (const param of result.ethCallParams) {
-        if (!providers2.has(param.chainId)) {
-          providers2.set(param.chainId, getProvider2(param.chainId));
+        const { chainId, address, blockTag } = param.context;
+        if (!providers2.has(chainId)) {
+          providers2.set(chainId, getProvider2(chainId));
         }
-        const key = param.chainId + "|" + param.address;
+        const key = [chainId, address, blockTag].join("|");
         if (!groupedRequests.has(key)) {
           groupedRequests.set(key, []);
         }
@@ -77165,15 +77212,15 @@ var ProcessorServiceImpl = class {
     const start = Date.now();
     const callPromises = [];
     for (const params of groupedRequests.values()) {
-      console.log(`chain: ${params[0].chainId}, address: ${params[0].address}, totalCalls: ${params.length}`);
+      const { chainId, address, blockTag } = params[0].context;
+      console.log(`chain: ${chainId}, address: ${address}, blockTag: ${blockTag}, totalCalls: ${params.length}`);
       for (const param of params) {
-        const frag = new Interface([param.signature]);
-        const calldata = frag.encodeFunctionData(param.function, param.args);
         callPromises.push(
-          providers2.get(param.chainId).call({
-            to: param.address,
-            data: calldata
-          }).then((ret) => [calldata, frag.decodeFunctionResult(param.function, ret).toArray()])
+          providers2.get(chainId).call({
+            to: address,
+            data: param.calldata,
+            blockTag
+          }).then((result) => [makeEthCallKey(param), result])
         );
       }
     }
@@ -77253,11 +77300,9 @@ var ProcessorServiceImpl = class {
           }).catch((e) => {
             console.debug(e);
             dbContext.error(request.processId, e);
-            process_binding_error.add(1);
           }).finally(() => {
             const cost = Date.now() - start;
             console.debug("preprocessBinding", request.processId, " took", cost, "ms");
-            process_binding_time.add(cost);
             contexts.delete(request.processId);
           });
         }
@@ -77670,6 +77715,7 @@ export {
   mergeProcessResults,
   errorString,
   USER_PROCESSOR,
+  makeEthCallKey,
   Endpoints,
   GLOBAL_CONFIG,
   StoreContext,

package/lib/core/index.js

@@ -22,10 +22,10 @@ import {
   scaleDown,
   toBigInteger,
   toMetricValue
-} from "../chunk-KA5CLZU6.js";
+} from "../chunk-7NWX3CH7.js";
 import "../chunk-BQH37WZR.js";
-import "../chunk-S727P6WP.js";
-import "../chunk-USETTWR7.js";
+import "../chunk-SYEQKTIU.js";
+import "../chunk-Z5PQR6UE.js";
 import {
   BigDecimal
 } from "../chunk-3PI3P62P.js";

package/lib/{eacaggregatorproxy-aed46d4a.d.ts → eacaggregatorproxy-cb8e39be.d.ts}

@@ -1,7 +1,7 @@
 import { Interface, BaseContract, Overrides, BigNumberish, Signer, Provider } from 'ethers';
 import { B as BaseProcessor, a as BindOptions, b as BaseProcessorTemplate } from './base-processor-template-51ea121e.js';
 import { T as TypedEvent, a as TypedEventFilter, d as TypedCallTrace, C as ContractView, B as BoundContractView, E as EthContext, c as ContractContext } from './eth-d186c27a.js';
-import { EthFetchConfig, PreprocessResult } from '@sentio/protos';
+import { PreparedData, EthCallContext, EthCallParam, EthFetchConfig, PreprocessResult } from '@sentio/protos';
 import './base-context-05879549.js';
 import { EthChainId } from '@sentio/chain';
 import { ContractRunner, LogParams } from 'ethers/providers';
@@ -154,12 +154,12 @@ interface VersionCallObject {
 type VersionCallTrace = TypedCallTrace<[], VersionCallObject>;
 declare class EACAggregatorProxyContractView extends ContractView<EACAggregatorProxy> {
     constructor(contract: EACAggregatorProxy);
-    accessController(overrides?: Overrides): Promise<string>;
-    aggregator(overrides?: Overrides): Promise<string>;
-    decimals(overrides?: Overrides): Promise<bigint>;
-    description(overrides?: Overrides): Promise<string>;
-    getAnswer(_roundId: BigNumberish, overrides?: Overrides): Promise<bigint>;
-    getRoundData(_roundId: BigNumberish, overrides?: Overrides): Promise<[
+    accessController(overrides?: Overrides, preparedData?: PreparedData, ethCallContext?: EthCallContext): Promise<string>;
+    aggregator(overrides?: Overrides, preparedData?: PreparedData, ethCallContext?: EthCallContext): Promise<string>;
+    decimals(overrides?: Overrides, preparedData?: PreparedData, ethCallContext?: EthCallContext): Promise<bigint>;
+    description(overrides?: Overrides, preparedData?: PreparedData, ethCallContext?: EthCallContext): Promise<string>;
+    getAnswer(_roundId: BigNumberish, overrides?: Overrides, preparedData?: PreparedData, ethCallContext?: EthCallContext): Promise<bigint>;
+    getRoundData(_roundId: BigNumberish, overrides?: Overrides, preparedData?: PreparedData, ethCallContext?: EthCallContext): Promise<[
         bigint,
         bigint,
         bigint,
@@ -172,10 +172,10 @@ declare class EACAggregatorProxyContractView extends ContractView<EACAggregatorP
         updatedAt: bigint;
         answeredInRound: bigint;
     }>;
-    getTimestamp(_roundId: BigNumberish, overrides?: Overrides): Promise<bigint>;
-    latestAnswer(overrides?: Overrides): Promise<bigint>;
-    latestRound(overrides?: Overrides): Promise<bigint>;
-    latestRoundData(overrides?: Overrides): Promise<[
+    getTimestamp(_roundId: BigNumberish, overrides?: Overrides, preparedData?: PreparedData, ethCallContext?: EthCallContext): Promise<bigint>;
+    latestAnswer(overrides?: Overrides, preparedData?: PreparedData, ethCallContext?: EthCallContext): Promise<bigint>;
+    latestRound(overrides?: Overrides, preparedData?: PreparedData, ethCallContext?: EthCallContext): Promise<bigint>;
+    latestRoundData(overrides?: Overrides, preparedData?: PreparedData, ethCallContext?: EthCallContext): Promise<[
         bigint,
         bigint,
         bigint,
@@ -188,12 +188,12 @@ declare class EACAggregatorProxyContractView extends ContractView<EACAggregatorP
         updatedAt: bigint;
         answeredInRound: bigint;
     }>;
-    latestTimestamp(overrides?: Overrides): Promise<bigint>;
-    owner(overrides?: Overrides): Promise<string>;
-    phaseAggregators(arg0: BigNumberish, overrides?: Overrides): Promise<string>;
-    phaseId(overrides?: Overrides): Promise<bigint>;
-    proposedAggregator(overrides?: Overrides): Promise<string>;
-    proposedGetRoundData(_roundId: BigNumberish, overrides?: Overrides): Promise<[
+    latestTimestamp(overrides?: Overrides, preparedData?: PreparedData, ethCallContext?: EthCallContext): Promise<bigint>;
+    owner(overrides?: Overrides, preparedData?: PreparedData, ethCallContext?: EthCallContext): Promise<string>;
+    phaseAggregators(arg0: BigNumberish, overrides?: Overrides, preparedData?: PreparedData, ethCallContext?: EthCallContext): Promise<string>;
+    phaseId(overrides?: Overrides, preparedData?: PreparedData, ethCallContext?: EthCallContext): Promise<bigint>;
+    proposedAggregator(overrides?: Overrides, preparedData?: PreparedData, ethCallContext?: EthCallContext): Promise<string>;
+    proposedGetRoundData(_roundId: BigNumberish, overrides?: Overrides, preparedData?: PreparedData, ethCallContext?: EthCallContext): Promise<[
         bigint,
         bigint,
         bigint,
@@ -206,7 +206,7 @@ declare class EACAggregatorProxyContractView extends ContractView<EACAggregatorP
         updatedAt: bigint;
         answeredInRound: bigint;
     }>;
-    proposedLatestRoundData(overrides?: Overrides): Promise<[
+    proposedLatestRoundData(overrides?: Overrides, preparedData?: PreparedData, ethCallContext?: EthCallContext): Promise<[
         bigint,
         bigint,
         bigint,
@@ -219,14 +219,39 @@ declare class EACAggregatorProxyContractView extends ContractView<EACAggregatorP
         updatedAt: bigint;
         answeredInRound: bigint;
     }>;
-    version(overrides?: Overrides): Promise<bigint>;
+    version(overrides?: Overrides, preparedData?: PreparedData, ethCallContext?: EthCallContext): Promise<bigint>;
     callStatic: {
         contract: EACAggregatorProxy;
-        acceptOwnership(overrides?: Overrides): Promise<void>;
-        confirmAggregator(_aggregator: string, overrides?: Overrides): Promise<void>;
-        proposeAggregator(_aggregator: string, overrides?: Overrides): Promise<void>;
-        setController(_accessController: string, overrides?: Overrides): Promise<void>;
-        transferOwnership(_to: string, overrides?: Overrides): Promise<void>;
+        acceptOwnership(overrides?: Overrides, preparedData?: PreparedData, ethCallContext?: EthCallContext): Promise<void>;
+        confirmAggregator(_aggregator: string, overrides?: Overrides, preparedData?: PreparedData, ethCallContext?: EthCallContext): Promise<void>;
+        proposeAggregator(_aggregator: string, overrides?: Overrides, preparedData?: PreparedData, ethCallContext?: EthCallContext): Promise<void>;
+        setController(_accessController: string, overrides?: Overrides, preparedData?: PreparedData, ethCallContext?: EthCallContext): Promise<void>;
+        transferOwnership(_to: string, overrides?: Overrides, preparedData?: PreparedData, ethCallContext?: EthCallContext): Promise<void>;
+    };
+    encodeCall: {
+        acceptOwnership(ethCallContext: EthCallContext): EthCallParam;
+        accessController(ethCallContext: EthCallContext): EthCallParam;
+        aggregator(ethCallContext: EthCallContext): EthCallParam;
+        confirmAggregator(_aggregator: string, ethCallContext: EthCallContext): EthCallParam;
+        decimals(ethCallContext: EthCallContext): EthCallParam;
+        description(ethCallContext: EthCallContext): EthCallParam;
+        getAnswer(_roundId: BigNumberish, ethCallContext: EthCallContext): EthCallParam;
+        getRoundData(_roundId: BigNumberish, ethCallContext: EthCallContext): EthCallParam;
+        getTimestamp(_roundId: BigNumberish, ethCallContext: EthCallContext): EthCallParam;
+        latestAnswer(ethCallContext: EthCallContext): EthCallParam;
+        latestRound(ethCallContext: EthCallContext): EthCallParam;
+        latestRoundData(ethCallContext: EthCallContext): EthCallParam;
+        latestTimestamp(ethCallContext: EthCallContext): EthCallParam;
+        owner(ethCallContext: EthCallContext): EthCallParam;
+        phaseAggregators(arg0: BigNumberish, ethCallContext: EthCallContext): EthCallParam;
+        phaseId(ethCallContext: EthCallContext): EthCallParam;
+        proposeAggregator(_aggregator: string, ethCallContext: EthCallContext): EthCallParam;
+        proposedAggregator(ethCallContext: EthCallContext): EthCallParam;
+        proposedGetRoundData(_roundId: BigNumberish, ethCallContext: EthCallContext): EthCallParam;
+        proposedLatestRoundData(ethCallContext: EthCallContext): EthCallParam;
+        setController(_accessController: string, ethCallContext: EthCallContext): EthCallParam;
+        transferOwnership(_to: string, ethCallContext: EthCallContext): EthCallParam;
+        version(ethCallContext: EthCallContext): EthCallParam;
     };
 }
 declare class EACAggregatorProxyBoundContractView extends BoundContractView<EACAggregatorProxy, EACAggregatorProxyContractView> {
@@ -305,6 +330,33 @@ declare class EACAggregatorProxyBoundContractView extends BoundContractView<EACA
         setController(_accessController: string, overrides?: Overrides): Promise<void>;
         transferOwnership(_to: string, overrides?: Overrides): Promise<void>;
     };
+    encodeCall: {
+        view: EACAggregatorProxyContractView;
+        context: EthContext;
+        acceptOwnership(overrides?: Overrides): EthCallParam;
+        accessController(overrides?: Overrides): EthCallParam;
+        aggregator(overrides?: Overrides): EthCallParam;
+        confirmAggregator(_aggregator: string, overrides?: Overrides): EthCallParam;
+        decimals(overrides?: Overrides): EthCallParam;
+        description(overrides?: Overrides): EthCallParam;
+        getAnswer(_roundId: BigNumberish, overrides?: Overrides): EthCallParam;
+        getRoundData(_roundId: BigNumberish, overrides?: Overrides): EthCallParam;
+        getTimestamp(_roundId: BigNumberish, overrides?: Overrides): EthCallParam;
+        latestAnswer(overrides?: Overrides): EthCallParam;
+        latestRound(overrides?: Overrides): EthCallParam;
+        latestRoundData(overrides?: Overrides): EthCallParam;
+        latestTimestamp(overrides?: Overrides): EthCallParam;
+        owner(overrides?: Overrides): EthCallParam;
+        phaseAggregators(arg0: BigNumberish, overrides?: Overrides): EthCallParam;
+        phaseId(overrides?: Overrides): EthCallParam;
+        proposeAggregator(_aggregator: string, overrides?: Overrides): EthCallParam;
+        proposedAggregator(overrides?: Overrides): EthCallParam;
+        proposedGetRoundData(_roundId: BigNumberish, overrides?: Overrides): EthCallParam;
+        proposedLatestRoundData(overrides?: Overrides): EthCallParam;
+        setController(_accessController: string, overrides?: Overrides): EthCallParam;
+        transferOwnership(_to: string, overrides?: Overrides): EthCallParam;
+        version(overrides?: Overrides): EthCallParam;
+    };
 }
 type EACAggregatorProxyContext = ContractContext<EACAggregatorProxy, EACAggregatorProxyBoundContractView>;
 declare class EACAggregatorProxyProcessor extends BaseProcessor<EACAggregatorProxy, EACAggregatorProxyBoundContractView> {

package/lib/{erc1155-80a76eb5.d.ts → erc1155-fb097c50.d.ts}

@@ -1,7 +1,7 @@
 import { Interface, BaseContract, BigNumberish, Overrides, BytesLike, Signer, Provider } from 'ethers';
 import { B as BaseProcessor, a as BindOptions, b as BaseProcessorTemplate } from './base-processor-template-51ea121e.js';
 import { T as TypedEvent, a as TypedEventFilter, d as TypedCallTrace, C as ContractView, B as BoundContractView, E as EthContext, c as ContractContext } from './eth-d186c27a.js';
-import { EthFetchConfig, PreprocessResult } from '@sentio/protos';
+import { PreparedData, EthCallContext, EthCallParam, EthFetchConfig, PreprocessResult } from '@sentio/protos';
 import './base-context-05879549.js';
 import { EthChainId } from '@sentio/chain';
 import { ContractRunner, LogParams } from 'ethers/providers';
@@ -132,16 +132,26 @@ interface UriCallObject {
 type UriCallTrace = TypedCallTrace<[bigint], UriCallObject>;
 declare class ERC1155ContractView extends ContractView<ERC1155> {
     constructor(contract: ERC1155);
-    balanceOf(account: string, id: BigNumberish, overrides?: Overrides): Promise<bigint>;
-    balanceOfBatch(accounts: string[], ids: BigNumberish[], overrides?: Overrides): Promise<bigint[]>;
-    isApprovedForAll(account: string, operator: string, overrides?: Overrides): Promise<boolean>;
-    supportsInterface(interfaceId: BytesLike, overrides?: Overrides): Promise<boolean>;
-    uri(id: BigNumberish, overrides?: Overrides): Promise<string>;
+    balanceOf(account: string, id: BigNumberish, overrides?: Overrides, preparedData?: PreparedData, ethCallContext?: EthCallContext): Promise<bigint>;
+    balanceOfBatch(accounts: string[], ids: BigNumberish[], overrides?: Overrides, preparedData?: PreparedData, ethCallContext?: EthCallContext): Promise<bigint[]>;
+    isApprovedForAll(account: string, operator: string, overrides?: Overrides, preparedData?: PreparedData, ethCallContext?: EthCallContext): Promise<boolean>;
+    supportsInterface(interfaceId: BytesLike, overrides?: Overrides, preparedData?: PreparedData, ethCallContext?: EthCallContext): Promise<boolean>;
+    uri(id: BigNumberish, overrides?: Overrides, preparedData?: PreparedData, ethCallContext?: EthCallContext): Promise<string>;
     callStatic: {
         contract: ERC1155;
-        safeBatchTransferFrom(from: string, to: string, ids: BigNumberish[], amounts: BigNumberish[], data: BytesLike, overrides?: Overrides): Promise<void>;
-        safeTransferFrom(from: string, to: string, id: BigNumberish, amount: BigNumberish, data: BytesLike, overrides?: Overrides): Promise<void>;
-        setApprovalForAll(operator: string, approved: boolean, overrides?: Overrides): Promise<void>;
+        safeBatchTransferFrom(from: string, to: string, ids: BigNumberish[], amounts: BigNumberish[], data: BytesLike, overrides?: Overrides, preparedData?: PreparedData, ethCallContext?: EthCallContext): Promise<void>;
+        safeTransferFrom(from: string, to: string, id: BigNumberish, amount: BigNumberish, data: BytesLike, overrides?: Overrides, preparedData?: PreparedData, ethCallContext?: EthCallContext): Promise<void>;
+        setApprovalForAll(operator: string, approved: boolean, overrides?: Overrides, preparedData?: PreparedData, ethCallContext?: EthCallContext): Promise<void>;
+    };
+    encodeCall: {
+        balanceOf(account: string, id: BigNumberish, ethCallContext: EthCallContext): EthCallParam;
+        balanceOfBatch(accounts: string[], ids: BigNumberish[], ethCallContext: EthCallContext): EthCallParam;
+        isApprovedForAll(account: string, operator: string, ethCallContext: EthCallContext): EthCallParam;
+        safeBatchTransferFrom(from: string, to: string, ids: BigNumberish[], amounts: BigNumberish[], data: BytesLike, ethCallContext: EthCallContext): EthCallParam;
+        safeTransferFrom(from: string, to: string, id: BigNumberish, amount: BigNumberish, data: BytesLike, ethCallContext: EthCallContext): EthCallParam;
+        setApprovalForAll(operator: string, approved: boolean, ethCallContext: EthCallContext): EthCallParam;
+        supportsInterface(interfaceId: BytesLike, ethCallContext: EthCallContext): EthCallParam;
+        uri(id: BigNumberish, ethCallContext: EthCallContext): EthCallParam;
     };
 }
 declare class ERC1155BoundContractView extends BoundContractView<ERC1155, ERC1155ContractView> {
@@ -157,6 +167,18 @@ declare class ERC1155BoundContractView extends BoundContractView<ERC1155, ERC115
         safeTransferFrom(from: string, to: string, id: BigNumberish, amount: BigNumberish, data: BytesLike, overrides?: Overrides): Promise<void>;
         setApprovalForAll(operator: string, approved: boolean, overrides?: Overrides): Promise<void>;
     };
+    encodeCall: {
+        view: ERC1155ContractView;
+        context: EthContext;
+        balanceOf(account: string, id: BigNumberish, overrides?: Overrides): EthCallParam;
+        balanceOfBatch(accounts: string[], ids: BigNumberish[], overrides?: Overrides): EthCallParam;
+        isApprovedForAll(account: string, operator: string, overrides?: Overrides): EthCallParam;
+        safeBatchTransferFrom(from: string, to: string, ids: BigNumberish[], amounts: BigNumberish[], data: BytesLike, overrides?: Overrides): EthCallParam;
+        safeTransferFrom(from: string, to: string, id: BigNumberish, amount: BigNumberish, data: BytesLike, overrides?: Overrides): EthCallParam;
+        setApprovalForAll(operator: string, approved: boolean, overrides?: Overrides): EthCallParam;
+        supportsInterface(interfaceId: BytesLike, overrides?: Overrides): EthCallParam;
+        uri(id: BigNumberish, overrides?: Overrides): EthCallParam;
+    };
 }
 type ERC1155Context = ContractContext<ERC1155, ERC1155BoundContractView>;
 declare class ERC1155Processor extends BaseProcessor<ERC1155, ERC1155BoundContractView> {

package/lib/{erc20-39aae019.d.ts → erc20-95ba7721.d.ts}

@@ -1,7 +1,7 @@
 import { Overrides, BigNumberish, Signer, Provider } from 'ethers';
 import { B as BaseProcessor, a as BindOptions, b as BaseProcessorTemplate } from './base-processor-template-51ea121e.js';
 import { d as TypedCallTrace, C as ContractView, B as BoundContractView, E as EthContext, c as ContractContext } from './eth-d186c27a.js';
-import { EthFetchConfig, PreprocessResult } from '@sentio/protos';
+import { PreparedData, EthCallContext, EthCallParam, EthFetchConfig, PreprocessResult } from '@sentio/protos';
 import './base-context-05879549.js';
 import { EthChainId } from '@sentio/chain';
 import { E as ERC20, A as ApprovalEvent, a as ApprovalEventFilter, O as OwnershipTransferredEvent, b as OwnershipTransferredEventFilter, T as TransferEvent, c as TransferEventFilter, d as ApprovalEventObject, e as OwnershipTransferredEventObject, f as TransferEventObject, g as ERC20Interface } from './ERC20-b4312b0c.js';
@@ -107,26 +107,46 @@ type TransferOwnershipCallTrace = TypedCallTrace<[
 ], TransferOwnershipCallObject>;
 declare class ERC20ContractView extends ContractView<ERC20> {
     constructor(contract: ERC20);
-    allowance(owner: string, spender: string, overrides?: Overrides): Promise<bigint>;
-    balanceOf(account: string, overrides?: Overrides): Promise<bigint>;
-    decimals(overrides?: Overrides): Promise<bigint>;
-    locker(overrides?: Overrides): Promise<string>;
-    name(overrides?: Overrides): Promise<string>;
-    owner(overrides?: Overrides): Promise<string>;
-    symbol(overrides?: Overrides): Promise<string>;
-    totalSupply(overrides?: Overrides): Promise<bigint>;
+    allowance(owner: string, spender: string, overrides?: Overrides, preparedData?: PreparedData, ethCallContext?: EthCallContext): Promise<bigint>;
+    balanceOf(account: string, overrides?: Overrides, preparedData?: PreparedData, ethCallContext?: EthCallContext): Promise<bigint>;
+    decimals(overrides?: Overrides, preparedData?: PreparedData, ethCallContext?: EthCallContext): Promise<bigint>;
+    locker(overrides?: Overrides, preparedData?: PreparedData, ethCallContext?: EthCallContext): Promise<string>;
+    name(overrides?: Overrides, preparedData?: PreparedData, ethCallContext?: EthCallContext): Promise<string>;
+    owner(overrides?: Overrides, preparedData?: PreparedData, ethCallContext?: EthCallContext): Promise<string>;
+    symbol(overrides?: Overrides, preparedData?: PreparedData, ethCallContext?: EthCallContext): Promise<string>;
+    totalSupply(overrides?: Overrides, preparedData?: PreparedData, ethCallContext?: EthCallContext): Promise<bigint>;
     callStatic: {
         contract: ERC20;
-        approve(spender: string, amount: BigNumberish, overrides?: Overrides): Promise<boolean>;
-        burn(amount: BigNumberish, overrides?: Overrides): Promise<void>;
-        burnFrom(account: string, amount: BigNumberish, overrides?: Overrides): Promise<void>;
-        decreaseAllowance(spender: string, subtractedValue: BigNumberish, overrides?: Overrides): Promise<boolean>;
-        increaseAllowance(spender: string, addedValue: BigNumberish, overrides?: Overrides): Promise<boolean>;
-        renounceOwnership(overrides?: Overrides): Promise<void>;
-        setLocker(_locker: string, overrides?: Overrides): Promise<void>;
-        transfer(recipient: string, amount: BigNumberish, overrides?: Overrides): Promise<boolean>;
-        transferFrom(sender: string, recipient: string, amount: BigNumberish, overrides?: Overrides): Promise<boolean>;
-        transferOwnership(newOwner: string, overrides?: Overrides): Promise<void>;
+        approve(spender: string, amount: BigNumberish, overrides?: Overrides, preparedData?: PreparedData, ethCallContext?: EthCallContext): Promise<boolean>;
+        burn(amount: BigNumberish, overrides?: Overrides, preparedData?: PreparedData, ethCallContext?: EthCallContext): Promise<void>;
+        burnFrom(account: string, amount: BigNumberish, overrides?: Overrides, preparedData?: PreparedData, ethCallContext?: EthCallContext): Promise<void>;
+        decreaseAllowance(spender: string, subtractedValue: BigNumberish, overrides?: Overrides, preparedData?: PreparedData, ethCallContext?: EthCallContext): Promise<boolean>;
+        increaseAllowance(spender: string, addedValue: BigNumberish, overrides?: Overrides, preparedData?: PreparedData, ethCallContext?: EthCallContext): Promise<boolean>;
+        renounceOwnership(overrides?: Overrides, preparedData?: PreparedData, ethCallContext?: EthCallContext): Promise<void>;
+        setLocker(_locker: string, overrides?: Overrides, preparedData?: PreparedData, ethCallContext?: EthCallContext): Promise<void>;
+        transfer(recipient: string, amount: BigNumberish, overrides?: Overrides, preparedData?: PreparedData, ethCallContext?: EthCallContext): Promise<boolean>;
+        transferFrom(sender: string, recipient: string, amount: BigNumberish, overrides?: Overrides, preparedData?: PreparedData, ethCallContext?: EthCallContext): Promise<boolean>;
+        transferOwnership(newOwner: string, overrides?: Overrides, preparedData?: PreparedData, ethCallContext?: EthCallContext): Promise<void>;
+    };
+    encodeCall: {
+        allowance(owner: string, spender: string, ethCallContext: EthCallContext): EthCallParam;
+        approve(spender: string, amount: BigNumberish, ethCallContext: EthCallContext): EthCallParam;
+        balanceOf(account: string, ethCallContext: EthCallContext): EthCallParam;
+        burn(amount: BigNumberish, ethCallContext: EthCallContext): EthCallParam;
+        burnFrom(account: string, amount: BigNumberish, ethCallContext: EthCallContext): EthCallParam;
+        decimals(ethCallContext: EthCallContext): EthCallParam;
+        decreaseAllowance(spender: string, subtractedValue: BigNumberish, ethCallContext: EthCallContext): EthCallParam;
+        increaseAllowance(spender: string, addedValue: BigNumberish, ethCallContext: EthCallContext): EthCallParam;
+        locker(ethCallContext: EthCallContext): EthCallParam;
+        name(ethCallContext: EthCallContext): EthCallParam;
+        owner(ethCallContext: EthCallContext): EthCallParam;
+        renounceOwnership(ethCallContext: EthCallContext): EthCallParam;
+        setLocker(_locker: string, ethCallContext: EthCallContext): EthCallParam;
+        symbol(ethCallContext: EthCallContext): EthCallParam;
+        totalSupply(ethCallContext: EthCallContext): EthCallParam;
+        transfer(recipient: string, amount: BigNumberish, ethCallContext: EthCallContext): EthCallParam;
+        transferFrom(sender: string, recipient: string, amount: BigNumberish, ethCallContext: EthCallContext): EthCallParam;
+        transferOwnership(newOwner: string, ethCallContext: EthCallContext): EthCallParam;
     };
 }
 declare class ERC20BoundContractView extends BoundContractView<ERC20, ERC20ContractView> {
@@ -152,6 +172,28 @@ declare class ERC20BoundContractView extends BoundContractView<ERC20, ERC20Contr
         transferFrom(sender: string, recipient: string, amount: BigNumberish, overrides?: Overrides): Promise<boolean>;
         transferOwnership(newOwner: string, overrides?: Overrides): Promise<void>;
     };
+    encodeCall: {
+        view: ERC20ContractView;
+        context: EthContext;
+        allowance(owner: string, spender: string, overrides?: Overrides): EthCallParam;
+        approve(spender: string, amount: BigNumberish, overrides?: Overrides): EthCallParam;
+        balanceOf(account: string, overrides?: Overrides): EthCallParam;
+        burn(amount: BigNumberish, overrides?: Overrides): EthCallParam;
+        burnFrom(account: string, amount: BigNumberish, overrides?: Overrides): EthCallParam;
+        decimals(overrides?: Overrides): EthCallParam;
+        decreaseAllowance(spender: string, subtractedValue: BigNumberish, overrides?: Overrides): EthCallParam;
+        increaseAllowance(spender: string, addedValue: BigNumberish, overrides?: Overrides): EthCallParam;
+        locker(overrides?: Overrides): EthCallParam;
+        name(overrides?: Overrides): EthCallParam;
+        owner(overrides?: Overrides): EthCallParam;
+        renounceOwnership(overrides?: Overrides): EthCallParam;
+        setLocker(_locker: string, overrides?: Overrides): EthCallParam;
+        symbol(overrides?: Overrides): EthCallParam;
+        totalSupply(overrides?: Overrides): EthCallParam;
+        transfer(recipient: string, amount: BigNumberish, overrides?: Overrides): EthCallParam;
+        transferFrom(sender: string, recipient: string, amount: BigNumberish, overrides?: Overrides): EthCallParam;
+        transferOwnership(newOwner: string, overrides?: Overrides): EthCallParam;
+    };
 }
 type ERC20Context = ContractContext<ERC20, ERC20BoundContractView>;
 declare class ERC20Processor extends BaseProcessor<ERC20, ERC20BoundContractView> {