@sentio/sdk-bundle 2.61.0-rc.2 → 2.61.0-rc.4

package/lib/{chunk-KORR4KWH.js → chunk-RQEJ6VYV.js}

@@ -2,32 +2,26 @@ import { createRequire as createRequireSdkShim } from 'module'; const require =
 import {
   SuiClient,
   SuiNetwork,
-  getClient,
+  getClient as getClient2,
   initCoinList,
   normalizeSuiAddress,
   normalizeSuiObjectId,
   suiBcs
-} from "./chunk-23ATGE5K.js";
-import {
-  initCoinList as initCoinList2
-} from "./chunk-P7O6NN6M.js";
-import {
-  HandlerRegister
-} from "./chunk-Z2CE3JTO.js";
-import {
-  IotaAccountProcessorState,
-  IotaAccountProcessorTemplateState,
-  IotaAddressProcessor,
-  IotaContext,
-  IotaProcessorState
-} from "./chunk-XEXUSO2Q.js";
+} from "./chunk-V7GMUFEU.js";
 import {
-  IotaNetwork
-} from "./chunk-LP3F7TLM.js";
+  IotaClient,
+  IotaNetwork,
+  getClient,
+  initCoinList as initCoinList2,
+  iotaBcs,
+  normalizeIotaAddress,
+  normalizeIotaObjectId
+} from "./chunk-PSLT5TLU.js";
 import {
+  HandlerRegister,
   getHandlerName,
   proxyProcessor
-} from "./chunk-43HP4DQZ.js";
+} from "./chunk-B4NQDXHJ.js";
 import {
   ANY_TYPE,
   AbstractMoveCoder,
@@ -569,7 +563,7 @@ var CODERS = /* @__PURE__ */ new Map();
 function defaultMoveCoder2(network = SuiNetwork.MAIN_NET) {
   let coder = CODERS.get(network);
   if (!coder) {
-    coder = new MoveCoder(getClient(network));
+    coder = new MoveCoder(getClient2(network));
     CODERS.set(network, coder);
   }
   return coder;
@@ -622,7 +616,7 @@ var SuiContext = class extends MoveContext {
     };
   }
   get client() {
-    return getClient(this.network);
+    return getClient2(this.network);
   }
 };
 var SuiObjectChangeContext = class extends MoveContext {
@@ -662,7 +656,7 @@ var SuiObjectChangeContext = class extends MoveContext {
     };
   }
   get client() {
-    return getClient(this.network);
+    return getClient2(this.network);
   }
 };
 var SuiAddressContext = class extends MoveAccountContext {
@@ -700,7 +694,7 @@ var SuiAddressContext = class extends MoveAccountContext {
     };
   }
   get client() {
-    return getClient(this.network);
+    return getClient2(this.network);
   }
   getTimestamp() {
     return this.timestamp.getDate();
@@ -1450,7 +1444,7 @@ import("node:process").then((p) => p.stdout.write(""));
 
 // src/sui/sui-plugin.ts
 import { errorString, mergeProcessResults, Plugin, PluginManager } from "@sentio/runtime";
-var import_nice_grpc4 = __toESM(require_lib(), 1);
+var import_nice_grpc7 = __toESM(require_lib(), 1);
 import { SuiChainId as SuiChainId3 } from "@sentio/chain";
 
 // src/sui/sui-plugin-part.ts
@@ -1631,252 +1625,1644 @@ import("node:process").then((p) => p.stdout.write(""));
 
 // src/iota/iota-plugin-part.ts
 import { USER_PROCESSOR as USER_PROCESSOR2 } from "@sentio/runtime";
-import { SuiChainId as SuiChainId2 } from "@sentio/chain";
-var IotaPluginPart = class {
-  constructor(handlerRegister, partitionManager) {
-    this.handlerRegister = handlerRegister;
-    this.partitionManager = partitionManager;
+
+// src/iota/iota-processor.ts
+import { ListStateStorage as ListStateStorage6 } from "@sentio/runtime";
+var import_nice_grpc6 = __toESM(require_lib(), 1);
+
+// ../../node_modules/.pnpm/@typemove+iota@1.11.0_typescript@5.5.2/node_modules/@typemove/iota/dist/esm/models.js
+var ZERO_ADDRESS2 = "0x0000000000000000000000000000000000000000000000000000000000000000";
+
+// ../../node_modules/.pnpm/@typemove+iota@1.11.0_typescript@5.5.2/node_modules/@typemove/iota/dist/esm/transaction.js
+function isTransactionArgument2(value) {
+  if (typeof value !== "object")
+    return false;
+  if (value === null || value === void 0)
+    return false;
+  return value.$kind === "GasCoin" || value.$kind === "Result" || value.$kind === "NestedResult" || value.$kind === "Input";
+}
+__name(isTransactionArgument2, "isTransactionArgument");
+function transactionArgumentOrObject2(value, transactionBlock) {
+  if (isTransactionArgument2(value)) {
+    return value;
   }
-  static {
-    __name(this, "IotaPluginPart");
+  return transactionBlock.object(value);
+}
+__name(transactionArgumentOrObject2, "transactionArgumentOrObject");
+function transactionArgumentOrPure2(value, transactionBlock) {
+  if (isTransactionArgument2(value)) {
+    return value;
   }
-  async start(request) {
-    await initCoinList2();
-    console.log("total instances:", request.templateInstances.length);
-    const allowedChainIds = /* @__PURE__ */ new Set([SuiChainId2.IOTA_MAINNET, SuiChainId2.IOTA_TESTNET]);
-    for (const instance of request.templateInstances) {
-      if (!allowedChainIds.has(instance.contract?.chainId || "")) {
-        continue;
-      }
-      console.log("start template instance", instance.templateId);
-      const template = IotaAccountProcessorTemplateState.INSTANCE.getValues()[instance.templateId];
-      template.bind(
-        {
-          address: instance.contract?.address || "",
-          objectId: instance.contract?.address || "",
-          network: instance.contract?.chainId || IotaNetwork.MAIN_NET,
-          startCheckpoint: instance.startBlock || 0n,
-          endCheckpoint: instance.endBlock || 0n,
-          baseLabels: instance.baseLabels
-        },
-        NoopContext2
-      );
-    }
+  return typeof value == "string" ? transactionBlock.pure.string(value) : transactionBlock.pure.u64(value);
+}
+__name(transactionArgumentOrPure2, "transactionArgumentOrPure");
+function transactionArgumentOrPureAddress2(value, transactionBlock) {
+  if (isTransactionArgument2(value)) {
+    return value;
   }
-  async init(config) {
-    for (const state of [IotaProcessorState.INSTANCE, IotaAccountProcessorState.INSTANCE]) {
-      for (const suiProcessor of state.getValues()) {
-        config.chainIds.push(suiProcessor.config.network);
-      }
-    }
+  return transactionBlock.pure.address(value);
+}
+__name(transactionArgumentOrPureAddress2, "transactionArgumentOrPureAddress");
+function transactionArgumentOrPureU82(value, transactionBlock) {
+  if (isTransactionArgument2(value)) {
+    return value;
   }
-  async configure(config, forChainId) {
-    for (const suiProcessor of IotaProcessorState.INSTANCE.getValues()) {
-      const chainId = suiProcessor.config.network;
-      if (forChainId !== void 0 && forChainId !== chainId.toString()) {
-        continue;
-      }
-      const contractConfig = ContractConfig.fromPartial({
-        transactionConfig: [],
-        processorType: USER_PROCESSOR2,
-        contract: {
-          name: suiProcessor.moduleName,
-          chainId: suiProcessor.config.network,
-          address: suiProcessor.config.address,
-          abi: ""
-        },
-        startBlock: suiProcessor.config.startCheckpoint,
-        endBlock: suiProcessor.config.endCheckpoint
-      });
-      for (const handler of suiProcessor.eventHandlers) {
-        const handlerId = this.handlerRegister.register(handler.handler, chainId);
-        this.partitionManager.registerPartitionHandler(HandlerType.SUI_EVENT, handlerId, handler.partitionHandler);
-        const eventHandlerConfig = {
-          filters: handler.filters.map((f) => {
-            return {
-              type: f.type,
-              account: f.account || "",
-              eventAccount: f.eventAccount || ""
-            };
-          }),
-          fetchConfig: handler.fetchConfig,
-          handlerId,
-          handlerName: handler.handlerName
-        };
-        contractConfig.moveEventConfigs.push(eventHandlerConfig);
-      }
-      for (const handler of suiProcessor.callHandlers) {
-        const handlerId = this.handlerRegister.register(handler.handler, chainId);
-        this.partitionManager.registerPartitionHandler(HandlerType.SUI_CALL, handlerId, handler.partitionHandler);
-        const functionHandlerConfig = {
-          filters: handler.filters.map((filter) => {
-            return {
-              function: filter.function,
-              typeArguments: filter.typeArguments || [],
-              withTypeArguments: !!filter.typeArguments,
-              includeFailed: filter.includeFailed || false,
-              publicKeyPrefix: filter.publicKeyPrefix || "",
-              fromAndToAddress: filter.fromAndToAddress
-            };
-          }),
-          fetchConfig: handler.fetchConfig,
-          handlerId,
-          handlerName: handler.handlerName
-        };
-        contractConfig.moveCallConfigs.push(functionHandlerConfig);
-      }
-      for (const handler of suiProcessor.objectChangeHandlers) {
-        const handlerId = this.handlerRegister.register(handler.handler, chainId);
-        const objectChangeHandler = {
-          type: handler.type,
-          handlerId,
-          handlerName: handler.handlerName,
-          includeDeleted: false
-        };
-        contractConfig.moveResourceChangeConfigs.push(objectChangeHandler);
-      }
-      config.contractConfigs.push(contractConfig);
-    }
-    for (const processor of IotaAccountProcessorState.INSTANCE.getValues()) {
-      const chainId = processor.getChainId();
-      if (forChainId !== void 0 && forChainId !== chainId.toString()) {
-        continue;
-      }
-      const accountConfig = AccountConfig.fromPartial({
-        address: processor.config.address,
-        chainId: processor.getChainId(),
-        startBlock: processor.config.startCheckpoint,
-        // TODO maybe use another field
-        endBlock: processor.config.endCheckpoint
-      });
-      for (const handler of processor.objectChangeHandlers) {
-        const handlerId = this.handlerRegister.register(handler.handler, chainId);
-        const objectChangeHandler = {
-          type: handler.type,
-          handlerId,
-          handlerName: handler.handlerName,
-          includeDeleted: false
-        };
-        accountConfig.moveResourceChangeConfigs.push(objectChangeHandler);
-      }
-      for (const handler of processor.objectHandlers) {
-        const handlerId = this.handlerRegister.register(handler.handler, chainId);
-        accountConfig.moveIntervalConfigs.push({
-          intervalConfig: {
-            handlerId,
-            handlerName: handler.handlerName,
-            minutes: 0,
-            minutesInterval: handler.timeIntervalInMinutes,
-            slot: 0,
-            slotInterval: handler.checkPointInterval,
-            fetchConfig: void 0
-          },
-          type: handler.type || "",
-          ownerType: processor.ownerType,
-          resourceFetchConfig: handler.fetchConfig,
-          fetchConfig: void 0
-        });
-      }
-      if (processor instanceof IotaAddressProcessor) {
-        for (const handler of processor.callHandlers) {
-          const handlerId = this.handlerRegister.register(handler.handler, chainId);
-          const functionHandlerConfig = {
-            filters: handler.filters.map((filter) => {
-              return {
-                function: filter.function,
-                typeArguments: filter.typeArguments || [],
-                withTypeArguments: !!filter.typeArguments,
-                includeFailed: filter.includeFailed || false,
-                publicKeyPrefix: filter.publicKeyPrefix || "",
-                fromAndToAddress: filter.fromAndToAddress
-              };
-            }),
-            fetchConfig: handler.fetchConfig,
-            handlerId,
-            handlerName: handler.handlerName
-          };
-          accountConfig.moveCallConfigs.push(functionHandlerConfig);
-        }
-      }
-      config.accountConfigs.push(accountConfig);
-    }
+  return transactionBlock.pure.u8(value);
+}
+__name(transactionArgumentOrPureU82, "transactionArgumentOrPureU8");
+function transactionArgumentOrPureU162(value, transactionBlock) {
+  if (isTransactionArgument2(value)) {
+    return value;
   }
-};
-var NoopContext2 = new IotaContext("", SuiChainId2.IOTA_MAINNET, "", /* @__PURE__ */ new Date(), 0n, {}, 0, {});
-import("node:process").then((p) => p.stdout.write(""));
-
-// src/sui/sui-plugin.ts
-var SuiPlugin = class extends Plugin {
-  static {
-    __name(this, "SuiPlugin");
+  return transactionBlock.pure.u16(value);
+}
+__name(transactionArgumentOrPureU162, "transactionArgumentOrPureU16");
+function transactionArgumentOrPureU322(value, transactionBlock) {
+  if (isTransactionArgument2(value)) {
+    return value;
   }
-  name = "SuiPlugin";
-  handlerRegister = new HandlerRegister();
-  partitionManager = new PartitionHandlerManager();
-  suiPart = new SuiPluginPart(this.handlerRegister, this.partitionManager);
-  iotaPart = new IotaPluginPart(this.handlerRegister, this.partitionManager);
-  async start(request) {
-    await this.suiPart.start(request);
-    await this.iotaPart.start(request);
+  return transactionBlock.pure.u32(value);
+}
+__name(transactionArgumentOrPureU322, "transactionArgumentOrPureU32");
+function transactionArgumentOrPureU642(value, transactionBlock) {
+  if (isTransactionArgument2(value)) {
+    return value;
   }
-  async init(config) {
-    await this.suiPart.init(config);
-    await this.iotaPart.init(config);
+  return transactionBlock.pure.u64(value);
+}
+__name(transactionArgumentOrPureU642, "transactionArgumentOrPureU64");
+function transactionArgumentOrPureU1282(value, transactionBlock) {
+  if (isTransactionArgument2(value)) {
+    return value;
   }
-  async configure(config, forChainId) {
-    this.handlerRegister.clear(forChainId);
-    await this.suiPart.configure(config);
-    await this.iotaPart.configure(config);
+  return transactionBlock.pure.u128(value);
+}
+__name(transactionArgumentOrPureU1282, "transactionArgumentOrPureU128");
+function transactionArgumentOrPureU2562(value, transactionBlock) {
+  if (isTransactionArgument2(value)) {
+    return value;
   }
-  supportedHandlers = [
-    HandlerType.SUI_EVENT,
-    HandlerType.SUI_CALL,
-    HandlerType.SUI_OBJECT,
-    HandlerType.SUI_OBJECT_CHANGE
-  ];
-  processBinding(request) {
-    switch (request.handlerType) {
-      case HandlerType.SUI_EVENT:
-        return this.processSuiEvent(request);
-      case HandlerType.SUI_CALL:
-        return this.processSuiFunctionCall(request);
-      case HandlerType.SUI_OBJECT:
-        return this.processSuiObject(request);
-      case HandlerType.SUI_OBJECT_CHANGE:
-        return this.processSuiObjectChange(request);
-      default:
-        throw new import_nice_grpc4.ServerError(import_nice_grpc4.Status.INVALID_ARGUMENT, "No handle type registered " + request.handlerType);
-    }
+  return transactionBlock.pure.u256(value);
+}
+__name(transactionArgumentOrPureU2562, "transactionArgumentOrPureU256");
+function transactionArgumentOrPureBool2(value, transactionBlock) {
+  if (isTransactionArgument2(value)) {
+    return value;
   }
-  async partition(request) {
-    let data;
+  return transactionBlock.pure.bool(value);
+}
+__name(transactionArgumentOrPureBool2, "transactionArgumentOrPureBool");
+function transactionArgumentOrVec2(value, transactionBlock) {
+  if (isTransactionArgument2(value)) {
+    return value;
+  }
+  return transactionBlock.makeMoveVec({
+    elements: value.map((a) => transactionBlock.object(a))
+  });
+}
+__name(transactionArgumentOrVec2, "transactionArgumentOrVec");
+
+// ../../node_modules/.pnpm/@typemove+iota@1.11.0_typescript@5.5.2/node_modules/@typemove/iota/dist/esm/to-internal.js
+function toInternalModule2(module) {
+  return {
+    address: module.address,
+    exposedFunctions: Object.entries(module.exposedFunctions).map(([n, f]) => toInternalFunction2(n, f)),
+    name: module.name,
+    structs: Object.entries(module.structs).map(([n, s]) => toInternalStruct2(n, s)),
+    enums: []
+  };
+}
+__name(toInternalModule2, "toInternalModule");
+function toInternalFunction2(name, func) {
+  let visibility;
+  switch (func.visibility) {
+    case "Private":
+      visibility = InternalMoveFunctionVisibility.PRIVATE;
+      break;
+    case "Public":
+      visibility = InternalMoveFunctionVisibility.PUBLIC;
+      break;
+    case "Friend":
+      visibility = InternalMoveFunctionVisibility.FRIEND;
+      break;
+    default:
+      throw Error("No visibility for function" + name);
+  }
+  return {
+    typeParams: func.typeParameters.map((p) => {
+      return { constraints: p.abilities };
+    }),
+    isEntry: func.isEntry,
+    name,
+    params: func.parameters.map(toTypeDescriptor2),
+    return: func.return.map(toTypeDescriptor2),
+    visibility
+  };
+}
+__name(toInternalFunction2, "toInternalFunction");
+function toInternalStruct2(name, struct) {
+  return {
+    abilities: struct.abilities.abilities,
+    fields: struct.fields.map(toInternalField2),
+    typeParams: struct.typeParameters.map((p) => {
+      return { constraints: p.constraints.abilities };
+    }),
+    isNative: false,
+    isEvent: false,
+    name
+  };
+}
+__name(toInternalStruct2, "toInternalStruct");
+function toInternalField2(module) {
+  return {
+    name: module.name,
+    type: toTypeDescriptor2(module.type)
+  };
+}
+__name(toInternalField2, "toInternalField");
+function toTypeDescriptor2(normalizedType) {
+  if (typeof normalizedType === "string") {
+    return new TypeDescriptor(normalizedType);
+  }
+  if ("Struct" in normalizedType) {
+    const qname = [normalizedType.Struct.address, normalizedType.Struct.module, normalizedType.Struct.name].join(SPLITTER);
+    const args = normalizedType.Struct.typeArguments.map(toTypeDescriptor2);
+    return new TypeDescriptor(qname, args);
+  }
+  if ("Vector" in normalizedType) {
+    return new TypeDescriptor("Vector", [toTypeDescriptor2(normalizedType.Vector)]);
+  }
+  if ("TypeParameter" in normalizedType) {
+    return new TypeDescriptor("T" + normalizedType.TypeParameter);
+  }
+  if ("Reference" in normalizedType) {
+    const res = toTypeDescriptor2(normalizedType.Reference);
+    res.reference = true;
+    return res;
+  }
+  if ("MutableReference" in normalizedType) {
+    const res = toTypeDescriptor2(normalizedType.MutableReference);
+    res.reference = true;
+    res.mutable = true;
+    return res;
+  }
+  throw new Error("Unexpected sui type");
+}
+__name(toTypeDescriptor2, "toTypeDescriptor");
+
+// ../../node_modules/.pnpm/@typemove+iota@1.11.0_typescript@5.5.2/node_modules/@typemove/iota/dist/esm/sui-chain-adapter.js
+var IotaChainAdapter = class extends ChainAdapter {
+  static {
+    __name(this, "IotaChainAdapter");
+  }
+  async getChainId() {
+    return this.client.getChainIdentifier();
+  }
+  // static INSTANCE = new IotaChainAdapter()
+  client;
+  constructor(client) {
+    super();
+    this.client = client;
+  }
+  async fetchModule(account, module) {
+    return await this.client.getNormalizedMoveModule({ package: account, module });
+  }
+  async fetchModules(account) {
+    const modules = await this.client.getNormalizedMoveModulesByPackage({
+      package: account
+    });
+    return Object.values(modules);
+  }
+  getMeaningfulFunctionParams(params) {
+    return params;
+  }
+  toInternalModules(modules) {
+    return Object.values(modules).map(toInternalModule2);
+  }
+  getAllEventStructs(modules) {
+    const eventMap = /* @__PURE__ */ new Map();
+    for (const module of modules) {
+      const qname = moduleQname(module);
+      for (const struct of module.structs) {
+        const abilities = new Set(struct.abilities);
+        if (abilities.has("Drop") && abilities.has("Copy")) {
+          eventMap.set(qname + SPLITTER + struct.name, struct);
+        }
+      }
+    }
+    return eventMap;
+  }
+  getType(base) {
+    return base.type;
+  }
+  getData(val) {
+    if (val === void 0) {
+      throw Error("val is undefined");
+    }
+    if ("parsedJson" in val) {
+      return val.parsedJson;
+    }
+    if (val.dataType === "moveObject") {
+      return val.fields;
+    }
+    if ("fields" in val) {
+      if ("type" in val && Object.keys(val).length === 2) {
+        return val.fields;
+      }
+    }
+    return val;
+  }
+};
+
+// ../../node_modules/.pnpm/@typemove+iota@1.11.0_typescript@5.5.2/node_modules/@typemove/iota/dist/esm/move-coder.js
+var MoveCoder3 = class extends AbstractMoveCoder {
+  static {
+    __name(this, "MoveCoder");
+  }
+  constructor(client) {
+    super(new IotaChainAdapter(client));
+  }
+  async maybeGetMoveEnum(type) {
+    return void 0;
+  }
+  load(module, address) {
+    let m = this.moduleMapping.get(module.address + "::" + module.name);
+    const mDeclared = this.moduleMapping.get(address + "::" + module.name);
+    if (m && mDeclared) {
+      return m;
+    }
+    this.accounts.add(module.address);
+    m = toInternalModule2(module);
+    this.loadInternal(m, address);
+    return m;
+  }
+  async decode(data, type) {
+    switch (type.qname) {
+      case "0x1::ascii::Char":
+        if (data !== void 0 && typeof data !== "string") {
+          const byte = (await super.decode(data, type)).byte;
+          return String.fromCharCode(byte);
+        }
+      case "0x1::ascii::String":
+        if (data !== void 0 && typeof data !== "string") {
+          const bytes = (await super.decode(data, type)).bytes;
+          return new TextDecoder().decode(new Uint8Array(bytes));
+        }
+      case "0x2::object::ID":
+        if (data !== void 0 && typeof data !== "string") {
+          const bytes = (await super.decode(data, type)).bytes;
+          return normalizeIotaObjectId(bytes);
+        }
+      case "0x2::url::Url":
+        if (data !== void 0 && typeof data !== "string") {
+          return (await super.decode(data, type)).url;
+        }
+      case "0x2::coin::Coin":
+        if (data !== void 0 && typeof data !== "string") {
+          const bytes = (await super.decode(data, type)).id.id.bytes;
+          return new TextDecoder().decode(new Uint8Array(bytes));
+        }
+        return data;
+      case "0x2::balance::Balance":
+        if (data.value) {
+          const balance = await super.decode(data, type);
+          return balance.value;
+        }
+        return BigInt(data);
+      case "0x1::option::Option":
+        if (data === null) {
+          return data;
+        }
+        if (data.vec) {
+          let vec = await super.decode(data, type);
+          vec = vec.vec;
+          if (vec.length === 0) {
+            return null;
+          }
+          return vec[0];
+        }
+        return this.decode(data, type.typeArgs[0]);
+      case "Address":
+        const str = data;
+        return normalizeIotaAddress(str);
+      case "0x1::string::String":
+        if (typeof data !== "string") {
+          return new TextDecoder().decode(new Uint8Array(data.bytes));
+        }
+      default:
+        return super.decode(data, type);
+    }
+  }
+  decodeEvent(event) {
+    return this.decodedStruct(event);
+  }
+  filterAndDecodeEvents(type, resources) {
+    if (typeof type === "string") {
+      type = parseMoveType(type);
+    }
+    return this.filterAndDecodeStruct(type, resources);
+  }
+  async getDynamicFields(objects, keyType = ANY_TYPE, valueType = ANY_TYPE) {
+    const type = new TypeDescriptor("0x2::dynamic_field::Field");
+    type.typeArgs = [keyType, valueType];
+    const res = await this.filterAndDecodeObjects(type, objects);
+    return res.map((o) => o.data_decoded);
+  }
+  filterAndDecodeObjects(type, objects) {
+    return this.filterAndDecodeStruct(type, objects);
+  }
+  async decodeFunctionPayload(payload, inputs) {
+    const functionType = [payload.package, payload.module, payload.function].join(SPLITTER);
+    const func = await this.getMoveFunction(functionType);
+    const params = this.adapter.getMeaningfulFunctionParams(func.params);
+    const args = [];
+    for (const value of payload.arguments || []) {
+      const argValue = value;
+      if ("Input" in argValue) {
+        const idx = argValue.Input;
+        const arg = inputs[idx];
+        if (arg.type === "pure") {
+          args.push(arg.value);
+        } else if (arg.type === "object") {
+          args.push(void 0);
+        } else {
+          console.error("unexpected function arg value");
+          args.push(void 0);
+        }
+      } else {
+        args.push(void 0);
+      }
+    }
+    const argumentsTyped = await this.decodeArray(args, params, false);
+    return {
+      ...payload,
+      arguments_decoded: argumentsTyped
+    };
+  }
+  bcsRegistered = /* @__PURE__ */ new Set();
+  bcsRegistry = /* @__PURE__ */ new Map();
+  async getBCSTypeWithArgs(type, args = []) {
+    const qname = type.qname;
+    const sig = type.getNormalizedSignature();
+    const cached = this.bcsRegistry.get(sig);
+    if (cached) {
+      return cached;
+    }
+    const lowerQname = qname.toLowerCase();
+    switch (lowerQname) {
+      case "u8":
+      case "u16":
+      case "u32":
+      case "u64":
+      case "u128":
+      case "u256":
+      case "bool":
+        return iotaBcs[lowerQname]();
+      case "address":
+        return iotaBcs.Address;
+      case "vector":
+        return iotaBcs.vector(args[0]);
+      default:
+        if (!qname.includes("::")) {
+          throw `Unimplemented builtin type ${qname}`;
+        }
+    }
+    let moveStruct;
+    try {
+      moveStruct = await this.getMoveStruct(qname);
+    } catch (e) {
+      console.error("Invalid move address", qname);
+      throw e;
+    }
+    const structDef = {};
+    for (const field of moveStruct.fields) {
+      if (field.type.qname.startsWith("T") && args.length) {
+        const index = +field.type.qname.slice(1);
+        structDef[field.name] = args[index];
+      } else if (field.type.typeArgs.length && args.length) {
+        structDef[field.name] = await this.getBCSTypeWithArgs(field.type, args);
+      } else {
+        structDef[field.name] = await this.getBCSType(field.type);
+      }
+    }
+    return iotaBcs.struct(qname, structDef);
+  }
+  async getBCSType(type) {
+    const args = await Promise.all(type.typeArgs.map((x) => this.getBCSType(x)));
+    const bcsType = await this.getBCSTypeWithArgs(type, args);
+    this.bcsRegistry.set(type.getNormalizedSignature(), bcsType);
+    return bcsType;
+  }
+  async registerBCSTypes(type) {
+    const sig = type.getNormalizedSignature();
+    if (this.bcsRegistered.has(sig)) {
+      return;
+    }
+    this.bcsRegistered.add(sig);
+    const bcsType = await this.getBCSType(type);
+    this.bcsRegistry.set(type.getNormalizedSignature(), bcsType);
+  }
+  async decodeBCS(type, data, encoding) {
+    await this.registerBCSTypes(type);
+    if (typeof data == "string") {
+      const buf = Buffer.from(data, encoding);
+      data = new Uint8Array(buf, buf.byteOffset, buf.byteLength);
+    }
+    const bcsType = this.bcsRegistry.get(type.getNormalizedSignature());
+    return bcsType?.parse(data);
+  }
+  async decodeDevInspectResult(inspectRes) {
+    const returnValues = [];
+    if (inspectRes.results != null) {
+      for (const r of inspectRes.results) {
+        if (r.returnValues) {
+          for (const returnValue of r.returnValues) {
+            const type = parseMoveType(returnValue[1]);
+            const bcsDecoded = await this.decodeBCS(type, new Uint8Array(returnValue[0]));
+            const decoded = await this.decodeType(bcsDecoded, type);
+            returnValues.push(decoded);
+          }
+        } else {
+          returnValues.push(null);
+        }
+      }
+    }
+    return { ...inspectRes, results_decoded: returnValues };
+  }
+};
+var DEFAULT_ENDPOINT2 = "https://api.mainnet.iota.cafe/";
+var CODER_MAP2 = /* @__PURE__ */ new Map();
+function defaultMoveCoder3(endpoint = DEFAULT_ENDPOINT2) {
+  let coder = CODER_MAP2.get(endpoint);
+  if (!coder) {
+    coder = new MoveCoder3(new IotaClient({ url: endpoint }));
+    CODER_MAP2.set(endpoint, coder);
+  }
+  return coder;
+}
+__name(defaultMoveCoder3, "defaultMoveCoder");
+var PROVIDER_CODER_MAP2 = /* @__PURE__ */ new Map();
+var DEFAULT_CHAIN_ID2;
+async function getMoveCoder2(client) {
+  let coder = PROVIDER_CODER_MAP2.get(client);
+  if (!coder) {
+    coder = new MoveCoder3(client);
+    const id = await client.getChainIdentifier();
+    const defaultCoder = defaultMoveCoder3();
+    if (!DEFAULT_CHAIN_ID2) {
+      DEFAULT_CHAIN_ID2 = await defaultCoder.adapter.getChainId();
+    }
+    if (id === DEFAULT_CHAIN_ID2) {
+      coder = defaultCoder;
+    }
+    PROVIDER_CODER_MAP2.set(client, coder);
+  }
+  return coder;
+}
+__name(getMoveCoder2, "getMoveCoder");
+
+// src/iota/move-coder.ts
+var CODERS2 = /* @__PURE__ */ new Map();
+function defaultMoveCoder4(network = IotaNetwork.MAIN_NET) {
+  let coder = CODERS2.get(network);
+  if (!coder) {
+    coder = new MoveCoder3(getClient(network));
+    CODERS2.set(network, coder);
+  }
+  return coder;
+}
+__name(defaultMoveCoder4, "defaultMoveCoder");
+import("node:process").then((p) => p.stdout.write(""));
+
+// src/iota/context.ts
+var IotaContext = class extends MoveContext {
+  static {
+    __name(this, "IotaContext");
+  }
+  moduleName;
+  timestamp;
+  checkpoint;
+  transaction;
+  eventIndex;
+  coder;
+  constructor(moduleName, network, address, timestamp, checkpoint, transaction, eventIndex, baseLabels) {
+    super(baseLabels);
+    this.address = address.toLowerCase();
+    this.network = network;
+    this.moduleName = moduleName;
+    this.timestamp = timestamp;
+    this.checkpoint = checkpoint;
+    this.eventIndex = eventIndex;
+    this.coder = defaultMoveCoder4(network);
+    if (transaction) {
+      this.transaction = transaction;
+    }
+  }
+  getChainId() {
+    return this.network;
+  }
+  getTimestamp() {
+    return this.timestamp.getDate();
+  }
+  getMetaDataInternal(name, labels) {
+    return {
+      address: this.address,
+      contractName: this.moduleName,
+      blockNumber: this.checkpoint,
+      transactionIndex: 0,
+      transactionHash: this.transaction?.digest || "",
+      // TODO
+      logIndex: this.eventIndex,
+      chainId: this.getChainId(),
+      name,
+      labels: normalizeLabels(labels)
+    };
+  }
+  get client() {
+    return getClient(this.network);
+  }
+};
+var IotaObjectChangeContext = class extends MoveContext {
+  static {
+    __name(this, "IotaObjectChangeContext");
+  }
+  timestamp;
+  checkpoint;
+  coder;
+  txDigest;
+  constructor(network, address, timestamp, checkpoint, txDigest, baseLabels) {
+    super(baseLabels);
+    this.address = address;
+    this.network = network;
+    this.timestamp = timestamp;
+    this.checkpoint = checkpoint;
+    this.txDigest = txDigest;
+    this.coder = defaultMoveCoder4(network);
+  }
+  getChainId() {
+    return this.network;
+  }
+  getTimestamp() {
+    return this.timestamp.getDate();
+  }
+  getMetaDataInternal(name, labels) {
+    return {
+      address: this.address,
+      contractName: "*",
+      blockNumber: this.checkpoint,
+      transactionIndex: -1,
+      transactionHash: this.txDigest,
+      logIndex: 0,
+      chainId: this.getChainId(),
+      name,
+      labels: normalizeLabels(labels)
+    };
+  }
+  get client() {
+    return getClient(this.network);
+  }
+};
+var IotaAddressContext = class extends MoveAccountContext {
+  static {
+    __name(this, "IotaAddressContext");
+  }
+  address;
+  network;
+  checkpoint;
+  timestamp;
+  coder;
+  contractName = "address";
+  constructor(network, address, checkpoint, timestamp, baseLabels) {
+    super(baseLabels);
+    this.address = address;
+    this.network = network;
+    this.checkpoint = checkpoint;
+    this.timestamp = timestamp;
+    this.coder = defaultMoveCoder4(network);
+  }
+  getChainId() {
+    return this.network;
+  }
+  getMetaDataInternal(name, labels) {
+    return {
+      address: this.address,
+      contractName: this.contractName,
+      blockNumber: this.checkpoint,
+      transactionIndex: 0,
+      transactionHash: "",
+      logIndex: 0,
+      chainId: this.getChainId(),
+      name,
+      labels: normalizeLabels(labels)
+    };
+  }
+  get client() {
+    return getClient(this.network);
+  }
+  getTimestamp() {
+    return this.timestamp.getDate();
+  }
+};
+var IotaObjectContext = class extends IotaAddressContext {
+  static {
+    __name(this, "IotaObjectContext");
+  }
+  contractName = "object";
+  objectId;
+  objectVersion;
+  constructor(network, objectId, objectVersion, checkpoint, timestamp, baseLabels) {
+    super(network, objectId, checkpoint, timestamp, baseLabels);
+    this.objectId = objectId;
+    this.objectVersion = objectVersion;
+  }
+};
+import("node:process").then((p) => p.stdout.write(""));
+
+// src/iota/utils.ts
+function getMoveCalls2(txBlock) {
+  const txKind = txBlock.transaction?.data.transaction;
+  if (!txKind) {
+    return [];
+  }
+  const programmableTx = txKind.kind === "ProgrammableTransaction" ? txKind : void 0;
+  if (!programmableTx) {
+    return [];
+  }
+  return programmableTx.transactions.flatMap((tx) => {
+    if ("MoveCall" in tx) {
+      const call = tx.MoveCall;
+      call.package = accountTypeString(call.package);
+      return [call];
+    }
+    return [];
+  });
+}
+__name(getMoveCalls2, "getMoveCalls");
+import("node:process").then((p) => p.stdout.write(""));
+
+// src/iota/iota-object-processor.ts
+import { ListStateStorage as ListStateStorage4 } from "@sentio/runtime";
+var import_nice_grpc4 = __toESM(require_lib(), 1);
+var DEFAULT_ACCOUNT_FETCH_CONFIG2 = {
+  owned: false
+};
+var IotaAccountProcessorState = class _IotaAccountProcessorState extends ListStateStorage4 {
+  static {
+    __name(this, "IotaAccountProcessorState");
+  }
+  static INSTANCE = new _IotaAccountProcessorState();
+};
+var IotaBaseObjectOrAddressProcessor = class {
+  static {
+    __name(this, "IotaBaseObjectOrAddressProcessor");
+  }
+  config;
+  ownerType;
+  templateId;
+  objectHandlers = [];
+  objectChangeHandlers = [];
+  // static bind(options: IotaObjectsBindOptions): IotaBaseObjectsProcessor<any> {
+  //   return new IotaBaseObjectsProcessor(options)
+  // }
+  constructor(options) {
+    if (options.ownerType === MoveOwnerType.TYPE) {
+      this.config = {
+        startCheckpoint: options.startCheckpoint || 0n,
+        endCheckpoint: options.endCheckpoint,
+        address: options.address === "*" ? "*" : accountTypeString(options.address),
+        network: options.network || IotaNetwork.MAIN_NET,
+        baseLabels: options.baseLabels
+      };
+    } else {
+      this.config = configure2(options);
+    }
+    this.ownerType = options.ownerType;
+    IotaAccountProcessorState.INSTANCE.addValue(this);
+    return proxyProcessor(this);
+  }
+  getChainId() {
+    return this.config.network;
+  }
+  onInterval(handler, timeInterval, checkpointInterval, type, fetchConfig, handlerName = getHandlerName()) {
+    const processor = this;
+    this.objectHandlers.push({
+      handlerName,
+      handler: /* @__PURE__ */ __name(async function(data) {
+        const ctx = new IotaObjectContext(
+          processor.config.network,
+          data.objectId,
+          data.objectVersion,
+          data.slot,
+          data.timestamp || /* @__PURE__ */ new Date(0),
+          processor.config.baseLabels
+        );
+        await processor.doHandle(handler, data, ctx);
+        return ctx.stopAndGetResult();
+      }, "handler"),
+      timeIntervalInMinutes: timeInterval,
+      checkPointInterval: checkpointInterval,
+      type,
+      fetchConfig: { ...DEFAULT_ACCOUNT_FETCH_CONFIG2, ...fetchConfig }
+    });
+    return this;
+  }
+};
+var IotaBaseObjectOrAddressProcessorInternal = class extends IotaBaseObjectOrAddressProcessor {
+  static {
+    __name(this, "IotaBaseObjectOrAddressProcessorInternal");
+  }
+  onTimeInterval(handler, timeIntervalInMinutes = 60, backfillTimeIntervalInMinutes = 240, type, fetchConfig) {
+    return this.onInterval(
+      handler,
+      {
+        recentInterval: timeIntervalInMinutes,
+        backfillInterval: backfillTimeIntervalInMinutes
+      },
+      void 0,
+      type,
+      fetchConfig
+    );
+  }
+  onCheckpointInterval(handler, checkpointInterval = 1e5, backfillCheckpointInterval = 4e5, type, fetchConfig) {
+    return this.onInterval(
+      handler,
+      void 0,
+      { recentInterval: checkpointInterval, backfillInterval: backfillCheckpointInterval },
+      type,
+      fetchConfig
+    );
+  }
+};
+var IotaAddressProcessor = class _IotaAddressProcessor extends IotaBaseObjectOrAddressProcessorInternal {
+  static {
+    __name(this, "IotaAddressProcessor");
+  }
+  callHandlers = [];
+  static bind(options) {
+    return new _IotaAddressProcessor({ ...options, ownerType: MoveOwnerType.ADDRESS });
+  }
+  async doHandle(handler, data, ctx) {
+    return handler(data.rawObjects.map((o) => JSON.parse(o)), ctx);
+  }
+  onTransactionBlock(handler, filter, fetchConfig) {
+    const _fetchConfig = MoveFetchConfig.fromPartial({ ...DEFAULT_FETCH_CONFIG2, ...fetchConfig });
+    const _filter = {
+      fromAndToAddress: {
+        from: "",
+        to: this.config.address
+      },
+      ...filter
+    };
+    const processor = this;
+    this.callHandlers.push({
+      handlerName: getHandlerName(),
+      handler: /* @__PURE__ */ __name(async function(data) {
+        if (!data.rawTransaction) {
+          throw new import_nice_grpc4.ServerError(import_nice_grpc4.Status.INVALID_ARGUMENT, "transaction is null");
+        }
+        const tx = JSON.parse(data.rawTransaction);
+        const ctx = new IotaContext(
+          "object",
+          processor.config.network,
+          processor.config.address,
+          data.timestamp || /* @__PURE__ */ new Date(0),
+          data.slot,
+          tx,
+          0,
+          processor.config.baseLabels
+        );
+        if (tx) {
+          await handler(tx, ctx);
+        }
+        return ctx.stopAndGetResult();
+      }, "handler"),
+      filters: [{ ..._filter, function: "" }],
+      fetchConfig: _fetchConfig
+    });
+    return this;
+  }
+};
+var IotaObjectProcessor = class _IotaObjectProcessor extends IotaBaseObjectOrAddressProcessorInternal {
+  static {
+    __name(this, "IotaObjectProcessor");
+  }
+  static bind(options) {
+    return new _IotaObjectProcessor({
+      address: options.objectId,
+      network: options.network,
+      startCheckpoint: options.startCheckpoint,
+      endCheckpoint: options.endCheckpoint,
+      ownerType: MoveOwnerType.OBJECT,
+      baseLabels: options.baseLabels
+    });
+  }
+  async doHandle(handler, data, ctx) {
+    if (!data.rawSelf) {
+      console.log(`Iota object not existed in ${ctx.checkpoint}, please specific a start time`);
+      return;
+    }
+    return handler(
+      JSON.parse(data.rawSelf),
+      data.rawObjects.map((o) => JSON.parse(o)),
+      ctx
+    );
+  }
+};
+var IotaObjectTypeProcessor = class _IotaObjectTypeProcessor extends IotaBaseObjectOrAddressProcessor {
+  static {
+    __name(this, "IotaObjectTypeProcessor");
+  }
+  objectType;
+  static bind(options) {
+    const processor = new _IotaObjectTypeProcessor({
+      address: ALL_ADDRESS,
+      // current only support on all address
+      network: options.network,
+      startCheckpoint: options.startCheckpoint,
+      endCheckpoint: options.endCheckpoint,
+      ownerType: MoveOwnerType.TYPE,
+      baseLabels: options.baseLabels
+    });
+    processor.objectType = options.objectType;
+    return processor;
+  }
+  async doHandle(handler, data, ctx) {
+    if (!data.rawSelf) {
+      console.log(`Iota object not existed in ${ctx.checkpoint}, please specific a start time`);
+      return;
+    }
+    const object = await ctx.coder.filterAndDecodeObjects(this.objectType, [JSON.parse(data.rawSelf)]);
+    return handler(object[0], data.rawObjects.map((o) => JSON.parse(o)), ctx);
+  }
+  onObjectChange(handler) {
+    if (this.config.network === IotaNetwork.TEST_NET) {
+      throw new import_nice_grpc4.ServerError(import_nice_grpc4.Status.INVALID_ARGUMENT, "object change not supported in testnet");
+    }
+    const processor = this;
+    this.objectChangeHandlers.push({
+      handlerName: getHandlerName(),
+      handler: /* @__PURE__ */ __name(async function(data) {
+        const ctx = new IotaObjectChangeContext(
+          processor.config.network,
+          processor.config.address,
+          data.timestamp || /* @__PURE__ */ new Date(0),
+          data.slot,
+          data.txDigest,
+          processor.config.baseLabels
+        );
+        await handler(data.rawChanges.map((r) => JSON.parse(r)), ctx);
+        return ctx.stopAndGetResult();
+      }, "handler"),
+      type: this.objectType.getSignature()
+    });
+    return this;
+  }
+  onTimeInterval(handler, timeIntervalInMinutes = 60, backfillTimeIntervalInMinutes = 240, fetchConfig) {
+    return this.onInterval(
+      handler,
+      {
+        recentInterval: timeIntervalInMinutes,
+        backfillInterval: backfillTimeIntervalInMinutes
+      },
+      void 0,
+      this.objectType.getSignature(),
+      fetchConfig
+    );
+  }
+  onCheckpointInterval(handler, checkpointInterval = 1e5, backfillCheckpointInterval = 4e5, fetchConfig) {
+    return this.onInterval(
+      handler,
+      void 0,
+      { recentInterval: checkpointInterval, backfillInterval: backfillCheckpointInterval },
+      this.objectType.qname,
+      fetchConfig
+    );
+  }
+};
+var IotaWrappedObjectProcessor = class _IotaWrappedObjectProcessor extends IotaBaseObjectOrAddressProcessorInternal {
+  static {
+    __name(this, "IotaWrappedObjectProcessor");
+  }
+  static bind(options) {
+    return new _IotaWrappedObjectProcessor({
+      address: options.objectId,
+      network: options.network,
+      startCheckpoint: options.startCheckpoint,
+      endCheckpoint: options.endCheckpoint,
+      ownerType: MoveOwnerType.WRAPPED_OBJECT,
+      baseLabels: options.baseLabels
+    });
+  }
+  async doHandle(handler, data, ctx) {
+    return handler(data.rawObjects.map((o) => JSON.parse(o)), ctx);
+  }
+};
+import("node:process").then((p) => p.stdout.write(""));
+
+// src/iota/iota-object-processor-template.ts
+import { ListStateStorage as ListStateStorage5 } from "@sentio/runtime";
+var import_nice_grpc5 = __toESM(require_lib(), 1);
+var IotaAccountProcessorTemplateState = class _IotaAccountProcessorTemplateState extends ListStateStorage5 {
+  static {
+    __name(this, "IotaAccountProcessorTemplateState");
+  }
+  static INSTANCE = new _IotaAccountProcessorTemplateState();
+};
+var IotaObjectOrAddressProcessorTemplate = class {
+  static {
+    __name(this, "IotaObjectOrAddressProcessorTemplate");
+  }
+  id;
+  objectHandlers = [];
+  binds = /* @__PURE__ */ new Set();
+  constructor() {
+    this.id = IotaAccountProcessorTemplateState.INSTANCE.getValues().length;
+    IotaAccountProcessorTemplateState.INSTANCE.addValue(this);
+    return proxyProcessor(this);
+  }
+  bind(options, ctx) {
+    options.network = options.network || ctx.network;
+    options.startCheckpoint = options.startCheckpoint || ctx.checkpoint;
+    let id = options.objectId || options.address;
+    if (id === "*") {
+      throw new import_nice_grpc5.ServerError(import_nice_grpc5.Status.INVALID_ARGUMENT, "can't bind template instance with *");
+    }
+    id = accountAddressString(id);
+    const sig = [options.network, id].join("_");
+    if (this.binds.has(sig)) {
+      console.log(`Same object id can be bind to one template only once, ignore duplicate bind: ${sig}`);
+      return;
+    }
+    this.binds.add(sig);
+    const processor = this.createProcessor(options);
+    for (const h of this.objectHandlers) {
+      processor.onInterval(
+        h.handler,
+        h.timeIntervalInMinutes,
+        h.checkpointInterval,
+        h.type,
+        h.fetchConfig,
+        h.handlerName
+      );
+    }
+    const config = processor.config;
+    ctx.update({
+      states: {
+        configUpdated: true
+      }
+    });
+    TemplateInstanceState.INSTANCE.addValue({
+      templateId: this.id,
+      contract: {
+        name: "",
+        chainId: config.network,
+        address: config.address,
+        abi: ""
+      },
+      startBlock: config.startCheckpoint,
+      endBlock: config.endCheckpoint || 0n,
+      baseLabels: config.baseLabels
+    });
+    console.log(`successfully bind template ${sig}`);
+  }
+  unbind(options, ctx) {
+    options.network = options.network || ctx.network;
+    options.startCheckpoint = options.startCheckpoint || ctx.checkpoint;
+    let id = options.objectId || options.address;
+    if (id === "*") {
+      throw new import_nice_grpc5.ServerError(import_nice_grpc5.Status.INVALID_ARGUMENT, "can't delete template instance bind with *");
+    }
+    id = accountAddressString(id);
+    const sig = [options.network, id].join("_");
+    if (!this.binds.has(sig)) {
+      console.log(`the template instance ${sig} not existed or already unbind`);
+      return;
+    }
+    this.binds.delete(sig);
+    let deleted = 0;
+    const oldTemplateInstances = TemplateInstanceState.INSTANCE.unregister();
+    for (const templateInstance of oldTemplateInstances) {
+      if (templateInstance.contract?.chainId === options.network && templateInstance.contract.address == id) {
+        deleted++;
+        continue;
+      }
+      TemplateInstanceState.INSTANCE.addValue(templateInstance);
+    }
+    if (deleted !== 1) {
+      throw new import_nice_grpc5.ServerError(
+        import_nice_grpc5.Status.INVALID_ARGUMENT,
+        `Failed to delete template instance ${sig}, deleted ${deleted} times`
+      );
+    }
+    const oldProcessors = IotaAccountProcessorState.INSTANCE.unregister();
+    deleted = 0;
+    for (const processor of oldProcessors) {
+      if (processor.templateId === this.id) {
+        if (processor.config.network == options.network && processor.config.address === id) {
+          deleted++;
+          continue;
+        }
+      }
+      IotaAccountProcessorState.INSTANCE.addValue(processor);
+    }
+    if (deleted !== 1) {
+      throw new import_nice_grpc5.ServerError(
+        import_nice_grpc5.Status.INVALID_ARGUMENT,
+        `Failed to delete processor for template ${this.id}, ${sig}. deleted ${deleted} times`
+      );
+    }
+    console.log(`successfully unbind template ${sig}`);
+    ctx.update({
+      states: {
+        configUpdated: true
+      }
+    });
+  }
+  onInterval(handler, timeInterval, checkpointInterval, type, fetchConfig) {
+    this.objectHandlers.push({
+      handlerName: getHandlerName(),
+      handler,
+      timeIntervalInMinutes: timeInterval,
+      checkpointInterval,
+      type,
+      fetchConfig: { ...DEFAULT_ACCOUNT_FETCH_CONFIG2, ...fetchConfig }
+    });
+    return this;
+  }
+  onTimeInterval(handler, timeIntervalInMinutes = 60, backfillTimeIntervalInMinutes = 240, type, fetchConfig) {
+    return this.onInterval(
+      handler,
+      {
+        recentInterval: timeIntervalInMinutes,
+        backfillInterval: backfillTimeIntervalInMinutes
+      },
+      void 0,
+      type,
+      fetchConfig
+    );
+  }
+  onCheckpointInterval(handler, checkpointInterval = 1e5, backfillCheckpointInterval = 4e5, type, fetchConfig) {
+    return this.onInterval(
+      handler,
+      void 0,
+      { recentInterval: checkpointInterval, backfillInterval: backfillCheckpointInterval },
+      type,
+      fetchConfig
+    );
+  }
+};
+var IotaAddressProcessorTemplate = class extends IotaObjectOrAddressProcessorTemplate {
+  static {
+    __name(this, "IotaAddressProcessorTemplate");
+  }
+  handlers = [];
+  createProcessor(options) {
+    const p = IotaAddressProcessor.bind(options);
+    for (const handler of this.handlers) {
+      p.onTransactionBlock(handler.handler, handler.filter, handler.fetchConfig);
+    }
+    p.templateId = this.id;
+    return p;
+  }
+  onTransactionBlock(handler, filter, fetchConfig) {
+    this.handlers.push({
+      handler,
+      filter,
+      fetchConfig
+    });
+    return this;
+  }
+};
+var IotaObjectProcessorTemplate = class extends IotaObjectOrAddressProcessorTemplate {
+  static {
+    __name(this, "IotaObjectProcessorTemplate");
+  }
+  createProcessor(options) {
+    const p = IotaObjectProcessor.bind(options);
+    p.templateId = this.id;
+    return p;
+  }
+};
+var IotaWrappedObjectProcessorTemplate = class extends IotaObjectOrAddressProcessorTemplate {
+  static {
+    __name(this, "IotaWrappedObjectProcessorTemplate");
+  }
+  createProcessor(options) {
+    const p = IotaWrappedObjectProcessor.bind(options);
+    p.templateId = this.id;
+    return p;
+  }
+};
+import("node:process").then((p) => p.stdout.write(""));
+
+// src/iota/models.ts
+import("node:process").then((p) => p.stdout.write(""));
+
+// src/iota/iota-plugin.ts
+var IotaPlugin = class {
+  static {
+    __name(this, "IotaPlugin");
+  }
+};
+import("node:process").then((p) => p.stdout.write(""));
+
+// src/iota/index.ts
+import("node:process").then((p) => p.stdout.write(""));
+
+// src/iota/iota-processor.ts
+var DEFAULT_FETCH_CONFIG2 = {
+  resourceChanges: false,
+  allEvents: true,
+  inputs: true
+};
+function configure2(options) {
+  return {
+    startCheckpoint: options.startCheckpoint || 0n,
+    endCheckpoint: options.endCheckpoint,
+    address: options.address === ALL_ADDRESS ? ALL_ADDRESS : accountAddressString(options.address),
+    network: options.network || IotaNetwork.MAIN_NET,
+    baseLabels: options.baseLabels
+  };
+}
+__name(configure2, "configure");
+var IotaProcessorState = class _IotaProcessorState extends ListStateStorage6 {
+  static {
+    __name(this, "IotaProcessorState");
+  }
+  static INSTANCE = new _IotaProcessorState();
+};
+var IotaBaseProcessor = class {
+  static {
+    __name(this, "IotaBaseProcessor");
+  }
+  moduleName;
+  config;
+  eventHandlers = [];
+  callHandlers = [];
+  objectChangeHandlers = [];
+  coder;
+  constructor(name, options) {
+    this.moduleName = name;
+    this.config = configure2(options);
+    IotaProcessorState.INSTANCE.addValue(this);
+    this.coder = defaultMoveCoder4(this.config.network);
+    return proxyProcessor(this);
+  }
+  getChainId() {
+    return this.config.network;
+  }
+  onMoveEvent(handler, filter, handlerOptions) {
+    let _filters = [];
+    const _fetchConfig = MoveFetchConfig.fromPartial({ ...DEFAULT_FETCH_CONFIG2, ...handlerOptions });
+    if (Array.isArray(filter)) {
+      _filters = filter;
+    } else {
+      _filters.push(filter);
+    }
+    const processor = this;
+    this.eventHandlers.push({
+      handlerName: getHandlerName(),
+      handler: /* @__PURE__ */ __name(async function(data) {
+        if (!data.rawTransaction) {
+          throw new import_nice_grpc6.ServerError(import_nice_grpc6.Status.INVALID_ARGUMENT, "event is null");
+        }
+        const txn = JSON.parse(data.rawTransaction);
+        if (txn.events == null) {
+          txn.events = [];
+        }
+        const evt = JSON.parse(data.rawEvent);
+        const idx = Number(evt.id.eventSeq) || 0;
+        const ctx = new IotaContext(
+          processor.moduleName,
+          processor.config.network,
+          processor.config.address,
+          data.timestamp || /* @__PURE__ */ new Date(0),
+          data.slot,
+          txn,
+          idx,
+          processor.config.baseLabels
+        );
+        const decoded = await processor.coder.decodeEvent(evt);
+        await handler(decoded || evt, ctx);
+        return ctx.stopAndGetResult();
+      }, "handler"),
+      filters: _filters,
+      fetchConfig: _fetchConfig,
+      partitionHandler: /* @__PURE__ */ __name(async (data) => {
+        const p = handlerOptions?.partitionKey;
+        if (!p) return void 0;
+        if (typeof p === "function") {
+          const evt = JSON.parse(data.rawEvent);
+          const decoded = await processor.coder.decodeEvent(evt);
+          return p(decoded || evt);
+        }
+        return p;
+      }, "partitionHandler")
+    });
+    return this;
+  }
+  onEntryFunctionCall(handler, filter, handlerOptions) {
+    let _filters = [];
+    const _fetchConfig = MoveFetchConfig.fromPartial({ ...DEFAULT_FETCH_CONFIG2, ...handlerOptions });
+    if (Array.isArray(filter)) {
+      _filters = filter;
+    } else {
+      _filters.push(filter);
+    }
+    const processor = this;
+    const allFunctionType = new Set(_filters.map((f) => f.function));
+    this.callHandlers.push({
+      handlerName: getHandlerName(),
+      handler: /* @__PURE__ */ __name(async function(data) {
+        if (!data.rawTransaction) {
+          throw new import_nice_grpc6.ServerError(import_nice_grpc6.Status.INVALID_ARGUMENT, "call is null");
+        }
+        const tx = JSON.parse(data.rawTransaction);
+        const ctx = new IotaContext(
+          processor.moduleName,
+          processor.config.network,
+          processor.config.address,
+          data.timestamp || /* @__PURE__ */ new Date(0),
+          data.slot,
+          tx,
+          0,
+          processor.config.baseLabels
+        );
+        if (tx) {
+          const calls = getMoveCalls2(tx);
+          const txKind = tx.transaction?.data?.transaction;
+          if (!txKind) {
+            throw new import_nice_grpc6.ServerError(import_nice_grpc6.Status.INVALID_ARGUMENT, "Unexpected getTransactionKind get empty");
+          }
+          const programmableTx = txKind.kind === "ProgrammableTransaction" ? txKind : void 0;
+          for (const call of calls) {
+            const functionType = [call.module, call.function].join(SPLITTER);
+            if (!allFunctionType.has(functionType)) {
+              continue;
+            }
+            const decoded = await processor.coder.decodeFunctionPayload(call, programmableTx?.inputs || []);
+            await handler(decoded, ctx);
+          }
+        }
+        return ctx.stopAndGetResult();
+      }, "handler"),
+      filters: _filters,
+      fetchConfig: _fetchConfig,
+      partitionHandler: /* @__PURE__ */ __name(async (data) => {
+        const p = handlerOptions?.partitionKey;
+        if (!p) return void 0;
+        if (typeof p === "function") {
+          const tx = JSON.parse(data.rawTransaction);
+          const calls = getMoveCalls2(tx);
+          if (calls.length > 0) {
+            return p(calls[0]);
+          }
+          return void 0;
+        }
+        return p;
+      }, "partitionHandler")
+    });
+    return this;
+  }
+  onEvent(handler, handlerOptions) {
+    this.onMoveEvent(handler, { type: "" }, handlerOptions);
+    return this;
+  }
+  onTransactionBlock(handler, filter, handlerOptions) {
+    const _fetchConfig = MoveFetchConfig.fromPartial({ ...DEFAULT_FETCH_CONFIG2, ...handlerOptions });
+    const processor = this;
+    this.callHandlers.push({
+      handlerName: getHandlerName(),
+      handler: /* @__PURE__ */ __name(async function(data) {
+        if (!data.rawTransaction) {
+          throw new import_nice_grpc6.ServerError(import_nice_grpc6.Status.INVALID_ARGUMENT, "transaction is null");
+        }
+        const tx = JSON.parse(data.rawTransaction);
+        const ctx = new IotaContext(
+          processor.moduleName,
+          processor.config.network,
+          processor.config.address,
+          data.timestamp || /* @__PURE__ */ new Date(0),
+          data.slot,
+          tx,
+          0,
+          processor.config.baseLabels
+        );
+        if (tx) {
+          await handler(tx, ctx);
+        }
+        return ctx.stopAndGetResult();
+      }, "handler"),
+      filters: [{ ...filter, function: "" }],
+      fetchConfig: _fetchConfig,
+      partitionHandler: /* @__PURE__ */ __name(async (data) => {
+        const p = handlerOptions?.partitionKey;
+        if (!p) return void 0;
+        if (typeof p === "function") {
+          const tx = JSON.parse(data.rawTransaction);
+          return p(tx);
+        }
+        return p;
+      }, "partitionHandler")
+    });
+    return this;
+  }
+  onObjectChange(handler, type) {
+    if (this.config.network === IotaNetwork.TEST_NET) {
+      throw new import_nice_grpc6.ServerError(import_nice_grpc6.Status.INVALID_ARGUMENT, "object change not supported in testnet");
+    }
+    const processor = this;
+    this.objectChangeHandlers.push({
+      handlerName: getHandlerName(),
+      handler: /* @__PURE__ */ __name(async function(data) {
+        const ctx = new IotaObjectChangeContext(
+          processor.config.network,
+          processor.config.address,
+          data.timestamp || /* @__PURE__ */ new Date(0),
+          data.slot,
+          data.txDigest,
+          processor.config.baseLabels
+        );
+        await handler(data.rawChanges.map((r) => JSON.parse(r)), ctx);
+        return ctx.stopAndGetResult();
+      }, "handler"),
+      type
+    });
+    return this;
+  }
+};
+var IotaModulesProcessor = class _IotaModulesProcessor extends IotaBaseProcessor {
+  static {
+    __name(this, "IotaModulesProcessor");
+  }
+  static bind(options) {
+    return new _IotaModulesProcessor(ALL_ADDRESS, options);
+  }
+};
+var IotaGlobalProcessor = class _IotaGlobalProcessor extends IotaBaseProcessor {
+  static {
+    __name(this, "IotaGlobalProcessor");
+  }
+  static bind(options) {
+    return new _IotaGlobalProcessor(ALL_ADDRESS, { ...options, address: ALL_ADDRESS });
+  }
+  onTransactionBlock(handler, filter, fetchConfig) {
+    return super.onTransactionBlock(handler, filter, fetchConfig);
+  }
+  // deprecated,, use object type processor
+  onObjectChange(handler, type) {
+    return super.onObjectChange(handler, type);
+  }
+};
+import("node:process").then((p) => p.stdout.write(""));
+
+// src/iota/iota-plugin-part.ts
+import { SuiChainId as SuiChainId2 } from "@sentio/chain";
+var IotaPluginPart = class {
+  constructor(handlerRegister, partitionManager) {
+    this.handlerRegister = handlerRegister;
+    this.partitionManager = partitionManager;
+  }
+  static {
+    __name(this, "IotaPluginPart");
+  }
+  async start(request) {
+    await initCoinList2();
+    console.log("total instances:", request.templateInstances.length);
+    const allowedChainIds = /* @__PURE__ */ new Set([SuiChainId2.IOTA_MAINNET, SuiChainId2.IOTA_TESTNET]);
+    for (const instance of request.templateInstances) {
+      if (!allowedChainIds.has(instance.contract?.chainId || "")) {
+        continue;
+      }
+      console.log("start template instance", instance.templateId);
+      const template = IotaAccountProcessorTemplateState.INSTANCE.getValues()[instance.templateId];
+      template.bind(
+        {
+          address: instance.contract?.address || "",
+          objectId: instance.contract?.address || "",
+          network: instance.contract?.chainId || IotaNetwork.MAIN_NET,
+          startCheckpoint: instance.startBlock || 0n,
+          endCheckpoint: instance.endBlock || 0n,
+          baseLabels: instance.baseLabels
+        },
+        NoopContext2
+      );
+    }
+  }
+  async init(config) {
+    for (const state of [IotaProcessorState.INSTANCE, IotaAccountProcessorState.INSTANCE]) {
+      for (const suiProcessor of state.getValues()) {
+        config.chainIds.push(suiProcessor.config.network);
+      }
+    }
+  }
+  async configure(config, forChainId) {
+    for (const suiProcessor of IotaProcessorState.INSTANCE.getValues()) {
+      const chainId = suiProcessor.config.network;
+      if (forChainId !== void 0 && forChainId !== chainId.toString()) {
+        continue;
+      }
+      const contractConfig = ContractConfig.fromPartial({
+        transactionConfig: [],
+        processorType: USER_PROCESSOR2,
+        contract: {
+          name: suiProcessor.moduleName,
+          chainId: suiProcessor.config.network,
+          address: suiProcessor.config.address,
+          abi: ""
+        },
+        startBlock: suiProcessor.config.startCheckpoint,
+        endBlock: suiProcessor.config.endCheckpoint
+      });
+      for (const handler of suiProcessor.eventHandlers) {
+        const handlerId = this.handlerRegister.register(handler.handler, chainId);
+        this.partitionManager.registerPartitionHandler(HandlerType.SUI_EVENT, handlerId, handler.partitionHandler);
+        const eventHandlerConfig = {
+          filters: handler.filters.map((f) => {
+            return {
+              type: f.type,
+              account: f.account || "",
+              eventAccount: f.eventAccount || ""
+            };
+          }),
+          fetchConfig: handler.fetchConfig,
+          handlerId,
+          handlerName: handler.handlerName
+        };
+        contractConfig.moveEventConfigs.push(eventHandlerConfig);
+      }
+      for (const handler of suiProcessor.callHandlers) {
+        const handlerId = this.handlerRegister.register(handler.handler, chainId);
+        this.partitionManager.registerPartitionHandler(HandlerType.SUI_CALL, handlerId, handler.partitionHandler);
+        const functionHandlerConfig = {
+          filters: handler.filters.map((filter) => {
+            return {
+              function: filter.function,
+              typeArguments: filter.typeArguments || [],
+              withTypeArguments: !!filter.typeArguments,
+              includeFailed: filter.includeFailed || false,
+              publicKeyPrefix: filter.publicKeyPrefix || "",
+              fromAndToAddress: filter.fromAndToAddress
+            };
+          }),
+          fetchConfig: handler.fetchConfig,
+          handlerId,
+          handlerName: handler.handlerName
+        };
+        contractConfig.moveCallConfigs.push(functionHandlerConfig);
+      }
+      for (const handler of suiProcessor.objectChangeHandlers) {
+        const handlerId = this.handlerRegister.register(handler.handler, chainId);
+        const objectChangeHandler = {
+          type: handler.type,
+          handlerId,
+          handlerName: handler.handlerName,
+          includeDeleted: false
+        };
+        contractConfig.moveResourceChangeConfigs.push(objectChangeHandler);
+      }
+      config.contractConfigs.push(contractConfig);
+    }
+    for (const processor of IotaAccountProcessorState.INSTANCE.getValues()) {
+      const chainId = processor.getChainId();
+      if (forChainId !== void 0 && forChainId !== chainId.toString()) {
+        continue;
+      }
+      const accountConfig = AccountConfig.fromPartial({
+        address: processor.config.address,
+        chainId: processor.getChainId(),
+        startBlock: processor.config.startCheckpoint,
+        // TODO maybe use another field
+        endBlock: processor.config.endCheckpoint
+      });
+      for (const handler of processor.objectChangeHandlers) {
+        const handlerId = this.handlerRegister.register(handler.handler, chainId);
+        const objectChangeHandler = {
+          type: handler.type,
+          handlerId,
+          handlerName: handler.handlerName,
+          includeDeleted: false
+        };
+        accountConfig.moveResourceChangeConfigs.push(objectChangeHandler);
+      }
+      for (const handler of processor.objectHandlers) {
+        const handlerId = this.handlerRegister.register(handler.handler, chainId);
+        accountConfig.moveIntervalConfigs.push({
+          intervalConfig: {
+            handlerId,
+            handlerName: handler.handlerName,
+            minutes: 0,
+            minutesInterval: handler.timeIntervalInMinutes,
+            slot: 0,
+            slotInterval: handler.checkPointInterval,
+            fetchConfig: void 0
+          },
+          type: handler.type || "",
+          ownerType: processor.ownerType,
+          resourceFetchConfig: handler.fetchConfig,
+          fetchConfig: void 0
+        });
+      }
+      if (processor instanceof IotaAddressProcessor) {
+        for (const handler of processor.callHandlers) {
+          const handlerId = this.handlerRegister.register(handler.handler, chainId);
+          const functionHandlerConfig = {
+            filters: handler.filters.map((filter) => {
+              return {
+                function: filter.function,
+                typeArguments: filter.typeArguments || [],
+                withTypeArguments: !!filter.typeArguments,
+                includeFailed: filter.includeFailed || false,
+                publicKeyPrefix: filter.publicKeyPrefix || "",
+                fromAndToAddress: filter.fromAndToAddress
+              };
+            }),
+            fetchConfig: handler.fetchConfig,
+            handlerId,
+            handlerName: handler.handlerName
+          };
+          accountConfig.moveCallConfigs.push(functionHandlerConfig);
+        }
+      }
+      config.accountConfigs.push(accountConfig);
+    }
+  }
+};
+var NoopContext2 = new IotaContext("", SuiChainId2.IOTA_MAINNET, "", /* @__PURE__ */ new Date(), 0n, {}, 0, {});
+import("node:process").then((p) => p.stdout.write(""));
+
+// src/sui/sui-plugin.ts
+var SuiPlugin = class extends Plugin {
+  static {
+    __name(this, "SuiPlugin");
+  }
+  name = "SuiPlugin";
+  handlerRegister = new HandlerRegister();
+  partitionManager = new PartitionHandlerManager();
+  suiPart = new SuiPluginPart(this.handlerRegister, this.partitionManager);
+  iotaPart = new IotaPluginPart(this.handlerRegister, this.partitionManager);
+  async start(request) {
+    await this.suiPart.start(request);
+    await this.iotaPart.start(request);
+  }
+  async init(config) {
+    await this.suiPart.init(config);
+    await this.iotaPart.init(config);
+  }
+  async configure(config, forChainId) {
+    this.handlerRegister.clear(forChainId);
+    await this.suiPart.configure(config);
+    await this.iotaPart.configure(config);
+  }
+  supportedHandlers = [
+    HandlerType.SUI_EVENT,
+    HandlerType.SUI_CALL,
+    HandlerType.SUI_OBJECT,
+    HandlerType.SUI_OBJECT_CHANGE
+  ];
+  processBinding(request) {
+    switch (request.handlerType) {
+      case HandlerType.SUI_EVENT:
+        return this.processSuiEvent(request);
+      case HandlerType.SUI_CALL:
+        return this.processSuiFunctionCall(request);
+      case HandlerType.SUI_OBJECT:
+        return this.processSuiObject(request);
+      case HandlerType.SUI_OBJECT_CHANGE:
+        return this.processSuiObjectChange(request);
+      default:
+        throw new import_nice_grpc7.ServerError(import_nice_grpc7.Status.INVALID_ARGUMENT, "No handle type registered " + request.handlerType);
+    }
+  }
+  async partition(request) {
+    let data;
     switch (request.handlerType) {
       case HandlerType.SUI_EVENT:
         if (!request.data?.suiEvent) {
-          throw new import_nice_grpc4.ServerError(import_nice_grpc4.Status.INVALID_ARGUMENT, "suiEvent can't be empty");
+          throw new import_nice_grpc7.ServerError(import_nice_grpc7.Status.INVALID_ARGUMENT, "suiEvent can't be empty");
         }
         data = request.data.suiEvent;
         break;
       case HandlerType.SUI_CALL:
         if (!request.data?.suiCall) {
-          throw new import_nice_grpc4.ServerError(import_nice_grpc4.Status.INVALID_ARGUMENT, "suiCall can't be empty");
+          throw new import_nice_grpc7.ServerError(import_nice_grpc7.Status.INVALID_ARGUMENT, "suiCall can't be empty");
         }
         data = request.data.suiCall;
         break;
       case HandlerType.SUI_OBJECT:
         if (!request.data?.suiObject) {
-          throw new import_nice_grpc4.ServerError(import_nice_grpc4.Status.INVALID_ARGUMENT, "suiObject can't be empty");
+          throw new import_nice_grpc7.ServerError(import_nice_grpc7.Status.INVALID_ARGUMENT, "suiObject can't be empty");
         }
         data = request.data.suiObject;
         break;
       case HandlerType.SUI_OBJECT_CHANGE:
         if (!request.data?.suiObjectChange) {
-          throw new import_nice_grpc4.ServerError(import_nice_grpc4.Status.INVALID_ARGUMENT, "suiObjectChange can't be empty");
+          throw new import_nice_grpc7.ServerError(import_nice_grpc7.Status.INVALID_ARGUMENT, "suiObjectChange can't be empty");
         }
         data = request.data.suiObjectChange;
         break;
       default:
-        throw new import_nice_grpc4.ServerError(import_nice_grpc4.Status.INVALID_ARGUMENT, "No handle type registered " + request.handlerType);
+        throw new import_nice_grpc7.ServerError(import_nice_grpc7.Status.INVALID_ARGUMENT, "No handle type registered " + request.handlerType);
     }
     const partitions = await this.partitionManager.processPartitionForHandlerType(
       request.handlerType,
@@ -1889,7 +3275,7 @@ var SuiPlugin = class extends Plugin {
   }
   async processSuiEvent(binding) {
     if (!binding.data?.suiEvent) {
-      throw new import_nice_grpc4.ServerError(import_nice_grpc4.Status.INVALID_ARGUMENT, "Event can't be empty");
+      throw new import_nice_grpc7.ServerError(import_nice_grpc7.Status.INVALID_ARGUMENT, "Event can't be empty");
     }
     const promises = [];
     const event = binding.data.suiEvent;
@@ -1899,8 +3285,8 @@ var SuiPlugin = class extends Plugin {
           binding.chainId,
           handlerId
         )(event).catch((e) => {
-          throw new import_nice_grpc4.ServerError(
-            import_nice_grpc4.Status.INTERNAL,
+          throw new import_nice_grpc7.ServerError(
+            import_nice_grpc7.Status.INTERNAL,
             "error processing event: " + JSON.stringify(event) + "\n" + errorString(e)
           );
         })
@@ -1910,7 +3296,7 @@ var SuiPlugin = class extends Plugin {
   }
   async processSuiFunctionCall(binding) {
     if (!binding.data?.suiCall) {
-      throw new import_nice_grpc4.ServerError(import_nice_grpc4.Status.INVALID_ARGUMENT, "Call can't be empty");
+      throw new import_nice_grpc7.ServerError(import_nice_grpc7.Status.INVALID_ARGUMENT, "Call can't be empty");
     }
     const call = binding.data.suiCall;
     const promises = [];
@@ -1919,8 +3305,8 @@ var SuiPlugin = class extends Plugin {
         binding.chainId,
         handlerId
       )(call).catch((e) => {
-        throw new import_nice_grpc4.ServerError(
-          import_nice_grpc4.Status.INTERNAL,
+        throw new import_nice_grpc7.ServerError(
+          import_nice_grpc7.Status.INTERNAL,
           "error processing call: " + JSON.stringify(call) + "\n" + errorString(e)
         );
       });
@@ -1930,7 +3316,7 @@ var SuiPlugin = class extends Plugin {
   }
   async processSuiObject(binding) {
     if (!binding.data?.suiObject) {
-      throw new import_nice_grpc4.ServerError(import_nice_grpc4.Status.INVALID_ARGUMENT, "Object can't be empty");
+      throw new import_nice_grpc7.ServerError(import_nice_grpc7.Status.INVALID_ARGUMENT, "Object can't be empty");
     }
     const object = binding.data.suiObject;
     const promises = [];
@@ -1940,8 +3326,8 @@ var SuiPlugin = class extends Plugin {
           binding.chainId,
           handlerId
         )(object).catch((e) => {
-          throw new import_nice_grpc4.ServerError(
-            import_nice_grpc4.Status.INTERNAL,
+          throw new import_nice_grpc7.ServerError(
+            import_nice_grpc7.Status.INTERNAL,
             "error processing object: " + JSON.stringify(object) + "\n" + errorString(e)
           );
         })
@@ -1951,7 +3337,7 @@ var SuiPlugin = class extends Plugin {
   }
   async processSuiObjectChange(binding) {
     if (!binding.data?.suiObjectChange) {
-      throw new import_nice_grpc4.ServerError(import_nice_grpc4.Status.INVALID_ARGUMENT, "Object change can't be empty");
+      throw new import_nice_grpc7.ServerError(import_nice_grpc7.Status.INVALID_ARGUMENT, "Object change can't be empty");
     }
     const objectChange = binding.data.suiObjectChange;
     const promises = [];
@@ -1961,8 +3347,8 @@ var SuiPlugin = class extends Plugin {
           binding.chainId,
           handlerId
         )(objectChange).catch((e) => {
-          throw new import_nice_grpc4.ServerError(
-            import_nice_grpc4.Status.INTERNAL,
+          throw new import_nice_grpc7.ServerError(
+            import_nice_grpc7.Status.INTERNAL,
             "error processing object change: " + JSON.stringify(objectChange) + "\n" + errorString(e)
           );
         })
@@ -1979,26 +3365,56 @@ import("node:process").then((p) => p.stdout.write(""));
 import("node:process").then((p) => p.stdout.write(""));
 
 export {
-  ZERO_ADDRESS,
-  transactionArgumentOrObject,
-  transactionArgumentOrPure,
-  transactionArgumentOrPureAddress,
-  transactionArgumentOrPureU8,
-  transactionArgumentOrPureU16,
-  transactionArgumentOrPureU32,
-  transactionArgumentOrPureU64,
-  transactionArgumentOrPureU128,
-  transactionArgumentOrPureU256,
-  transactionArgumentOrPureBool,
-  transactionArgumentOrVec,
-  MoveCoder,
-  getMoveCoder,
-  defaultMoveCoder2 as defaultMoveCoder,
+  ZERO_ADDRESS2 as ZERO_ADDRESS,
+  transactionArgumentOrObject2 as transactionArgumentOrObject,
+  transactionArgumentOrPure2 as transactionArgumentOrPure,
+  transactionArgumentOrPureAddress2 as transactionArgumentOrPureAddress,
+  transactionArgumentOrPureU82 as transactionArgumentOrPureU8,
+  transactionArgumentOrPureU162 as transactionArgumentOrPureU16,
+  transactionArgumentOrPureU322 as transactionArgumentOrPureU32,
+  transactionArgumentOrPureU642 as transactionArgumentOrPureU64,
+  transactionArgumentOrPureU1282 as transactionArgumentOrPureU128,
+  transactionArgumentOrPureU2562 as transactionArgumentOrPureU256,
+  transactionArgumentOrPureBool2 as transactionArgumentOrPureBool,
+  transactionArgumentOrVec2 as transactionArgumentOrVec,
+  MoveCoder3 as MoveCoder,
+  getMoveCoder2 as getMoveCoder,
+  defaultMoveCoder4 as defaultMoveCoder,
+  IotaContext,
+  IotaObjectChangeContext,
+  IotaAddressContext,
+  IotaObjectContext,
+  getMoveCalls2 as getMoveCalls,
+  IotaBaseProcessor,
+  IotaModulesProcessor,
+  IotaGlobalProcessor,
+  IotaAddressProcessor,
+  IotaObjectProcessor,
+  IotaObjectTypeProcessor,
+  IotaWrappedObjectProcessor,
+  IotaAddressProcessorTemplate,
+  IotaObjectProcessorTemplate,
+  IotaWrappedObjectProcessorTemplate,
+  ZERO_ADDRESS as ZERO_ADDRESS2,
+  transactionArgumentOrObject as transactionArgumentOrObject2,
+  transactionArgumentOrPure as transactionArgumentOrPure2,
+  transactionArgumentOrPureAddress as transactionArgumentOrPureAddress2,
+  transactionArgumentOrPureU8 as transactionArgumentOrPureU82,
+  transactionArgumentOrPureU16 as transactionArgumentOrPureU162,
+  transactionArgumentOrPureU32 as transactionArgumentOrPureU322,
+  transactionArgumentOrPureU64 as transactionArgumentOrPureU642,
+  transactionArgumentOrPureU128 as transactionArgumentOrPureU1282,
+  transactionArgumentOrPureU256 as transactionArgumentOrPureU2562,
+  transactionArgumentOrPureBool as transactionArgumentOrPureBool2,
+  transactionArgumentOrVec as transactionArgumentOrVec2,
+  MoveCoder as MoveCoder2,
+  getMoveCoder as getMoveCoder2,
+  defaultMoveCoder2,
   SuiContext,
   SuiObjectChangeContext,
   SuiAddressContext,
   SuiObjectContext,
-  getMoveCalls,
+  getMoveCalls as getMoveCalls2,
   SuiBaseProcessor,
   SuiModulesProcessor,
   SuiGlobalProcessor,
@@ -2009,6 +3425,7 @@ export {
   SuiAddressProcessorTemplate,
   SuiObjectProcessorTemplate,
   SuiWrappedObjectProcessorTemplate,
-  SuiPlugin
+  SuiPlugin,
+  IotaPlugin
 };
-//# sourceMappingURL=chunk-KORR4KWH.js.map
+//# sourceMappingURL=chunk-RQEJ6VYV.js.map