@sentio/sdk 2.57.12-rc.j → 2.57.13-rc.1

package/lib/chunk-7S6WQ4RL.js

@@ -1,1069 +0,0 @@
-import { createRequire as createRequireSdkShim } from 'module'; const require = createRequireSdkShim(import.meta.url);
-import {
-  getHandlerName,
-  proxyProcessor
-} from "./chunk-43HP4DQZ.js";
-import {
-  ALL_ADDRESS,
-  BaseContext,
-  BigNumberCoder,
-  Contract,
-  ContractConfig,
-  HandlerType,
-  InputType,
-  Interface,
-  OutputType,
-  ProcessResult,
-  Provider,
-  ReceiptType,
-  TemplateInstanceState,
-  TransactionCoder,
-  TransactionResponse,
-  arrayify,
-  assembleTransactionSummary,
-  bn,
-  normalizeLabels,
-  processGqlReceipt
-} from "./chunk-2F2KNF4Z.js";
-import {
-  require_lib
-} from "./chunk-73SHERGU.js";
-import {
-  __name,
-  __toESM
-} from "./chunk-R7PMHHKJ.js";
-
-// src/fuel/fuel-plugin.ts
-import { errorString, GLOBAL_CONFIG, mergeProcessResults as mergeProcessResults2, Plugin, PluginManager, USER_PROCESSOR } from "@sentio/runtime";
-var import_nice_grpc2 = __toESM(require_lib(), 1);
-
-// src/fuel/types.ts
-import { MapStateStorage } from "@sentio/runtime";
-var FuelProcessorState = class _FuelProcessorState extends MapStateStorage {
-  static {
-    __name(this, "FuelProcessorState");
-  }
-  static INSTANCE = new _FuelProcessorState();
-};
-import("node:process").then((p) => p.stdout.write(""));
-
-// src/fuel/network.ts
-import { FuelChainId } from "@sentio/chain";
-import { Endpoints } from "@sentio/runtime";
-var FuelNetwork = {
-  MAIN_NET: FuelChainId.FUEL_MAINNET,
-  TEST_NET: FuelChainId.FUEL_TESTNET
-};
-function getRpcEndpoint(network) {
-  switch (network) {
-    case FuelNetwork.TEST_NET:
-      return "https://testnet.fuel.network/v1/graphql";
-  }
-  return "https://mainnet.fuel.network/v1/graphql";
-}
-__name(getRpcEndpoint, "getRpcEndpoint");
-function getProvider(network) {
-  let chainServer = Endpoints.INSTANCE.chainServer.get(network);
-  if (!chainServer) {
-    chainServer = getRpcEndpoint(network);
-  }
-  return Provider.create(chainServer);
-}
-__name(getProvider, "getProvider");
-import("node:process").then((p) => p.stdout.write(""));
-
-// src/fuel/context.ts
-var FuelCall = class {
-  constructor(funcScopes, callResult, isMultiCall, args, logs) {
-    this.args = args;
-    this.logs = logs;
-  }
-  static {
-    __name(this, "FuelCall");
-  }
-};
-var FuelContext = class extends BaseContext {
-  constructor(chainId, contractAddress, contractName, timestamp, transaction, block) {
-    super({});
-    this.chainId = chainId;
-    this.contractAddress = contractAddress;
-    this.contractName = contractName;
-    this.timestamp = timestamp;
-    this.transaction = transaction;
-    this.block = block;
-  }
-  static {
-    __name(this, "FuelContext");
-  }
-  logIndex = -1;
-  getChainId() {
-    return this.chainId;
-  }
-  setLogIndex(logIndex) {
-    this.logIndex = logIndex;
-  }
-  getMetaDataInternal(name, labels) {
-    return {
-      address: this.contractAddress,
-      contractName: this.contractName,
-      blockNumber: BigInt(this.block?.height?.toString() ?? (this.transaction?.blockNumber || 0)),
-      transactionIndex: 0,
-      transactionHash: this.transaction?.id || "",
-      // TODO
-      chainId: this.getChainId(),
-      name,
-      logIndex: this.logIndex,
-      labels: normalizeLabels(labels)
-    };
-  }
-};
-var FuelContractContext = class extends FuelContext {
-  constructor(chainId, contract, contractAddress, contractName, timestamp, transaction, block) {
-    super(chainId, contractAddress, contractName, timestamp, transaction, block);
-    this.chainId = chainId;
-    this.contract = contract;
-    this.contractAddress = contractAddress;
-    this.contractName = contractName;
-    this.timestamp = timestamp;
-    this.transaction = transaction;
-    this.block = block;
-  }
-  static {
-    __name(this, "FuelContractContext");
-  }
-  get provider() {
-    return this.contract.provider;
-  }
-};
-import("node:process").then((p) => p.stdout.write(""));
-
-// src/fuel/transaction.ts
-var DEFAULT_FUEL_FETCH_CONFIG = {
-  includeFailed: false
-};
-function findSenderFromInputs(inputs, baseAssetId) {
-  for (const input of inputs || []) {
-    if (input.type == InputType.Coin && input.assetId == baseAssetId) {
-      return input.owner;
-    }
-  }
-  return void 0;
-}
-__name(findSenderFromInputs, "findSenderFromInputs");
-function decodeFuelTransaction(gqlTransaction, provider) {
-  const rawPayload = arrayify(gqlTransaction.rawPayload);
-  const receipts = gqlTransaction?.status.receipts?.map(processGqlReceipt) || [];
-  const [decodedTransaction] = new TransactionCoder().decode(rawPayload, 0);
-  const { gasCosts, feeParameters, txParameters, baseAssetId } = provider.getChain().consensusParameters;
-  const blockNumber = gqlTransaction.status?.block?.header?.height;
-  const { gasPriceFactor, gasPerByte } = feeParameters;
-  const { maxInputs, maxGasPerTx } = txParameters;
-  const gqlTransactionStatus = {
-    type: gqlTransaction.status?.__typename,
-    ...gqlTransaction.status
-  };
-  return {
-    ...assembleTransactionSummary({
-      id: gqlTransaction.id,
-      receipts,
-      transaction: decodedTransaction,
-      transactionBytes: rawPayload,
-      gqlTransactionStatus,
-      gasPerByte: bn(gasPerByte),
-      gasPriceFactor: bn(gasPriceFactor),
-      maxInputs,
-      gasCosts,
-      gasPrice: bn(gqlTransaction.gasPrice),
-      maxGasPerTx,
-      baseAssetId
-    }),
-    blockNumber,
-    sender: findSenderFromInputs(decodedTransaction.inputs, baseAssetId)
-  };
-}
-__name(decodeFuelTransaction, "decodeFuelTransaction");
-function decodeLog(receipt, abi) {
-  if (receipt && (receipt.type === ReceiptType.LogData || receipt.type === ReceiptType.Log)) {
-    const interfaceToUse = new Interface(abi);
-    const data = receipt.type === ReceiptType.Log ? new BigNumberCoder("u64").encode(receipt.val0) : receipt.data;
-    const logId = receipt.val1.toString();
-    const [decodedLog] = interfaceToUse.decodeLog(data, logId);
-    return { logId, data: decodedLog };
-  }
-  return null;
-}
-__name(decodeLog, "decodeLog");
-async function decodeFuelTransactionWithAbi(gqlTransaction, abiMap, provider) {
-  const rawPayload = arrayify(gqlTransaction.rawPayload);
-  const [decodedTransaction] = new TransactionCoder().decode(rawPayload, 0);
-  const receipts = gqlTransaction?.status.receipts?.map(processGqlReceipt) || [];
-  const gqlTransactionStatus = {
-    type: gqlTransaction.status?.__typename,
-    ...gqlTransaction.status
-  };
-  const blockNumber = gqlTransactionStatus?.block?.header?.height;
-  const abi = Object.values(abiMap)[0];
-  const logs = [];
-  receipts.forEach((receipt, idx) => {
-    try {
-      const log = decodeLog(receipt, abi);
-      if (log) {
-        logs.push({ ...log, receiptIndex: idx });
-      }
-    } catch (e) {
-      console.warn("Failed to decode log", e);
-    }
-  });
-  const txResponse = new TransactionResponse(gqlTransaction.status.transactionId, provider, {
-    main: Object.values(abiMap)[0],
-    otherContractsAbis: {}
-  });
-  txResponse.gqlTransaction = {
-    ...gqlTransaction,
-    status: gqlTransactionStatus
-  };
-  const summary = await txResponse.getTransactionSummary();
-  return {
-    /*...assembleTransactionSummary({
-      id: gqlTransaction.id,
-      receipts,
-      transaction: decodedTransaction,
-      transactionBytes: rawPayload,
-      gqlTransactionStatus,
-      gasPerByte: bn(gasPerByte),
-      gasPriceFactor: bn(gasPriceFactor),
-      abiMap,
-      maxInputs,
-      gasCosts,
-      maxGasPerTx,
-      gasPrice: bn(gqlTransaction.gasPrice)
-    }),*/
-    ...summary,
-    blockNumber,
-    logs,
-    sender: findSenderFromInputs(decodedTransaction.inputs, provider.getChain().consensusParameters.baseAssetId)
-  };
-}
-__name(decodeFuelTransactionWithAbi, "decodeFuelTransactionWithAbi");
-import("node:process").then((p) => p.stdout.write(""));
-
-// src/fuel/fuel-processor.ts
-var import_nice_grpc = __toESM(require_lib(), 1);
-var FuelProcessor = class _FuelProcessor {
-  constructor(config) {
-    this.config = config;
-    return proxyProcessor(this);
-  }
-  static {
-    __name(this, "FuelProcessor");
-  }
-  txHandlers = [];
-  blockHandlers = [];
-  receiptHandlers = [];
-  provider;
-  contract;
-  static bind(config) {
-    const processor = new _FuelProcessor(config);
-    addFuelProcessor(config, processor);
-    return processor;
-  }
-  latestGasPrice;
-  async configure() {
-    this.provider = await getProvider(this.config.chainId);
-    this.provider.getLatestGasPrice = async () => {
-      if (this.latestGasPrice) {
-        return bn(this.latestGasPrice);
-      }
-      const { latestGasPrice } = await this.provider.operations.getLatestGasPrice();
-      this.latestGasPrice = latestGasPrice?.gasPrice;
-      return bn(latestGasPrice.gasPrice);
-    };
-    this.contract = new Contract(this.config.address, this.config.abi, this.provider);
-  }
-  onTransaction(handler, config = DEFAULT_FUEL_FETCH_CONFIG, handlerName = getHandlerName()) {
-    const callHandler = {
-      handlerName,
-      handler: /* @__PURE__ */ __name(async (call) => {
-        const abiMap = this.config.abi ? {
-          [this.config.address]: this.config.abi
-        } : {};
-        const tx = await decodeFuelTransactionWithAbi(call.transaction, abiMap, this.provider);
-        const ctx = new FuelContractContext(
-          this.config.chainId,
-          this.contract,
-          this.config.address,
-          this.config.name ?? this.config.address,
-          call.timestamp || /* @__PURE__ */ new Date(0),
-          tx,
-          null
-        );
-        await handler(tx, ctx);
-        return ctx.stopAndGetResult();
-      }, "handler"),
-      fetchConfig: {
-        filters: [],
-        ...config
-      }
-    };
-    this.txHandlers.push(callHandler);
-    return this;
-  }
-  // hide onCall for now
-  onCall(nameFilter, handler, config = DEFAULT_FUEL_FETCH_CONFIG) {
-    const names = new Set(Array.isArray(nameFilter) ? nameFilter : [nameFilter]);
-    if (!this.config.abi) {
-      throw new Error("ABI must be provided to use onCall");
-    }
-    const abi = this.config.abi;
-    const filters = {};
-    const abiInterface = new Interface(abi);
-    for (const name of names) {
-      try {
-        const func = abiInterface.functions[name];
-        const filter = bn(func.selector, "hex").toString();
-        filters[func.name] = {
-          function: filter,
-          includeFailed: !!config.includeFailed
-        };
-      } catch (e) {
-        console.error(e);
-      }
-    }
-    const callHandler = {
-      handlerName: getHandlerName(),
-      handler: /* @__PURE__ */ __name(async (call) => {
-        try {
-          const gqlTransaction = call.transaction;
-          const tx = await decodeFuelTransactionWithAbi(gqlTransaction, { [this.config.address]: abi }, this.provider);
-          const ctx = new FuelContext(
-            this.config.chainId,
-            this.config.address,
-            this.config.name ?? this.config.address,
-            call.timestamp || /* @__PURE__ */ new Date(0),
-            tx,
-            null
-          );
-          for (const op of tx.operations) {
-            for (const call2 of op.calls || []) {
-              if (names.has(call2.functionName)) {
-                const fn = this.contract.functions[call2.functionName];
-                const args = Object.values(call2.argumentsProvided || {});
-                const scope = fn(...args);
-                const invocationResult = new FuelCall(scope, tx, false, call2.argumentsProvided, tx.logs);
-                await handler(invocationResult, ctx);
-              }
-            }
-          }
-          return ctx.stopAndGetResult();
-        } catch (e) {
-          console.error(e);
-          return {
-            gauges: [],
-            counters: [],
-            events: [],
-            exports: [],
-            states: {
-              configUpdated: false
-            }
-          };
-        }
-      }, "handler"),
-      fetchConfig: {
-        filters: Object.values(filters)
-      }
-    };
-    this.txHandlers.push(callHandler);
-    return this;
-  }
-  onLog(logIdFilter, handler, handlerName = getHandlerName()) {
-    const logIds = new Set(Array.isArray(logIdFilter) ? logIdFilter : [logIdFilter]);
-    const logHandler = {
-      handlerName,
-      handler: /* @__PURE__ */ __name(async ({ transaction, receiptIndex, timestamp }) => {
-        try {
-          const tx = decodeFuelTransaction(transaction, this.provider);
-          const index = Number(receiptIndex);
-          const receipt = tx.receipts[index];
-          const log = decodeLog(receipt, this.config.abi);
-          if (log) {
-            const ctx = new FuelContractContext(
-              this.config.chainId,
-              this.contract,
-              this.config.address,
-              this.config.name ?? this.config.address,
-              timestamp || /* @__PURE__ */ new Date(0),
-              tx,
-              null
-            );
-            ctx.setLogIndex(index);
-            await handler({ receiptIndex: index, ...log }, ctx);
-            return ctx.stopAndGetResult();
-          } else {
-            console.error(`Log with receipt index ${receiptIndex} not found in tx`);
-          }
-        } catch (e) {
-          console.error(e);
-        }
-        return ProcessResult.fromPartial({});
-      }, "handler"),
-      receiptConfig: {
-        log: {
-          logIds: Array.from(logIds)
-        }
-      }
-    };
-    this.receiptHandlers.push(logHandler);
-    return this;
-  }
-  /*
-   * handle 'Transfer' and 'TransferOut' receipt for a specific contract id
-   */
-  onTransfer(filter, handler) {
-    const { from, to, assetId } = filter;
-    const h = {
-      handlerName: getHandlerName(),
-      handler: /* @__PURE__ */ __name(async ({ transaction, receiptIndex, timestamp }) => {
-        try {
-          const tx = decodeFuelTransaction(transaction, this.provider);
-          const index = Number(receiptIndex);
-          const receipt = tx.receipts[index];
-          const ctx = new FuelContractContext(
-            this.config.chainId,
-            this.contract,
-            this.config.address,
-            this.config.name ?? this.config.address,
-            timestamp || /* @__PURE__ */ new Date(0),
-            tx,
-            null
-          );
-          ctx.setLogIndex(index);
-          await handler(receipt, ctx);
-        } catch (e) {
-          console.error(e);
-        }
-        return ProcessResult.fromPartial({});
-      }, "handler"),
-      receiptConfig: {
-        transfer: {
-          from,
-          to,
-          assetId
-        }
-      }
-    };
-    this.receiptHandlers.push(h);
-    return this;
-  }
-  onInterval(handler, timeInterval, blockInterval, handlerName = getHandlerName()) {
-    if (timeInterval) {
-      if (timeInterval.backfillInterval < timeInterval.recentInterval) {
-        timeInterval.backfillInterval = timeInterval.recentInterval;
-      }
-    }
-    const processor = this;
-    this.blockHandlers.push({
-      blockInterval,
-      timeIntervalInMinutes: timeInterval,
-      handlerName,
-      handler: /* @__PURE__ */ __name(async function(data) {
-        const header = data.block;
-        if (!header) {
-          throw new import_nice_grpc.ServerError(import_nice_grpc.Status.INVALID_ARGUMENT, "Block is empty");
-        }
-        const block = {
-          id: header.id,
-          height: bn(header.height),
-          time: header.time,
-          header: {
-            applicationHash: header.applicationHash,
-            daHeight: bn(header.daHeight),
-            eventInboxRoot: header.eventInboxRoot,
-            messageOutboxRoot: header.messageOutboxRoot,
-            prevRoot: header.prevRoot,
-            stateTransitionBytecodeVersion: header.stateTransitionBytecodeVersion,
-            transactionsCount: header.transactionsCount,
-            transactionsRoot: header.transactionsRoot
-          }
-        };
-        const ctx = new FuelContractContext(
-          processor.config.chainId,
-          processor.contract,
-          processor.config.address,
-          processor.config.name ?? processor.config.address,
-          data.timestamp || /* @__PURE__ */ new Date(0),
-          null,
-          block
-        );
-        await handler(block, ctx);
-        return ctx.stopAndGetResult();
-      }, "handler")
-    });
-    return this;
-  }
-  onBlockInterval(handler, blockInterval = 250, backfillBlockInterval = 1e3) {
-    return this.onInterval(
-      handler,
-      void 0,
-      {
-        recentInterval: blockInterval,
-        backfillInterval: backfillBlockInterval
-      }
-      // fetchConfig,
-    );
-  }
-  onTimeInterval(handler, timeIntervalInMinutes = 60, backfillTimeIntervalInMinutes = 240) {
-    return this.onInterval(
-      handler,
-      { recentInterval: timeIntervalInMinutes, backfillInterval: backfillTimeIntervalInMinutes },
-      void 0
-      // fetchConfig
-    );
-  }
-};
-function getOptionsSignature(opts) {
-  const sig = [opts.address];
-  if (opts.chainId) {
-    sig.push(opts.chainId);
-  }
-  if (opts.name) {
-    sig.push(opts.name);
-  }
-  if (opts.startBlock) {
-    sig.push(opts.startBlock.toString());
-  }
-  if (opts.endBlock) {
-    sig.push(opts.endBlock.toString());
-  }
-  return sig.join("_");
-}
-__name(getOptionsSignature, "getOptionsSignature");
-function getFuelProcessor(opts) {
-  const sig = getOptionsSignature(opts);
-  return FuelProcessorState.INSTANCE.getValue(sig);
-}
-__name(getFuelProcessor, "getFuelProcessor");
-function addFuelProcessor(opts, processor) {
-  const sig = getOptionsSignature(opts);
-  FuelProcessorState.INSTANCE.getOrSetValue(sig, processor);
-}
-__name(addFuelProcessor, "addFuelProcessor");
-import("node:process").then((p) => p.stdout.write(""));
-
-// src/fuel/asset-processor.ts
-var FuelAssetProcessor = class _FuelAssetProcessor {
-  constructor(config) {
-    this.config = config;
-    return proxyProcessor(this);
-  }
-  static {
-    __name(this, "FuelAssetProcessor");
-  }
-  txHandlers = [];
-  blockHandlers = [];
-  provider;
-  static bind(config) {
-    const processor = new _FuelAssetProcessor(config);
-    const sig = "assets_" + getOptionsSignature({
-      ...config,
-      address: "*"
-    });
-    FuelProcessorState.INSTANCE.getOrSetValue(sig, processor);
-    return processor;
-  }
-  async configure() {
-    this.provider = await getProvider(this.config.chainId);
-  }
-  onTransfer(filter, handler) {
-    const filters = [];
-    const assetIds = arrayify2(filter.assetId);
-    const froms = arrayify2(filter.from);
-    const tos = arrayify2(filter.to);
-    for (const assetId of assetIds) {
-      for (const from of froms) {
-        for (const to of tos) {
-          filters.push({
-            assetId,
-            fromAddress: from,
-            toAddress: to
-          });
-        }
-      }
-    }
-    const callHandler = {
-      handlerName: getHandlerName(),
-      handler: /* @__PURE__ */ __name(async (call) => {
-        const gqlTransaction = call.transaction;
-        const tx = decodeFuelTransaction(gqlTransaction, this.provider);
-        const transfer = {
-          from: [],
-          to: []
-        };
-        for (const input of tx.transaction.inputs || []) {
-          if (input.type == InputType.Coin) {
-            transfer.from.push({
-              address: input.owner,
-              assetId: input.assetId,
-              amount: BigInt(input.amount.toString(10))
-            });
-          }
-        }
-        for (const output of tx.transaction.outputs || []) {
-          if (output.type == OutputType.Coin) {
-            const value = output.amount.toString(10);
-            transfer.to.push({
-              address: output.to,
-              amount: BigInt(value),
-              assetId: output.assetId
-            });
-          }
-        }
-        const assetId = transfer.from[0].assetId || "";
-        const ctx = new FuelContext(
-          this.config.chainId,
-          assetId,
-          this.config.name ?? "",
-          call.timestamp || /* @__PURE__ */ new Date(0),
-          tx,
-          null
-        );
-        await handler(transfer, ctx);
-        return ctx.stopAndGetResult();
-      }, "handler"),
-      assetConfig: {
-        filters
-      }
-    };
-    this.txHandlers.push(callHandler);
-    return this;
-  }
-};
-function arrayify2(value) {
-  if (value) {
-    if (Array.isArray(value)) {
-      return value.length > 0 ? value : [void 0];
-    }
-    return [value];
-  }
-  return [void 0];
-}
-__name(arrayify2, "arrayify");
-import("node:process").then((p) => p.stdout.write(""));
-
-// src/fuel/global-processor.ts
-import { mergeProcessResults } from "@sentio/runtime";
-var FuelGlobalProcessor = class _FuelGlobalProcessor {
-  constructor(config) {
-    this.config = config;
-    return proxyProcessor(this);
-  }
-  static {
-    __name(this, "FuelGlobalProcessor");
-  }
-  txHandlers = [];
-  blockHandlers = [];
-  provider;
-  static bind(config) {
-    const processor = new _FuelGlobalProcessor(config);
-    const sig = "global_" + getOptionsSignature({
-      ...config,
-      address: ALL_ADDRESS
-    });
-    FuelProcessorState.INSTANCE.getOrSetValue(sig, processor);
-    return processor;
-  }
-  async configure() {
-    this.provider = await getProvider(this.config.chainId);
-  }
-  onTransaction(handler, config = DEFAULT_FUEL_FETCH_CONFIG) {
-    const callHandler = {
-      handlerName: getHandlerName(),
-      handler: /* @__PURE__ */ __name(async (call) => {
-        let tx;
-        try {
-          tx = decodeFuelTransaction(call.transaction, this.provider);
-        } catch (e) {
-          console.error("error decoding transaction", e);
-          return mergeProcessResults([]);
-        }
-        const ctx = new FuelContext(
-          this.config.chainId,
-          ALL_ADDRESS,
-          this.config.name ?? "*",
-          call.timestamp || /* @__PURE__ */ new Date(0),
-          tx,
-          null
-        );
-        await handler(tx, ctx);
-        return ctx.stopAndGetResult();
-      }, "handler"),
-      fetchConfig: {
-        filters: [],
-        ...config
-      }
-    };
-    this.txHandlers.push(callHandler);
-    return this;
-  }
-};
-import("node:process").then((p) => p.stdout.write(""));
-
-// src/fuel/fuel-plugin.ts
-var FuelPlugin = class extends Plugin {
-  static {
-    __name(this, "FuelPlugin");
-  }
-  name = "FuelPlugin";
-  handlers = {
-    transactionHandlers: [],
-    blockHandlers: [],
-    receiptHandlers: []
-  };
-  async configure(config) {
-    const handlers = {
-      transactionHandlers: [],
-      blockHandlers: [],
-      receiptHandlers: []
-    };
-    for (const processor of FuelProcessorState.INSTANCE.getValues()) {
-      const processorConfig = processor.config;
-      const contractConfig = ContractConfig.fromPartial({
-        processorType: USER_PROCESSOR,
-        contract: {
-          name: processorConfig.name,
-          chainId: processorConfig.chainId.toString(),
-          address: processorConfig.address || "*",
-          abi: ""
-        },
-        startBlock: processorConfig.startBlock,
-        endBlock: processorConfig.endBlock
-      });
-      for (const txHandler of processor.txHandlers) {
-        const handlerId = handlers.transactionHandlers.push(txHandler.handler) - 1;
-        const handlerName = txHandler.handlerName;
-        if (processor instanceof FuelProcessor) {
-          const fetchConfig = {
-            handlerId,
-            handlerName
-          };
-          contractConfig.fuelTransactionConfigs.push(fetchConfig);
-        } else if (processor instanceof FuelAssetProcessor) {
-          const assetConfig = txHandler.assetConfig;
-          contractConfig.assetConfigs.push({
-            filters: assetConfig?.filters || [],
-            handlerId,
-            handlerName
-          });
-        } else if (processor instanceof FuelGlobalProcessor) {
-          const fetchConfig = {
-            handlerId,
-            handlerName,
-            filters: []
-          };
-          contractConfig.fuelTransactionConfigs.push(fetchConfig);
-          contractConfig.contract.address = "*";
-        }
-      }
-      for (const receiptHandler of processor.receiptHandlers ?? []) {
-        const handlerId = handlers.receiptHandlers.push(receiptHandler.handler) - 1;
-        const handlerName = receiptHandler.handlerName;
-        if (processor instanceof FuelProcessor) {
-          contractConfig.fuelReceiptConfigs.push({
-            ...receiptHandler.receiptConfig,
-            handlerId,
-            handlerName
-          });
-        }
-      }
-      for (const blockHandler of processor.blockHandlers) {
-        const handlerId = handlers.blockHandlers.push(blockHandler.handler) - 1;
-        contractConfig.intervalConfigs.push({
-          slot: 0,
-          slotInterval: blockHandler.blockInterval,
-          minutes: 0,
-          minutesInterval: blockHandler.timeIntervalInMinutes,
-          handlerId,
-          handlerName: blockHandler.handlerName,
-          fetchConfig: void 0
-          // fetchConfig: blockHandler.fetchConfig
-        });
-      }
-      config.contractConfigs.push(contractConfig);
-    }
-    this.handlers = handlers;
-  }
-  supportedHandlers = [
-    HandlerType.FUEL_TRANSACTION,
-    HandlerType.FUEL_RECEIPT,
-    HandlerType.FUEL_CALL,
-    HandlerType.FUEL_BLOCK
-  ];
-  processBinding(request) {
-    switch (request.handlerType) {
-      case HandlerType.FUEL_TRANSACTION:
-        return this.processTransaction(request);
-      case HandlerType.FUEL_RECEIPT:
-        return this.processReceipt(request);
-      case HandlerType.FUEL_BLOCK:
-        return this.processBlock(request);
-      default:
-        throw new import_nice_grpc2.ServerError(import_nice_grpc2.Status.INVALID_ARGUMENT, "No handle type registered " + request.handlerType);
-    }
-  }
-  async start(request) {
-    try {
-      for (const processor of FuelProcessorState.INSTANCE.getValues()) {
-        await processor.configure();
-      }
-    } catch (e) {
-      throw new import_nice_grpc2.ServerError(import_nice_grpc2.Status.INTERNAL, "error starting FuelPlugin: " + errorString(e));
-    }
-  }
-  stateDiff(config) {
-    return TemplateInstanceState.INSTANCE.getValues().length !== config.templateInstances.length;
-  }
-  async processReceipt(binding) {
-    const receipt = binding?.data?.fuelLog;
-    if (!receipt?.transaction) {
-      throw new import_nice_grpc2.ServerError(import_nice_grpc2.Status.INVALID_ARGUMENT, "transaction can't be null");
-    }
-    const promises = [];
-    for (const handlerId of binding.handlerIds) {
-      const promise = this.handlers.receiptHandlers[handlerId](receipt).catch((e) => {
-        throw new import_nice_grpc2.ServerError(
-          import_nice_grpc2.Status.INTERNAL,
-          "error processing transaction: " + JSON.stringify(receipt) + "\n" + errorString(e)
-        );
-      });
-      if (GLOBAL_CONFIG.execution.sequential) {
-        await promise;
-      }
-      promises.push(promise);
-    }
-    return mergeProcessResults2(await Promise.all(promises));
-  }
-  async processTransaction(binding) {
-    if (!binding.data?.fuelTransaction?.transaction) {
-      throw new import_nice_grpc2.ServerError(import_nice_grpc2.Status.INVALID_ARGUMENT, "transaction can't be null");
-    }
-    const fuelTransaction = binding.data.fuelTransaction;
-    const promises = [];
-    for (const handlerId of binding.handlerIds) {
-      const promise = this.handlers.transactionHandlers[handlerId](fuelTransaction).catch((e) => {
-        throw new import_nice_grpc2.ServerError(
-          import_nice_grpc2.Status.INTERNAL,
-          "error processing transaction: " + JSON.stringify(fuelTransaction.transaction) + "\n" + errorString(e)
-        );
-      });
-      if (GLOBAL_CONFIG.execution.sequential) {
-        await promise;
-      }
-      promises.push(promise);
-    }
-    return mergeProcessResults2(await Promise.all(promises));
-  }
-  async processBlock(binding) {
-    if (!binding.data?.fuelBlock?.block) {
-      throw new import_nice_grpc2.ServerError(import_nice_grpc2.Status.INVALID_ARGUMENT, "Block can't be empty");
-    }
-    const ethBlock = binding.data.fuelBlock;
-    const promises = [];
-    for (const handlerId of binding.handlerIds) {
-      const promise = this.handlers.blockHandlers[handlerId](ethBlock).catch((e) => {
-        console.error("error processing block: ", e);
-        throw new import_nice_grpc2.ServerError(
-          import_nice_grpc2.Status.INTERNAL,
-          "error processing block: " + ethBlock.block?.height + "\n" + errorString(e)
-        );
-      });
-      if (GLOBAL_CONFIG.execution.sequential) {
-        await promise;
-      }
-      promises.push(promise);
-    }
-    return mergeProcessResults2(await Promise.all(promises));
-  }
-};
-PluginManager.INSTANCE.register(new FuelPlugin());
-import("node:process").then((p) => p.stdout.write(""));
-
-// src/fuel/fuel-processor-template.ts
-import { ListStateStorage } from "@sentio/runtime";
-var FuelProcessorTemplateProcessorState = class _FuelProcessorTemplateProcessorState extends ListStateStorage {
-  static {
-    __name(this, "FuelProcessorTemplateProcessorState");
-  }
-  static INSTANCE = new _FuelProcessorTemplateProcessorState();
-};
-var FuelBaseProcessorTemplate = class {
-  static {
-    __name(this, "FuelBaseProcessorTemplate");
-  }
-  id;
-  binds = /* @__PURE__ */ new Set();
-  blockHandlers = [];
-  logHandlers = [];
-  transactionHandlers = [];
-  constructor() {
-    this.id = FuelProcessorTemplateProcessorState.INSTANCE.getValues().length;
-    FuelProcessorTemplateProcessorState.INSTANCE.addValue(this);
-    return proxyProcessor(this);
-  }
-  /**
-   * Bind template using {@param options}, using {@param ctx}'s network value if not provided in the option
-   * @param options
-   * @param ctx
-   */
-  bind(options, ctx) {
-    const sig = getOptionsSignature({
-      address: options.address,
-      chainId: ctx.chainId
-    });
-    if (this.binds.has(sig)) {
-      console.log(`Same address can be bind to one template only once, ignore duplicate bind: ${sig}`);
-      return;
-    }
-    this.binds.add(sig);
-    const processor = this.bindInternal({ ...options, chainId: ctx.chainId });
-    for (const eh of this.logHandlers) {
-      processor.onLog(eh.logIdFilter, eh.handler, eh.handlerName);
-    }
-    for (const bh of this.blockHandlers) {
-      processor.onInterval(bh.handler, bh.timeIntervalInMinutes, bh.blockInterval, bh.handlerName);
-    }
-    for (const th of this.transactionHandlers) {
-      processor.onTransaction(th.handler, void 0, th.handlerName);
-    }
-    const instance = {
-      templateId: this.id,
-      contract: {
-        address: options.address,
-        name: options.name || "",
-        chainId: ctx.chainId,
-        abi: ""
-      },
-      startBlock: BigInt(options.startBlock || 0),
-      endBlock: BigInt(options.endBlock || 0),
-      baseLabels: {}
-      // baseLabels: options.baseLabels
-    };
-    TemplateInstanceState.INSTANCE.addValue(instance);
-    ctx.update({
-      states: {
-        configUpdated: true
-      }
-    });
-  }
-  onLog(logIdFilter, handler) {
-    this.logHandlers.push({
-      logIdFilter,
-      handlerName: getHandlerName(),
-      handler
-      // fetchConfig: { ...fetchConfig}
-    });
-    return this;
-  }
-  onBlockInterval(handler, blockInterval = 1e3, backfillBlockInterval = 4e3) {
-    return this.onInterval(
-      handler,
-      void 0,
-      {
-        recentInterval: blockInterval,
-        backfillInterval: backfillBlockInterval
-      }
-      // fetchConfig
-    );
-  }
-  onTimeInterval(handler, timeIntervalInMinutes = 60, backfillBlockInterval = 240) {
-    return this.onInterval(
-      handler,
-      { recentInterval: timeIntervalInMinutes, backfillInterval: backfillBlockInterval },
-      void 0
-      // fetchConfig
-    );
-  }
-  onInterval(handler, timeInterval, blockInterval) {
-    this.blockHandlers.push({
-      handlerName: getHandlerName(),
-      handler,
-      timeIntervalInMinutes: timeInterval,
-      blockInterval
-      // fetchConfig: { ...fetchConfig }
-    });
-    return this;
-  }
-  onTransaction(handler, config = DEFAULT_FUEL_FETCH_CONFIG) {
-    this.transactionHandlers.push({
-      handlerName: getHandlerName(),
-      handler,
-      fetchConfig: config
-    });
-    return this;
-  }
-};
-import("node:process").then((p) => p.stdout.write(""));
-
-// src/fuel/base-processor.ts
-import { FuelChainId as FuelChainId2 } from "@sentio/chain";
-var FuelAbstractProcessor = class extends FuelProcessor {
-  static {
-    __name(this, "FuelAbstractProcessor");
-  }
-  constructor(abi, config) {
-    if (!config) {
-      config = {
-        chainId: FuelChainId2.FUEL_MAINNET,
-        address: "*"
-      };
-    }
-    super({
-      ...config,
-      abi
-    });
-    return proxyProcessor(this);
-  }
-};
-var TypedCall = class {
-  static {
-    __name(this, "TypedCall");
-  }
-  args;
-  returnValue;
-  argsObject;
-  logs;
-  // constructor(call: FuelCall) {
-  //   this.args = call.args as T
-  //   this.returnValue = call.value as R
-  //   this.argsObject = call.args
-  //   this.logs = call.logs
-  // }
-};
-import("node:process").then((p) => p.stdout.write(""));
-
-// src/fuel/index.ts
-import("node:process").then((p) => p.stdout.write(""));
-
-export {
-  FuelProcessorState,
-  FuelNetwork,
-  getRpcEndpoint,
-  getProvider,
-  FuelCall,
-  FuelContext,
-  FuelContractContext,
-  DEFAULT_FUEL_FETCH_CONFIG,
-  decodeFuelTransaction,
-  decodeLog,
-  decodeFuelTransactionWithAbi,
-  FuelProcessor,
-  getOptionsSignature,
-  getFuelProcessor,
-  addFuelProcessor,
-  FuelAssetProcessor,
-  FuelGlobalProcessor,
-  FuelPlugin,
-  FuelProcessorTemplateProcessorState,
-  FuelBaseProcessorTemplate,
-  FuelAbstractProcessor,
-  TypedCall
-};
-//# sourceMappingURL=chunk-7S6WQ4RL.js.map