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

package/lib/chunk-4OCWUYSJ.js

@@ -1,898 +0,0 @@
-import { createRequire as createRequireSdkShim } from 'module'; const require = createRequireSdkShim(import.meta.url);
-import {
-  BaseContext
-} from "./chunk-2F2KNF4Z.js";
-import {
-  __name
-} from "./chunk-R7PMHHKJ.js";
-
-// src/move/filter.ts
-var EventHandler = class {
-  static {
-    __name(this, "EventHandler");
-  }
-  filters;
-  handlerName;
-  handler;
-  fetchConfig;
-};
-var CallHandler = class {
-  static {
-    __name(this, "CallHandler");
-  }
-  filters;
-  handlerName;
-  handler;
-  fetchConfig;
-};
-var ObjectChangeHandler = class {
-  static {
-    __name(this, "ObjectChangeHandler");
-  }
-  handlerName;
-  handler;
-  type;
-};
-var ResourceChangeHandler = class {
-  static {
-    __name(this, "ResourceChangeHandler");
-  }
-  handlerName;
-  handler;
-  type;
-};
-var ResourceIntervalHandler = class {
-  static {
-    __name(this, "ResourceIntervalHandler");
-  }
-  type;
-  versionInterval;
-  timeIntervalInMinutes;
-  handler;
-  handlerName;
-  fetchConfig;
-};
-var TransactionIntervalHandler = class {
-  static {
-    __name(this, "TransactionIntervalHandler");
-  }
-  versionInterval;
-  timeIntervalInMinutes;
-  handler;
-  handlerName;
-  fetchConfig;
-};
-import("node:process").then((p) => p.stdout.write(""));
-
-// src/move/move-context.ts
-var MoveContext = class extends BaseContext {
-  static {
-    __name(this, "MoveContext");
-  }
-  address;
-  coder;
-  network;
-};
-var MoveAccountContext = class extends BaseContext {
-  static {
-    __name(this, "MoveAccountContext");
-  }
-  address;
-  coder;
-  network;
-};
-import("node:process").then((p) => p.stdout.write(""));
-
-// ../../node_modules/.pnpm/radash@12.1.0/node_modules/radash/dist/esm/string.mjs
-var capitalize = /* @__PURE__ */ __name((str) => {
-  if (!str || str.length === 0)
-    return "";
-  const lower = str.toLowerCase();
-  return lower.substring(0, 1).toUpperCase() + lower.substring(1, lower.length);
-}, "capitalize");
-var camel = /* @__PURE__ */ __name((str) => {
-  const parts = str?.replace(/([A-Z])+/g, capitalize)?.split(/(?=[A-Z])|[\.\-\s_]/).map((x) => x.toLowerCase()) ?? [];
-  if (parts.length === 0)
-    return "";
-  if (parts.length === 1)
-    return parts[0];
-  return parts.reduce((acc, part) => {
-    return `${acc}${part.charAt(0).toUpperCase()}${part.slice(1)}`;
-  });
-}, "camel");
-
-// ../../node_modules/.pnpm/@typemove+move@1.9.0/node_modules/@typemove/move/dist/esm/utils.js
-var SPLITTER = "::";
-var VECTOR_STR = "vector";
-function isFrameworkAccount(account) {
-  const n = parseInt(account, 16);
-  if (Number.isNaN(n)) {
-    return false;
-  }
-  return n >= 0 && n < 16;
-}
-__name(isFrameworkAccount, "isFrameworkAccount");
-function accountTypeString(account) {
-  const withoutPrefix = account.toLowerCase().replace(/^(0x)/, "");
-  return "0x" + withoutPrefix.replace(/^0*/, "");
-}
-__name(accountTypeString, "accountTypeString");
-var MOVE_ADDRESS_LENGTH = 32;
-function isHex(value) {
-  return /^(0x|0X)?[a-fA-F0-9]+$/.test(value);
-}
-__name(isHex, "isHex");
-function getHexByteLength(value) {
-  return /^(0x|0X)/.test(value) ? (value.length - 2) / 2 : value.length / 2;
-}
-__name(getHexByteLength, "getHexByteLength");
-function isValidMoveAddress(value) {
-  return isHex(value) && getHexByteLength(value) <= MOVE_ADDRESS_LENGTH;
-}
-__name(isValidMoveAddress, "isValidMoveAddress");
-function accountAddressString(account) {
-  if (!isValidMoveAddress(account)) {
-    throw Error("Not valid move address");
-  }
-  const address = account.toLowerCase().replace(/^(0x)/, "");
-  return `0x${address.padStart(MOVE_ADDRESS_LENGTH * 2, "0")}`;
-}
-__name(accountAddressString, "accountAddressString");
-var KEYWORDS = /* @__PURE__ */ new Set([
-  "break",
-  "case",
-  "catch",
-  "class",
-  "const",
-  "continue",
-  "debugger",
-  "default",
-  "delete",
-  "do",
-  "else",
-  "enum",
-  "export",
-  "extends",
-  "false",
-  "finally",
-  "for",
-  "function",
-  "if",
-  "import",
-  "in",
-  "instanceof",
-  "new",
-  "null",
-  "return",
-  "super",
-  "switch",
-  "this",
-  "throw",
-  "true",
-  "try",
-  "typeof",
-  "var",
-  "void",
-  "while",
-  "with",
-  "as",
-  "implements",
-  "interface",
-  "let",
-  "package",
-  "private",
-  "protected",
-  "public",
-  "static",
-  "yield",
-  "any",
-  "boolean",
-  "constructor",
-  "declare",
-  // 'get',
-  "module",
-  // 'require',
-  "number",
-  // 'set',
-  "string",
-  "symbol",
-  "type",
-  "from",
-  // 'of',
-  "async",
-  "await",
-  "bigint",
-  "object",
-  "volatile",
-  "namespace"
-]);
-function normalizeToJSName(name) {
-  if (KEYWORDS.has(name)) {
-    return name + "$";
-  }
-  return name;
-}
-__name(normalizeToJSName, "normalizeToJSName");
-function moduleQnameForType(type) {
-  const parts = type.split(SPLITTER).slice(0, 2);
-  return [parts[0], parts[1]];
-}
-__name(moduleQnameForType, "moduleQnameForType");
-function moduleQname(module) {
-  return accountTypeString(module.address) + SPLITTER + module.name;
-}
-__name(moduleQname, "moduleQname");
-function structQname(module, struct) {
-  return [accountTypeString(module.address), module.name, struct.name].join(SPLITTER);
-}
-__name(structQname, "structQname");
-function upperFirst(str) {
-  return str.charAt(0).toUpperCase() + str.slice(1);
-}
-__name(upperFirst, "upperFirst");
-function camel2(str) {
-  const base = camel(str);
-  return str.endsWith("_") ? base + "_" : base;
-}
-__name(camel2, "camel");
-
-// ../../node_modules/.pnpm/@typemove+move@1.9.0/node_modules/@typemove/move/dist/esm/types.js
-var TypeDescriptor = class _TypeDescriptor {
-  static {
-    __name(this, "TypeDescriptor");
-  }
-  qname;
-  reference;
-  mutable;
-  typeArgs;
-  constructor(symbol, typeParams) {
-    this.qname = symbol;
-    this.reference = false;
-    this.mutable = false;
-    this.typeArgs = typeParams || [];
-  }
-  apply(...typeArgs) {
-    const newObj = this.clone();
-    newObj.typeArgs = typeArgs;
-    return newObj;
-  }
-  clone() {
-    const newObj = new _TypeDescriptor(this.qname, this.typeArgs);
-    newObj.reference = this.reference;
-    newObj.mutable = this.mutable;
-    return newObj;
-  }
-  // compare qname without consider case for system type
-  compareQname(t) {
-    let t1 = this.qname;
-    if (BUILTIN_TYPES_SET.has(this.qname.toLowerCase())) {
-      t1 = this.qname.toLowerCase();
-    }
-    let t2 = t.qname;
-    if (BUILTIN_TYPES_SET.has(t.qname.toLowerCase())) {
-      t2 = t.qname;
-    }
-    return t1 === t2;
-  }
-  getSignature() {
-    if (this.typeArgs.length > 0) {
-      return this.qname + "<" + this.typeArgs.map((t) => t.getSignature()).join(", ") + ">";
-    }
-    return this.qname;
-  }
-  // Make U8, U16, etc => u8, u16
-  getNormalizedSignature() {
-    let qname = this.qname;
-    switch (qname) {
-      case "U8":
-      case "U16":
-      case "U32":
-      case "U64":
-      case "U128":
-      case "U256":
-      case "Vector":
-      case "Bool":
-      case "Address":
-        qname = qname.toLowerCase();
-    }
-    if (this.typeArgs.length > 0) {
-      return qname + "<" + this.typeArgs.map((t) => t.getNormalizedSignature()).join(", ") + ">";
-    }
-    return qname;
-  }
-  // Replace T0, T1 with more concrete type
-  applyTypeArgs(ctx) {
-    const replace = ctx.get(this.qname);
-    if (replace) {
-      return replace;
-    }
-    if (ctx.size === 0 || this.typeArgs.length === 0) {
-      return this;
-    }
-    const typeArgs = [];
-    for (const arg of this.typeArgs) {
-      const replace2 = ctx.get(arg.qname);
-      if (replace2) {
-        typeArgs.push(replace2);
-      } else {
-        typeArgs.push(arg.applyTypeArgs(ctx));
-      }
-    }
-    return new _TypeDescriptor(this.qname, typeArgs);
-  }
-  // all depended types including itself, not include system type
-  dependedTypes() {
-    if (this.qname.startsWith("&")) {
-      console.error("Not expected &");
-      return [];
-    }
-    if (this.isVector()) {
-      return this.typeArgs[0].dependedTypes();
-    }
-    if (BUILTIN_TYPES_SET.has(this.qname.toLowerCase())) {
-      return [];
-    }
-    switch (this.qname) {
-      case "signer":
-      case "0x1::string::String":
-        return [];
-    }
-    if (this.qname.indexOf(SPLITTER) == -1) {
-      if (this.qname.startsWith("T")) {
-        return [];
-      }
-    }
-    const types = /* @__PURE__ */ new Set();
-    for (const param of this.typeArgs) {
-      param.dependedTypes().forEach((t) => types.add(t));
-    }
-    types.add(this.qname);
-    return Array.from(types);
-  }
-  isVector() {
-    return this.qname.toLowerCase() === VECTOR_STR;
-  }
-  existAnyType() {
-    if (this.qname === "any") {
-      return true;
-    }
-    for (const param of this.typeArgs) {
-      if (param.existAnyType()) {
-        return true;
-      }
-    }
-    return false;
-  }
-  name() {
-    const parts = this.qname.split(SPLITTER);
-    return parts[parts.length - 1];
-  }
-  module() {
-    const parts = this.qname.split(SPLITTER);
-    return parts[parts.length - 2];
-  }
-};
-function parseMoveType(type) {
-  const stack = [new TypeDescriptor("")];
-  let buffer = [];
-  if (type === void 0) {
-    console.log("");
-  }
-  for (let i = 0; i < type.length; i++) {
-    const ch = type[i];
-    if (ch === " ") {
-      continue;
-    }
-    if (ch === "<") {
-      const symbol = buffer.join("");
-      buffer = [];
-      stack[stack.length - 1].qname = symbol;
-      adjustType(stack[stack.length - 1]);
-      stack.push(new TypeDescriptor(""));
-      continue;
-    }
-    if (ch === ">" || ch === ",") {
-      const typeParam = stack.pop();
-      if (!typeParam) {
-        throw Error("Unexpected stack size");
-      }
-      if (buffer.length > 0) {
-        typeParam.qname = buffer.join("");
-        buffer = [];
-      }
-      adjustType(typeParam);
-      stack[stack.length - 1].typeArgs.push(typeParam);
-      if (ch === ",") {
-        stack.push(new TypeDescriptor(""));
-      }
-      continue;
-    }
-    buffer.push(ch);
-  }
-  if (buffer.length > 0) {
-    stack[stack.length - 1].qname = buffer.join("");
-  }
-  adjustType(stack[stack.length - 1]);
-  const res = stack.pop();
-  if (!res || stack.length > 0) {
-    throw Error("Unexpected stack size");
-  }
-  return res;
-}
-__name(parseMoveType, "parseMoveType");
-function adjustType(type) {
-  if (type.qname.startsWith("&")) {
-    type.reference = true;
-    type.qname = type.qname.slice(1);
-  }
-  if (type.qname.startsWith("mut")) {
-    type.mutable = true;
-    type.qname = type.qname.slice(3);
-  }
-  const parts = type.qname.split(SPLITTER);
-  if (parts.length > 1) {
-    const [account, module, name] = parts;
-    type.qname = [accountTypeString(account), module, name].join(SPLITTER);
-  }
-}
-__name(adjustType, "adjustType");
-var ANY_TYPE = new TypeDescriptor("any");
-function vectorType(t = ANY_TYPE) {
-  return BUILTIN_TYPES.VECTOR_TYPE_ANY.apply(t);
-}
-__name(vectorType, "vectorType");
-var BUILTIN_TYPES = {
-  ADDRESS_TYPE: new TypeDescriptor("address"),
-  // export const Address = new TypeDescriptor<string>("Address")
-  VECTOR_TYPE_ANY: new TypeDescriptor("vector"),
-  VECTOR_TYPE: vectorType,
-  BOOL_TYPE: new TypeDescriptor("bool"),
-  U8_TYPE: new TypeDescriptor("u8"),
-  // export const U8 = new TypeDescriptor<number>("U8")
-  U16_TYPE: new TypeDescriptor("u16"),
-  // export const U16 = new TypeDescriptor<number>("U16")
-  U32_TYPE: new TypeDescriptor("u32"),
-  // export const U32 = new TypeDescriptor<number>("U32")
-  U64_TYPE: new TypeDescriptor("u64"),
-  // export const U64 = new TypeDescriptor<number>("U64")
-  U128_TYPE: new TypeDescriptor("u128"),
-  // export const U128 = new TypeDescriptor<number>("U128")
-  U256_TYPE: new TypeDescriptor("u256")
-  // export const U256 = new TypeDescriptor<number>("U256")
-};
-var BUILTIN_TYPES_SET = new Set(Object.values(BUILTIN_TYPES).flatMap((t) => {
-  if (typeof t === "object") {
-    return [t.qname.toLowerCase()];
-  }
-  return [];
-}));
-function matchType(matcher, type) {
-  if (matcher.qname === "any") {
-    return true;
-  }
-  if (!matcher.compareQname(type)) {
-    return false;
-  }
-  for (const [idx, matcherTarg] of matcher.typeArgs.entries()) {
-    const targ = type.typeArgs[idx];
-    if (!matchType(matcherTarg, targ)) {
-      return false;
-    }
-  }
-  return true;
-}
-__name(matchType, "matchType");
-
-// ../../node_modules/.pnpm/@typemove+move@1.9.0/node_modules/@typemove/move/dist/esm/account.js
-var AccountModulesImportInfo = class {
-  static {
-    __name(this, "AccountModulesImportInfo");
-  }
-  // account to module
-  imports;
-  account;
-  moduleName;
-  constructor(account, tsModuleName) {
-    this.account = account;
-    this.moduleName = tsModuleName;
-    this.imports = /* @__PURE__ */ new Map();
-  }
-  addImport(account, module) {
-    if (account === this.account) {
-      return;
-    }
-    let accountModules = this.imports.get(account);
-    if (!accountModules) {
-      accountModules = /* @__PURE__ */ new Set();
-      this.imports.set(account, accountModules);
-    }
-    accountModules.add(module);
-  }
-};
-var AccountRegister = class {
-  static {
-    __name(this, "AccountRegister");
-  }
-  accountImports = /* @__PURE__ */ new Map();
-  pendingAccounts = /* @__PURE__ */ new Set();
-  register(module, tsModuleName) {
-    const currentModuleFqn = moduleQname(module);
-    let accountModuleImports = this.accountImports.get(module.address);
-    if (!accountModuleImports) {
-      accountModuleImports = new AccountModulesImportInfo(module.address, tsModuleName);
-      this.accountImports.set(module.address, accountModuleImports);
-      this.pendingAccounts.delete(module.address);
-    }
-    this.registerStruct(module, accountModuleImports);
-    this.registerFunctions(module, accountModuleImports);
-    this.accountImports.set(currentModuleFqn, accountModuleImports);
-    return accountModuleImports;
-  }
-  registerFunctions(module, accountModuleImports) {
-    for (const func of module.exposedFunctions) {
-      for (const param of func.params.concat(func.return)) {
-        for (const type of param.dependedTypes()) {
-          const [account, module2] = moduleQnameForType(type);
-          accountModuleImports.addImport(account, module2);
-          if (!this.accountImports.has(account)) {
-            this.pendingAccounts.add(account);
-          }
-        }
-      }
-    }
-  }
-  registerStruct(module, accountModuleImports) {
-    for (const struct of module.structs) {
-      for (const field of struct.fields) {
-        for (const type of field.type.dependedTypes()) {
-          const [account, module2] = moduleQnameForType(type);
-          accountModuleImports.addImport(account, module2);
-          if (!this.accountImports.has(account)) {
-            this.pendingAccounts.add(account);
-          }
-        }
-      }
-    }
-  }
-};
-
-// ../../node_modules/.pnpm/@typemove+move@1.9.0/node_modules/@typemove/move/dist/esm/chain-adapter.js
-var ChainAdapter = class {
-  static {
-    __name(this, "ChainAdapter");
-  }
-};
-
-// ../../node_modules/.pnpm/@typemove+move@1.9.0/node_modules/@typemove/move/dist/esm/abstract-move-coder.js
-var AbstractMoveCoder = class {
-  static {
-    __name(this, "AbstractMoveCoder");
-  }
-  moduleMapping = /* @__PURE__ */ new Map();
-  accounts = /* @__PURE__ */ new Set();
-  typeMapping = /* @__PURE__ */ new Map();
-  enumMapping = /* @__PURE__ */ new Map();
-  funcMapping = /* @__PURE__ */ new Map();
-  // network: string
-  adapter;
-  constructor(adapter) {
-    this.adapter = adapter;
-  }
-  contains(account, name) {
-    return this.moduleMapping.has(moduleQname({ address: account, name }));
-  }
-  loadInternal(module, address) {
-    const account = accountAddressString(module.address);
-    const declareAccount = accountAddressString(address);
-    this._loadInternal(module, account);
-    if (account !== declareAccount) {
-      this._loadInternal(module, declareAccount);
-    }
-  }
-  _loadInternal(module, account) {
-    if (this.contains(account, module.name)) {
-      return;
-    }
-    this.moduleMapping.set(moduleQname({ address: account, name: module.name }), module);
-    for (const enumType of module.enums) {
-      const key = [account, module.name, enumType.name].join(SPLITTER);
-      this.enumMapping.set(key, enumType);
-    }
-    for (const struct of module.structs) {
-      const key = [account, module.name, struct.name].join(SPLITTER);
-      this.typeMapping.set(key, struct);
-    }
-    for (const func of module.exposedFunctions) {
-      const key = [account, module.name, func.name].join(SPLITTER);
-      this.funcMapping.set(key, func);
-    }
-  }
-  decodeBigInt(data) {
-    if (Array.isArray(data)) {
-      throw new Error("data is in byte array");
-    }
-    return BigInt(data);
-  }
-  requestMap = /* @__PURE__ */ new Map();
-  async getMoveStruct(type) {
-    const [account_, module, typeName] = type.split(SPLITTER);
-    const account = accountAddressString(account_);
-    type = [account, module, typeName].join(SPLITTER);
-    let struct = this.typeMapping.get(type);
-    if (struct) {
-      return struct;
-    }
-    if (this.accounts.has(account)) {
-      throw new Error("Failed to load struct " + type + " for imported account");
-    }
-    let resp = this.requestMap.get(account);
-    if (!resp) {
-      resp = this.adapter.fetchModules(account).then((modules) => {
-        for (const m of modules) {
-          this.load(m, account);
-        }
-      });
-      this.requestMap.set(account, resp);
-    }
-    await resp;
-    struct = this.typeMapping.get(type);
-    if (struct) {
-      return struct;
-    }
-    throw new Error("Failed to load function " + type + " type are not imported anywhere");
-  }
-  async maybeGetMoveEnum(type) {
-    const [account_, module, typeName] = type.split(SPLITTER);
-    const account = accountAddressString(account_);
-    type = [account, module, typeName].join(SPLITTER);
-    let enumType = this.enumMapping.get(type);
-    if (enumType) {
-      return enumType;
-    }
-    if (this.accounts.has(account)) {
-      return void 0;
-    }
-    let resp = this.requestMap.get(account);
-    if (!resp) {
-      resp = this.adapter.fetchModules(account).then((modules) => {
-        for (const m of modules) {
-          this.load(m, account);
-        }
-      });
-      this.requestMap.set(account, resp);
-    }
-    await resp;
-    enumType = this.enumMapping.get(type);
-    if (enumType) {
-      return enumType;
-    }
-    return void 0;
-  }
-  async getMoveFunction(type) {
-    const [account_, module, typeName] = type.split(SPLITTER);
-    const account = accountAddressString(account_);
-    type = [account, module, typeName].join(SPLITTER);
-    let func = this.funcMapping.get(type);
-    if (func) {
-      return func;
-    }
-    if (this.accounts.has(account)) {
-      throw new Error("Failed to load function " + type + " for imported account");
-    }
-    let resp = this.requestMap.get(account);
-    if (!resp) {
-      resp = this.adapter.fetchModules(account).then((modules) => {
-        for (const m of modules) {
-          this.load(m, account);
-        }
-      }).catch((e) => {
-        this.requestMap.delete(account);
-      });
-      this.requestMap.set(account, resp);
-    }
-    await resp;
-    func = this.funcMapping.get(type);
-    if (func) {
-      return func;
-    }
-    throw new Error("Failed to load function " + type + " type are not imported anywhere");
-  }
-  async decode(data, type) {
-    if (type.reference) {
-      return data;
-    }
-    switch (type.qname) {
-      case "signer":
-      // TODO check this, aptos only
-      case "address":
-      case "Address":
-      case "0x1::string::String":
-      case "bool":
-      case "Bool":
-      case "u8":
-      case "U8":
-      case "u16":
-      case "U16":
-      case "u32":
-      case "U32":
-        return data;
-      case "u64":
-      case "U64":
-      case "u128":
-      case "U128":
-      case "u256":
-      case "U256":
-        return this.decodeBigInt(data);
-    }
-    if (type.qname.toLowerCase() === VECTOR_STR) {
-      if (type.typeArgs[0].qname === "u8" || type.typeArgs[0].qname === "U8") {
-        return data;
-      }
-      const res = [];
-      for (const entry of data) {
-        res.push(await this.decode(entry, type.typeArgs[0]));
-      }
-      return res;
-    }
-    const enumType = await this.maybeGetMoveEnum(type.qname);
-    if (enumType) {
-      return data;
-    }
-    const struct = await this.getMoveStruct(type.qname);
-    const typeCtx = /* @__PURE__ */ new Map();
-    for (const [idx, typeArg] of type.typeArgs.entries()) {
-      typeCtx.set("T" + idx, typeArg);
-    }
-    const typedData = {};
-    for (const field of struct.fields) {
-      let filedType = field.type;
-      filedType = filedType.applyTypeArgs(typeCtx);
-      const fieldValue = this.adapter.getData(data)[field.name];
-      const value = await this.decode(fieldValue, filedType);
-      typedData[field.name] = value;
-    }
-    return typedData;
-  }
-  async decodeArray(entries, types, strict = true) {
-    const entriesDecoded = [];
-    for (const [idx, arg] of entries.entries()) {
-      const argType = types[idx];
-      try {
-        if (!strict && arg === void 0) {
-          entriesDecoded.push(arg);
-        } else {
-          entriesDecoded.push(await this.decode(arg, argType));
-        }
-      } catch (e) {
-        throw Error("Decoding error for " + JSON.stringify(arg) + "using type" + argType + e.toString());
-      }
-    }
-    return entriesDecoded;
-  }
-  encode(data) {
-    if (data === void 0 || data === null) {
-      return void 0;
-    }
-    if (typeof data === "bigint") {
-      return data.toString();
-    }
-    if (Array.isArray(data)) {
-      return this.encodeArray(data);
-    }
-    for (const [key, value] of Object.entries(data)) {
-      if (!value) {
-        continue;
-      }
-      if (typeof value === "bigint") {
-        data[key] = value.toString();
-      }
-    }
-    return data;
-  }
-  encodeArray(entriesDecoded) {
-    const entries = [];
-    for (const [idx, arg] of entriesDecoded.entries()) {
-      entries.push(this.encode(arg));
-    }
-    return entries;
-  }
-  async decodeCallResult(res, func) {
-    const f = await this.getMoveFunction(func);
-    return this.decodeArray(res, f.return);
-  }
-  async filterAndDecodeStruct(typeMatcher, structsWithTags) {
-    if (!structsWithTags) {
-      return [];
-    }
-    const results = [];
-    for (const resource of structsWithTags) {
-      const resourceType = this.adapter.getType(resource);
-      const resourceTypeDescriptor = parseMoveType(resourceType);
-      if (!matchType(typeMatcher, resourceTypeDescriptor)) {
-        continue;
-      }
-      const result = await this.decodedStruct(resource);
-      if (result) {
-        results.push(result);
-      } else {
-        console.error("decoding error");
-      }
-    }
-    return results;
-  }
-  async decodedStruct(typeStruct) {
-    const typeDescriptor = parseMoveType(this.adapter.getType(typeStruct));
-    const typeArguments = typeDescriptor.typeArgs.map((t) => t.getSignature());
-    let dataTyped = void 0;
-    try {
-      dataTyped = await this.decode(typeStruct, typeDescriptor);
-    } catch (e) {
-      throw Error("Decoding error for struct" + JSON.stringify(typeStruct) + e.toString());
-    }
-    return {
-      ...typeStruct,
-      data_decoded: dataTyped,
-      type_arguments: typeArguments
-    };
-  }
-  async decodeType(typeStruct, type) {
-    if (typeStruct === null || typeStruct == void 0) {
-      return typeStruct;
-    }
-    if (typeof typeStruct === "object") {
-      if ("type" in typeStruct) {
-        const typeInStruct = parseMoveType(typeStruct.type.toString() || "");
-        if (!matchType(type, typeInStruct)) {
-          return void 0;
-        }
-      }
-    }
-    return await this.decode(typeStruct, type);
-  }
-};
-
-// ../../node_modules/.pnpm/@typemove+move@1.9.0/node_modules/@typemove/move/dist/esm/internal-models.js
-var InternalMoveFunctionVisibility;
-(function(InternalMoveFunctionVisibility2) {
-  InternalMoveFunctionVisibility2["PRIVATE"] = "private";
-  InternalMoveFunctionVisibility2["PUBLIC"] = "public";
-  InternalMoveFunctionVisibility2["FRIEND"] = "friend";
-})(InternalMoveFunctionVisibility || (InternalMoveFunctionVisibility = {}));
-
-// src/move/index.ts
-import("node:process").then((p) => p.stdout.write(""));
-
-export {
-  SPLITTER,
-  VECTOR_STR,
-  isFrameworkAccount,
-  accountTypeString,
-  isValidMoveAddress,
-  accountAddressString,
-  normalizeToJSName,
-  moduleQnameForType,
-  moduleQname,
-  structQname,
-  upperFirst,
-  camel2 as camel,
-  TypeDescriptor,
-  parseMoveType,
-  ANY_TYPE,
-  vectorType,
-  BUILTIN_TYPES,
-  matchType,
-  AccountModulesImportInfo,
-  AccountRegister,
-  ChainAdapter,
-  AbstractMoveCoder,
-  InternalMoveFunctionVisibility,
-  EventHandler,
-  CallHandler,
-  ObjectChangeHandler,
-  ResourceChangeHandler,
-  ResourceIntervalHandler,
-  TransactionIntervalHandler,
-  MoveContext,
-  MoveAccountContext
-};
-//# sourceMappingURL=chunk-4OCWUYSJ.js.map