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

package/lib/chunk-E2DS6WZF.js

@@ -1,1690 +0,0 @@
-import { createRequire as createRequireSdkShim } from 'module'; const require = createRequireSdkShim(import.meta.url);
-import {
-  SuiClient,
-  SuiNetwork,
-  getClient,
-  initCoinList,
-  normalizeSuiAddress,
-  normalizeSuiObjectId,
-  suiBcs
-} from "./chunk-4HPFNKDX.js";
-import {
-  getHandlerName,
-  proxyProcessor
-} from "./chunk-43HP4DQZ.js";
-import {
-  ANY_TYPE,
-  AbstractMoveCoder,
-  ChainAdapter,
-  InternalMoveFunctionVisibility,
-  MoveAccountContext,
-  MoveContext,
-  SPLITTER,
-  TypeDescriptor,
-  accountAddressString,
-  accountTypeString,
-  moduleQname,
-  parseMoveType
-} from "./chunk-4OCWUYSJ.js";
-import {
-  ALL_ADDRESS,
-  AccountConfig,
-  ContractConfig,
-  HandlerType,
-  MoveFetchConfig,
-  MoveOwnerType,
-  TemplateInstanceState,
-  normalizeLabels
-} from "./chunk-2F2KNF4Z.js";
-import {
-  require_lib
-} from "./chunk-73SHERGU.js";
-import {
-  __name,
-  __toESM
-} from "./chunk-R7PMHHKJ.js";
-
-// src/sui/sui-processor.ts
-import { ListStateStorage } from "@sentio/runtime";
-var import_nice_grpc = __toESM(require_lib(), 1);
-
-// ../../node_modules/.pnpm/@typemove+sui@1.9.0_typescript@5.5.2/node_modules/@typemove/sui/dist/esm/models.js
-var ZERO_ADDRESS = "0x0000000000000000000000000000000000000000000000000000000000000000";
-
-// ../../node_modules/.pnpm/@typemove+sui@1.9.0_typescript@5.5.2/node_modules/@typemove/sui/dist/esm/transaction.js
-function isTransactionArgument(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(isTransactionArgument, "isTransactionArgument");
-function transactionArgumentOrObject(value, transactionBlock) {
-  if (isTransactionArgument(value)) {
-    return value;
-  }
-  return transactionBlock.object(value);
-}
-__name(transactionArgumentOrObject, "transactionArgumentOrObject");
-function transactionArgumentOrPure(value, transactionBlock) {
-  if (isTransactionArgument(value)) {
-    return value;
-  }
-  return typeof value == "string" ? transactionBlock.pure.string(value) : transactionBlock.pure.u64(value);
-}
-__name(transactionArgumentOrPure, "transactionArgumentOrPure");
-function transactionArgumentOrPureAddress(value, transactionBlock) {
-  if (isTransactionArgument(value)) {
-    return value;
-  }
-  return transactionBlock.pure.address(value);
-}
-__name(transactionArgumentOrPureAddress, "transactionArgumentOrPureAddress");
-function transactionArgumentOrPureU8(value, transactionBlock) {
-  if (isTransactionArgument(value)) {
-    return value;
-  }
-  return transactionBlock.pure.u8(value);
-}
-__name(transactionArgumentOrPureU8, "transactionArgumentOrPureU8");
-function transactionArgumentOrPureU16(value, transactionBlock) {
-  if (isTransactionArgument(value)) {
-    return value;
-  }
-  return transactionBlock.pure.u16(value);
-}
-__name(transactionArgumentOrPureU16, "transactionArgumentOrPureU16");
-function transactionArgumentOrPureU32(value, transactionBlock) {
-  if (isTransactionArgument(value)) {
-    return value;
-  }
-  return transactionBlock.pure.u32(value);
-}
-__name(transactionArgumentOrPureU32, "transactionArgumentOrPureU32");
-function transactionArgumentOrPureU64(value, transactionBlock) {
-  if (isTransactionArgument(value)) {
-    return value;
-  }
-  return transactionBlock.pure.u64(value);
-}
-__name(transactionArgumentOrPureU64, "transactionArgumentOrPureU64");
-function transactionArgumentOrPureU128(value, transactionBlock) {
-  if (isTransactionArgument(value)) {
-    return value;
-  }
-  return transactionBlock.pure.u128(value);
-}
-__name(transactionArgumentOrPureU128, "transactionArgumentOrPureU128");
-function transactionArgumentOrPureU256(value, transactionBlock) {
-  if (isTransactionArgument(value)) {
-    return value;
-  }
-  return transactionBlock.pure.u256(value);
-}
-__name(transactionArgumentOrPureU256, "transactionArgumentOrPureU256");
-function transactionArgumentOrPureBool(value, transactionBlock) {
-  if (isTransactionArgument(value)) {
-    return value;
-  }
-  return transactionBlock.pure.bool(value);
-}
-__name(transactionArgumentOrPureBool, "transactionArgumentOrPureBool");
-function transactionArgumentOrVec(value, transactionBlock) {
-  if (isTransactionArgument(value)) {
-    return value;
-  }
-  return transactionBlock.makeMoveVec({
-    elements: value.map((a) => transactionBlock.object(a))
-  });
-}
-__name(transactionArgumentOrVec, "transactionArgumentOrVec");
-
-// ../../node_modules/.pnpm/@typemove+sui@1.9.0_typescript@5.5.2/node_modules/@typemove/sui/dist/esm/to-internal.js
-function toInternalModule(module) {
-  return {
-    address: module.address,
-    exposedFunctions: Object.entries(module.exposedFunctions).map(([n, f]) => toInternalFunction(n, f)),
-    name: module.name,
-    structs: Object.entries(module.structs).map(([n, s]) => toInternalStruct(n, s)),
-    enums: Object.entries(module.enums || {}).map(([n, e]) => toInternalEnum(n, e))
-  };
-}
-__name(toInternalModule, "toInternalModule");
-function toInternalFunction(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(toTypeDescriptor),
-    return: func.return.map(toTypeDescriptor),
-    visibility
-  };
-}
-__name(toInternalFunction, "toInternalFunction");
-function toInternalStruct(name, struct) {
-  return {
-    abilities: struct.abilities.abilities,
-    fields: struct.fields.map(toInternalField),
-    typeParams: struct.typeParameters.map((p) => {
-      return { constraints: p.constraints.abilities };
-    }),
-    isNative: false,
-    isEvent: false,
-    name
-  };
-}
-__name(toInternalStruct, "toInternalStruct");
-function toInternalEnum(name, enumType) {
-  return {
-    name,
-    abilities: enumType.abilities.abilities,
-    typeParams: enumType.typeParameters.map((p) => {
-      return { constraints: p.constraints.abilities };
-    }),
-    variants: Object.entries(enumType.variants).reduce((acc, [k, v]) => {
-      acc[k] = v.map(toInternalField);
-      return acc;
-    }, {})
-  };
-}
-__name(toInternalEnum, "toInternalEnum");
-function toInternalField(module) {
-  return {
-    name: module.name,
-    type: toTypeDescriptor(module.type)
-  };
-}
-__name(toInternalField, "toInternalField");
-function toTypeDescriptor(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(toTypeDescriptor);
-    return new TypeDescriptor(qname, args);
-  }
-  if ("Vector" in normalizedType) {
-    return new TypeDescriptor("Vector", [toTypeDescriptor(normalizedType.Vector)]);
-  }
-  if ("TypeParameter" in normalizedType) {
-    return new TypeDescriptor("T" + normalizedType.TypeParameter);
-  }
-  if ("Reference" in normalizedType) {
-    const res = toTypeDescriptor(normalizedType.Reference);
-    res.reference = true;
-    return res;
-  }
-  if ("MutableReference" in normalizedType) {
-    const res = toTypeDescriptor(normalizedType.MutableReference);
-    res.reference = true;
-    res.mutable = true;
-    return res;
-  }
-  throw new Error("Unexpected sui type");
-}
-__name(toTypeDescriptor, "toTypeDescriptor");
-
-// ../../node_modules/.pnpm/@typemove+sui@1.9.0_typescript@5.5.2/node_modules/@typemove/sui/dist/esm/sui-chain-adapter.js
-var SuiChainAdapter = class extends ChainAdapter {
-  static {
-    __name(this, "SuiChainAdapter");
-  }
-  async getChainId() {
-    return this.client.getChainIdentifier();
-  }
-  // static INSTANCE = new SuiChainAdapter()
-  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(toInternalModule);
-  }
-  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+sui@1.9.0_typescript@5.5.2/node_modules/@typemove/sui/dist/esm/move-coder.js
-var MoveCoder = class extends AbstractMoveCoder {
-  static {
-    __name(this, "MoveCoder");
-  }
-  constructor(client) {
-    super(new SuiChainAdapter(client));
-  }
-  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 = toInternalModule(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 normalizeSuiObjectId(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 normalizeSuiAddress(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 suiBcs[lowerQname]();
-      case "address":
-        return suiBcs.Address;
-      case "vector":
-        return suiBcs.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 suiBcs.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_ENDPOINT = "https://fullnode.mainnet.sui.io/";
-var CODER_MAP = /* @__PURE__ */ new Map();
-function defaultMoveCoder(endpoint = DEFAULT_ENDPOINT) {
-  let coder = CODER_MAP.get(endpoint);
-  if (!coder) {
-    coder = new MoveCoder(new SuiClient({ url: endpoint }));
-    CODER_MAP.set(endpoint, coder);
-  }
-  return coder;
-}
-__name(defaultMoveCoder, "defaultMoveCoder");
-var PROVIDER_CODER_MAP = /* @__PURE__ */ new Map();
-var DEFAULT_CHAIN_ID;
-async function getMoveCoder(client) {
-  let coder = PROVIDER_CODER_MAP.get(client);
-  if (!coder) {
-    coder = new MoveCoder(client);
-    const id = await client.getChainIdentifier();
-    const defaultCoder = defaultMoveCoder();
-    if (!DEFAULT_CHAIN_ID) {
-      DEFAULT_CHAIN_ID = await defaultCoder.adapter.getChainId();
-    }
-    if (id === DEFAULT_CHAIN_ID) {
-      coder = defaultCoder;
-    }
-    PROVIDER_CODER_MAP.set(client, coder);
-  }
-  return coder;
-}
-__name(getMoveCoder, "getMoveCoder");
-
-// src/sui/move-coder.ts
-var CODERS = /* @__PURE__ */ new Map();
-function defaultMoveCoder2(network = SuiNetwork.MAIN_NET) {
-  let coder = CODERS.get(network);
-  if (!coder) {
-    coder = new MoveCoder(getClient(network));
-    CODERS.set(network, coder);
-  }
-  return coder;
-}
-__name(defaultMoveCoder2, "defaultMoveCoder");
-import("node:process").then((p) => p.stdout.write(""));
-
-// src/sui/context.ts
-var SuiContext = class extends MoveContext {
-  static {
-    __name(this, "SuiContext");
-  }
-  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 = defaultMoveCoder2(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 SuiObjectChangeContext = class extends MoveContext {
-  static {
-    __name(this, "SuiObjectChangeContext");
-  }
-  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 = defaultMoveCoder2(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 SuiAddressContext = class extends MoveAccountContext {
-  static {
-    __name(this, "SuiAddressContext");
-  }
-  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 = defaultMoveCoder2(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 SuiObjectContext = class extends SuiAddressContext {
-  static {
-    __name(this, "SuiObjectContext");
-  }
-  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/sui/utils.ts
-function getMoveCalls(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(getMoveCalls, "getMoveCalls");
-import("node:process").then((p) => p.stdout.write(""));
-
-// src/sui/sui-processor.ts
-var DEFAULT_FETCH_CONFIG = {
-  resourceChanges: false,
-  allEvents: true,
-  inputs: true
-};
-function configure(options) {
-  return {
-    startCheckpoint: options.startCheckpoint || 0n,
-    address: options.address === ALL_ADDRESS ? ALL_ADDRESS : accountAddressString(options.address),
-    network: options.network || SuiNetwork.MAIN_NET,
-    baseLabels: options.baseLabels
-  };
-}
-__name(configure, "configure");
-var SuiProcessorState = class _SuiProcessorState extends ListStateStorage {
-  static {
-    __name(this, "SuiProcessorState");
-  }
-  static INSTANCE = new _SuiProcessorState();
-};
-var SuiBaseProcessor = class {
-  static {
-    __name(this, "SuiBaseProcessor");
-  }
-  moduleName;
-  config;
-  eventHandlers = [];
-  callHandlers = [];
-  objectChangeHandlers = [];
-  coder;
-  constructor(name, options) {
-    this.moduleName = name;
-    this.config = configure(options);
-    SuiProcessorState.INSTANCE.addValue(this);
-    this.coder = defaultMoveCoder2(this.config.network);
-    return proxyProcessor(this);
-  }
-  getChainId() {
-    return this.config.network;
-  }
-  onMoveEvent(handler, filter, fetchConfig) {
-    let _filters = [];
-    const _fetchConfig = MoveFetchConfig.fromPartial({ ...DEFAULT_FETCH_CONFIG, ...fetchConfig });
-    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_grpc.ServerError(import_nice_grpc.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 SuiContext(
-          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
-    });
-    return this;
-  }
-  onEntryFunctionCall(handler, filter, fetchConfig) {
-    let _filters = [];
-    const _fetchConfig = MoveFetchConfig.fromPartial({ ...DEFAULT_FETCH_CONFIG, ...fetchConfig });
-    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_grpc.ServerError(import_nice_grpc.Status.INVALID_ARGUMENT, "call is null");
-        }
-        const tx = JSON.parse(data.rawTransaction);
-        const ctx = new SuiContext(
-          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 = getMoveCalls(tx);
-          const txKind = tx.transaction?.data?.transaction;
-          if (!txKind) {
-            throw new import_nice_grpc.ServerError(import_nice_grpc.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
-    });
-    return this;
-  }
-  onEvent(handler, fetchConfig) {
-    this.onMoveEvent(handler, { type: "" }, fetchConfig);
-    return this;
-  }
-  onTransactionBlock(handler, filter, fetchConfig) {
-    const _fetchConfig = MoveFetchConfig.fromPartial({ ...DEFAULT_FETCH_CONFIG, ...fetchConfig });
-    const processor = this;
-    this.callHandlers.push({
-      handlerName: getHandlerName(),
-      handler: /* @__PURE__ */ __name(async function(data) {
-        if (!data.rawTransaction) {
-          throw new import_nice_grpc.ServerError(import_nice_grpc.Status.INVALID_ARGUMENT, "transaction is null");
-        }
-        const tx = JSON.parse(data.rawTransaction);
-        const ctx = new SuiContext(
-          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
-    });
-    return this;
-  }
-  onObjectChange(handler, type) {
-    if (this.config.network === SuiNetwork.TEST_NET) {
-      throw new import_nice_grpc.ServerError(import_nice_grpc.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 SuiObjectChangeContext(
-          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 SuiModulesProcessor = class _SuiModulesProcessor extends SuiBaseProcessor {
-  static {
-    __name(this, "SuiModulesProcessor");
-  }
-  static bind(options) {
-    return new _SuiModulesProcessor(ALL_ADDRESS, options);
-  }
-};
-var SuiGlobalProcessor = class _SuiGlobalProcessor extends SuiBaseProcessor {
-  static {
-    __name(this, "SuiGlobalProcessor");
-  }
-  static bind(options) {
-    return new _SuiGlobalProcessor(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/sui/sui-object-processor.ts
-import { ListStateStorage as ListStateStorage2 } from "@sentio/runtime";
-var import_nice_grpc2 = __toESM(require_lib(), 1);
-var DEFAULT_ACCOUNT_FETCH_CONFIG = {
-  owned: false
-};
-var SuiAccountProcessorState = class _SuiAccountProcessorState extends ListStateStorage2 {
-  static {
-    __name(this, "SuiAccountProcessorState");
-  }
-  static INSTANCE = new _SuiAccountProcessorState();
-};
-var SuiBaseObjectOrAddressProcessor = class {
-  static {
-    __name(this, "SuiBaseObjectOrAddressProcessor");
-  }
-  config;
-  ownerType;
-  templateId;
-  objectHandlers = [];
-  objectChangeHandlers = [];
-  // static bind(options: SuiObjectsBindOptions): SuiBaseObjectsProcessor<any> {
-  //   return new SuiBaseObjectsProcessor(options)
-  // }
-  constructor(options) {
-    if (options.ownerType === MoveOwnerType.TYPE) {
-      this.config = {
-        startCheckpoint: options.startCheckpoint || 0n,
-        address: options.address === "*" ? "*" : accountTypeString(options.address),
-        network: options.network || SuiNetwork.MAIN_NET,
-        baseLabels: options.baseLabels
-      };
-    } else {
-      this.config = configure(options);
-    }
-    this.ownerType = options.ownerType;
-    SuiAccountProcessorState.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 SuiObjectContext(
-          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_CONFIG, ...fetchConfig }
-    });
-    return this;
-  }
-};
-var SuiBaseObjectOrAddressProcessorInternal = class extends SuiBaseObjectOrAddressProcessor {
-  static {
-    __name(this, "SuiBaseObjectOrAddressProcessorInternal");
-  }
-  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 SuiAddressProcessor = class _SuiAddressProcessor extends SuiBaseObjectOrAddressProcessorInternal {
-  static {
-    __name(this, "SuiAddressProcessor");
-  }
-  callHandlers = [];
-  static bind(options) {
-    return new _SuiAddressProcessor({ ...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_CONFIG, ...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_grpc2.ServerError(import_nice_grpc2.Status.INVALID_ARGUMENT, "transaction is null");
-        }
-        const tx = JSON.parse(data.rawTransaction);
-        const ctx = new SuiContext(
-          "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 SuiObjectProcessor = class _SuiObjectProcessor extends SuiBaseObjectOrAddressProcessorInternal {
-  static {
-    __name(this, "SuiObjectProcessor");
-  }
-  static bind(options) {
-    return new _SuiObjectProcessor({
-      address: options.objectId,
-      network: options.network,
-      startCheckpoint: options.startCheckpoint,
-      ownerType: MoveOwnerType.OBJECT,
-      baseLabels: options.baseLabels
-    });
-  }
-  async doHandle(handler, data, ctx) {
-    if (!data.rawSelf) {
-      console.log(`Sui 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 SuiObjectTypeProcessor = class _SuiObjectTypeProcessor extends SuiBaseObjectOrAddressProcessor {
-  static {
-    __name(this, "SuiObjectTypeProcessor");
-  }
-  objectType;
-  static bind(options) {
-    const processor = new _SuiObjectTypeProcessor({
-      address: ALL_ADDRESS,
-      // current only support on all address
-      network: options.network,
-      startCheckpoint: options.startCheckpoint,
-      ownerType: MoveOwnerType.TYPE,
-      baseLabels: options.baseLabels
-    });
-    processor.objectType = options.objectType;
-    return processor;
-  }
-  async doHandle(handler, data, ctx) {
-    if (!data.rawSelf) {
-      console.log(`Sui 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 === SuiNetwork.TEST_NET) {
-      throw new import_nice_grpc2.ServerError(import_nice_grpc2.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 SuiObjectChangeContext(
-          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.qname
-    });
-    return this;
-  }
-  onTimeInterval(handler, timeIntervalInMinutes = 60, backfillTimeIntervalInMinutes = 240, fetchConfig) {
-    return this.onInterval(
-      handler,
-      {
-        recentInterval: timeIntervalInMinutes,
-        backfillInterval: backfillTimeIntervalInMinutes
-      },
-      void 0,
-      this.objectType.qname,
-      fetchConfig
-    );
-  }
-  onCheckpointInterval(handler, checkpointInterval = 1e5, backfillCheckpointInterval = 4e5, fetchConfig) {
-    return this.onInterval(
-      handler,
-      void 0,
-      { recentInterval: checkpointInterval, backfillInterval: backfillCheckpointInterval },
-      this.objectType.qname,
-      fetchConfig
-    );
-  }
-};
-var SuiWrappedObjectProcessor = class _SuiWrappedObjectProcessor extends SuiBaseObjectOrAddressProcessorInternal {
-  static {
-    __name(this, "SuiWrappedObjectProcessor");
-  }
-  static bind(options) {
-    return new _SuiWrappedObjectProcessor({
-      address: options.objectId,
-      network: options.network,
-      startCheckpoint: options.startCheckpoint,
-      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/sui/sui-object-processor-template.ts
-import { ListStateStorage as ListStateStorage3 } from "@sentio/runtime";
-var import_nice_grpc3 = __toESM(require_lib(), 1);
-var SuiAccountProcessorTemplateState = class _SuiAccountProcessorTemplateState extends ListStateStorage3 {
-  static {
-    __name(this, "SuiAccountProcessorTemplateState");
-  }
-  static INSTANCE = new _SuiAccountProcessorTemplateState();
-};
-var SuiObjectOrAddressProcessorTemplate = class {
-  static {
-    __name(this, "SuiObjectOrAddressProcessorTemplate");
-  }
-  id;
-  objectHandlers = [];
-  binds = /* @__PURE__ */ new Set();
-  constructor() {
-    this.id = SuiAccountProcessorTemplateState.INSTANCE.getValues().length;
-    SuiAccountProcessorTemplateState.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_grpc3.ServerError(import_nice_grpc3.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: 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_grpc3.ServerError(import_nice_grpc3.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_grpc3.ServerError(
-        import_nice_grpc3.Status.INVALID_ARGUMENT,
-        `Failed to delete template instance ${sig}, deleted ${deleted} times`
-      );
-    }
-    const oldProcessors = SuiAccountProcessorState.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;
-        }
-      }
-      SuiAccountProcessorState.INSTANCE.addValue(processor);
-    }
-    if (deleted !== 1) {
-      throw new import_nice_grpc3.ServerError(
-        import_nice_grpc3.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_CONFIG, ...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 SuiAddressProcessorTemplate = class extends SuiObjectOrAddressProcessorTemplate {
-  static {
-    __name(this, "SuiAddressProcessorTemplate");
-  }
-  handlers = [];
-  createProcessor(options) {
-    const p = SuiAddressProcessor.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 SuiObjectProcessorTemplate = class extends SuiObjectOrAddressProcessorTemplate {
-  static {
-    __name(this, "SuiObjectProcessorTemplate");
-  }
-  createProcessor(options) {
-    const p = SuiObjectProcessor.bind(options);
-    p.templateId = this.id;
-    return p;
-  }
-};
-var SuiWrappedObjectProcessorTemplate = class extends SuiObjectOrAddressProcessorTemplate {
-  static {
-    __name(this, "SuiWrappedObjectProcessorTemplate");
-  }
-  createProcessor(options) {
-    const p = SuiWrappedObjectProcessor.bind(options);
-    p.templateId = this.id;
-    return p;
-  }
-};
-import("node:process").then((p) => p.stdout.write(""));
-
-// src/sui/models.ts
-import("node:process").then((p) => p.stdout.write(""));
-
-// src/sui/sui-plugin.ts
-import { errorString, mergeProcessResults, Plugin, PluginManager, USER_PROCESSOR } from "@sentio/runtime";
-var import_nice_grpc4 = __toESM(require_lib(), 1);
-import { SuiChainId } from "@sentio/chain";
-var SuiPlugin = class extends Plugin {
-  static {
-    __name(this, "SuiPlugin");
-  }
-  name = "SuiPlugin";
-  handlers = {
-    suiCallHandlers: [],
-    suiEventHandlers: [],
-    suiObjectHandlers: [],
-    suiObjectChangeHandlers: []
-  };
-  async start(request) {
-    await initCoinList();
-    console.log("total instances:", request.templateInstances.length);
-    const allowedChainIds = new Set(Object.values(SuiChainId));
-    for (const instance of request.templateInstances) {
-      if (!allowedChainIds.has(instance.contract?.chainId || "")) {
-        continue;
-      }
-      console.log("start template instance", instance.templateId);
-      const template = SuiAccountProcessorTemplateState.INSTANCE.getValues()[instance.templateId];
-      template.bind(
-        {
-          address: instance.contract?.address || "",
-          objectId: instance.contract?.address || "",
-          network: instance.contract?.chainId || SuiNetwork.MAIN_NET,
-          startCheckpoint: instance.startBlock || 0n,
-          baseLabels: instance.baseLabels
-        },
-        NoopContext
-      );
-    }
-  }
-  async configure(config) {
-    const handlers = {
-      suiCallHandlers: [],
-      suiEventHandlers: [],
-      suiObjectHandlers: [],
-      suiObjectChangeHandlers: []
-    };
-    for (const suiProcessor of SuiProcessorState.INSTANCE.getValues()) {
-      const contractConfig = ContractConfig.fromPartial({
-        transactionConfig: [],
-        processorType: USER_PROCESSOR,
-        contract: {
-          name: suiProcessor.moduleName,
-          chainId: suiProcessor.config.network,
-          address: suiProcessor.config.address,
-          abi: ""
-        },
-        startBlock: suiProcessor.config.startCheckpoint
-      });
-      for (const handler of suiProcessor.eventHandlers) {
-        const handlerId = handlers.suiEventHandlers.push(handler.handler) - 1;
-        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 = handlers.suiCallHandlers.push(handler.handler) - 1;
-        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 = handlers.suiObjectChangeHandlers.push(handler.handler) - 1;
-        const objectChangeHandler = {
-          type: handler.type,
-          handlerId,
-          handlerName: handler.handlerName
-        };
-        contractConfig.moveResourceChangeConfigs.push(objectChangeHandler);
-      }
-      config.contractConfigs.push(contractConfig);
-    }
-    for (const processor of SuiAccountProcessorState.INSTANCE.getValues()) {
-      const accountConfig = AccountConfig.fromPartial({
-        address: processor.config.address,
-        chainId: processor.getChainId(),
-        startBlock: processor.config.startCheckpoint
-        // TODO maybe use another field
-      });
-      for (const handler of processor.objectChangeHandlers) {
-        const handlerId = handlers.suiObjectChangeHandlers.push(handler.handler) - 1;
-        const objectChangeHandler = {
-          type: handler.type,
-          handlerId,
-          handlerName: handler.handlerName
-        };
-        accountConfig.moveResourceChangeConfigs.push(objectChangeHandler);
-      }
-      for (const handler of processor.objectHandlers) {
-        const handlerId = handlers.suiObjectHandlers.push(handler.handler) - 1;
-        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 SuiAddressProcessor) {
-        for (const handler of processor.callHandlers) {
-          const handlerId = handlers.suiCallHandlers.push(handler.handler) - 1;
-          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);
-    }
-    this.handlers = handlers;
-  }
-  async processSuiEvent(binding) {
-    if (!binding.data?.suiEvent) {
-      throw new import_nice_grpc4.ServerError(import_nice_grpc4.Status.INVALID_ARGUMENT, "Event can't be empty");
-    }
-    const promises = [];
-    const event = binding.data.suiEvent;
-    for (const handlerId of binding.handlerIds) {
-      promises.push(
-        this.handlers.suiEventHandlers[handlerId](event).catch((e) => {
-          throw new import_nice_grpc4.ServerError(
-            import_nice_grpc4.Status.INTERNAL,
-            "error processing event: " + JSON.stringify(event) + "\n" + errorString(e)
-          );
-        })
-      );
-    }
-    return mergeProcessResults(await Promise.all(promises));
-  }
-  async processSuiFunctionCall(binding) {
-    if (!binding.data?.suiCall) {
-      throw new import_nice_grpc4.ServerError(import_nice_grpc4.Status.INVALID_ARGUMENT, "Call can't be empty");
-    }
-    const call = binding.data.suiCall;
-    const promises = [];
-    for (const handlerId of binding.handlerIds) {
-      const promise = this.handlers.suiCallHandlers[handlerId](call).catch((e) => {
-        throw new import_nice_grpc4.ServerError(import_nice_grpc4.Status.INTERNAL, "error processing call: " + JSON.stringify(call) + "\n" + errorString(e));
-      });
-      promises.push(promise);
-    }
-    return mergeProcessResults(await Promise.all(promises));
-  }
-  async processSuiObject(binding) {
-    if (!binding.data?.suiObject) {
-      throw new import_nice_grpc4.ServerError(import_nice_grpc4.Status.INVALID_ARGUMENT, "Object can't be empty");
-    }
-    const object = binding.data.suiObject;
-    const promises = [];
-    for (const handlerId of binding.handlerIds) {
-      promises.push(
-        this.handlers.suiObjectHandlers[handlerId](object).catch((e) => {
-          throw new import_nice_grpc4.ServerError(
-            import_nice_grpc4.Status.INTERNAL,
-            "error processing object: " + JSON.stringify(object) + "\n" + errorString(e)
-          );
-        })
-      );
-    }
-    return mergeProcessResults(await Promise.all(promises));
-  }
-  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");
-    }
-    const objectChange = binding.data.suiObjectChange;
-    const promises = [];
-    for (const handlerId of binding.handlerIds) {
-      promises.push(
-        this.handlers.suiObjectChangeHandlers[handlerId](objectChange).catch((e) => {
-          throw new import_nice_grpc4.ServerError(
-            import_nice_grpc4.Status.INTERNAL,
-            "error processing object change: " + JSON.stringify(objectChange) + "\n" + errorString(e)
-          );
-        })
-      );
-    }
-    return mergeProcessResults(await Promise.all(promises));
-  }
-  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);
-    }
-  }
-};
-PluginManager.INSTANCE.register(new SuiPlugin());
-var NoopContext = new SuiContext("", SuiChainId.SUI_MAINNET, "", /* @__PURE__ */ new Date(), 0n, {}, 0, {});
-import("node:process").then((p) => p.stdout.write(""));
-
-// src/sui/index.ts
-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,
-  SuiContext,
-  SuiObjectChangeContext,
-  SuiAddressContext,
-  SuiObjectContext,
-  getMoveCalls,
-  SuiBaseProcessor,
-  SuiModulesProcessor,
-  SuiGlobalProcessor,
-  SuiAddressProcessor,
-  SuiObjectProcessor,
-  SuiObjectTypeProcessor,
-  SuiWrappedObjectProcessor,
-  SuiAddressProcessorTemplate,
-  SuiObjectProcessorTemplate,
-  SuiWrappedObjectProcessorTemplate,
-  SuiPlugin
-};
-//# sourceMappingURL=chunk-E2DS6WZF.js.map