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

package/lib/chunk-XEXUSO2Q.js

@@ -1,1469 +0,0 @@
-import { createRequire as createRequireSdkShim } from 'module'; const require = createRequireSdkShim(import.meta.url);
-import {
-  IotaClient,
-  IotaNetwork,
-  getClient,
-  iotaBcs,
-  normalizeIotaAddress,
-  normalizeIotaObjectId
-} from "./chunk-LP3F7TLM.js";
-import {
-  getHandlerName,
-  proxyProcessor
-} from "./chunk-43HP4DQZ.js";
-import {
-  ANY_TYPE,
-  AbstractMoveCoder,
-  ChainAdapter,
-  InternalMoveFunctionVisibility,
-  MoveAccountContext,
-  MoveContext,
-  SPLITTER,
-  TypeDescriptor,
-  accountAddressString,
-  accountTypeString,
-  moduleQname,
-  parseMoveType
-} from "./chunk-N3RF2ACU.js";
-import {
-  ALL_ADDRESS,
-  MoveFetchConfig,
-  MoveOwnerType,
-  TemplateInstanceState,
-  normalizeLabels
-} from "./chunk-5J7XO34J.js";
-import {
-  require_lib
-} from "./chunk-5GXMJVJP.js";
-import {
-  __name,
-  __toESM
-} from "./chunk-R7PMHHKJ.js";
-
-// src/iota/iota-processor.ts
-import { ListStateStorage } from "@sentio/runtime";
-var import_nice_grpc = __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_ADDRESS = "0x0000000000000000000000000000000000000000000000000000000000000000";
-
-// ../../node_modules/.pnpm/@typemove+iota@1.11.0_typescript@5.5.2/node_modules/@typemove/iota/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+iota@1.11.0_typescript@5.5.2/node_modules/@typemove/iota/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: []
-  };
-}
-__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 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+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(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+iota@1.11.0_typescript@5.5.2/node_modules/@typemove/iota/dist/esm/move-coder.js
-var MoveCoder = 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 = 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 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_ENDPOINT = "https://api.mainnet.iota.cafe/";
-var CODER_MAP = /* @__PURE__ */ new Map();
-function defaultMoveCoder(endpoint = DEFAULT_ENDPOINT) {
-  let coder = CODER_MAP.get(endpoint);
-  if (!coder) {
-    coder = new MoveCoder(new IotaClient({ 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/iota/move-coder.ts
-var CODERS = /* @__PURE__ */ new Map();
-function defaultMoveCoder2(network = IotaNetwork.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/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 = 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 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 = 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 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 = 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 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 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/iota/iota-processor.ts
-var DEFAULT_FETCH_CONFIG = {
-  resourceChanges: false,
-  allEvents: true,
-  inputs: true
-};
-function configure(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(configure, "configure");
-var IotaProcessorState = class _IotaProcessorState extends ListStateStorage {
-  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 = configure(options);
-    IotaProcessorState.INSTANCE.addValue(this);
-    this.coder = defaultMoveCoder2(this.config.network);
-    return proxyProcessor(this);
-  }
-  getChainId() {
-    return this.config.network;
-  }
-  onMoveEvent(handler, filter, handlerOptions) {
-    let _filters = [];
-    const _fetchConfig = MoveFetchConfig.fromPartial({ ...DEFAULT_FETCH_CONFIG, ...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_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 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_CONFIG, ...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_grpc.ServerError(import_nice_grpc.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 = 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,
-      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 = getMoveCalls(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_CONFIG, ...handlerOptions });
-    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 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_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 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-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 IotaAccountProcessorState = class _IotaAccountProcessorState extends ListStateStorage2 {
-  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 = configure(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_CONFIG, ...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_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 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_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 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 ListStateStorage3 } from "@sentio/runtime";
-var import_nice_grpc3 = __toESM(require_lib(), 1);
-var IotaAccountProcessorTemplateState = class _IotaAccountProcessorTemplateState extends ListStateStorage3 {
-  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_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: 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_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 = 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_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 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(""));
-
-export {
-  ZERO_ADDRESS,
-  transactionArgumentOrObject,
-  transactionArgumentOrPure,
-  transactionArgumentOrPureAddress,
-  transactionArgumentOrPureU8,
-  transactionArgumentOrPureU16,
-  transactionArgumentOrPureU32,
-  transactionArgumentOrPureU64,
-  transactionArgumentOrPureU128,
-  transactionArgumentOrPureU256,
-  transactionArgumentOrPureBool,
-  transactionArgumentOrVec,
-  MoveCoder,
-  getMoveCoder,
-  defaultMoveCoder2 as defaultMoveCoder,
-  IotaContext,
-  IotaObjectChangeContext,
-  IotaAddressContext,
-  IotaObjectContext,
-  getMoveCalls,
-  IotaProcessorState,
-  IotaBaseProcessor,
-  IotaModulesProcessor,
-  IotaGlobalProcessor,
-  IotaAccountProcessorState,
-  IotaAddressProcessor,
-  IotaObjectProcessor,
-  IotaObjectTypeProcessor,
-  IotaWrappedObjectProcessor,
-  IotaAccountProcessorTemplateState,
-  IotaAddressProcessorTemplate,
-  IotaObjectProcessorTemplate,
-  IotaWrappedObjectProcessorTemplate,
-  IotaPlugin
-};
-//# sourceMappingURL=chunk-XEXUSO2Q.js.map