wowok 1.8.2 → 2.1.9

package/dist/cjs/w/query/object.js

@@ -0,0 +1,1671 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var object_exports = {};
+__export(object_exports, {
+  AllocationMode: () => AllocationMode,
+  AmountType: () => AmountType,
+  ArbStatus: () => ArbStatus,
+  DiscountType: () => DiscountType,
+  IdFrom: () => IdFrom,
+  MAX_OBJECTS_PER_QUERY: () => MAX_OBJECTS_PER_QUERY,
+  OBJECT_TYPE_DEFINITIONS: () => OBJECT_TYPE_DEFINITIONS,
+  ObjectType: () => import_common.ObjectType,
+  TreasuryOp: () => TreasuryOp,
+  WitnessSourceType: () => WitnessSourceType,
+  WitnessTargetType: () => WitnessTargetType,
+  data2object: () => data2object,
+  getMoveNameFromNumber: () => getMoveNameFromNumber,
+  getMoveNameFromObjectType: () => getMoveNameFromObjectType,
+  getNumberFromMoveName: () => getNumberFromMoveName,
+  getNumberFromObjectType: () => getNumberFromObjectType,
+  getNumbersFromObjectTypes: () => getNumbersFromObjectTypes,
+  getObjectTypeDefinition: () => getObjectTypeDefinition,
+  getObjectTypeDefinitionFromNumber: () => getObjectTypeDefinitionFromNumber,
+  getObjectTypeFromMoveName: () => getObjectTypeFromMoveName,
+  getObjectTypeFromNumber: () => getObjectTypeFromNumber,
+  getObjectTypesFromNumbers: () => getObjectTypesFromNumbers,
+  idFromToString: () => idFromToString,
+  isValidIdFromInput: () => isValidIdFromInput,
+  numberToObjectType: () => numberToObjectType,
+  objectTypeToNumber: () => objectTypeToNumber,
+  parseIdFrom: () => parseIdFrom,
+  queryTableItem_AddressMark: () => queryTableItem_AddressMark,
+  queryTableItem_DemandPresenter: () => queryTableItem_DemandPresenter,
+  queryTableItem_EntityLinker: () => queryTableItem_EntityLinker,
+  queryTableItem_EntityRegistrar: () => queryTableItem_EntityRegistrar,
+  queryTableItem_MachineNode: () => queryTableItem_MachineNode,
+  queryTableItem_PermissionPerm: () => queryTableItem_PermissionPerm,
+  queryTableItem_ProgressHistory: () => queryTableItem_ProgressHistory,
+  queryTableItem_RepositoryData: () => queryTableItem_RepositoryData,
+  queryTableItem_RewardRecord: () => queryTableItem_RewardRecord,
+  queryTableItem_TreasuryHistory: () => queryTableItem_TreasuryHistory,
+  query_objects: () => query_objects,
+  query_objects_json: () => query_objects_json,
+  query_personal: () => query_personal,
+  query_table: () => query_table,
+  query_table_json: () => query_table_json,
+  raw2type: () => raw2type
+});
+module.exports = __toCommonJS(object_exports);
+var import_network = require("../../client/network.js");
+var import_client = require("../../client/index.js");
+var import_cache = require("../local/cache.js");
+var import_config = require("../local/config.js");
+var import_local = require("../local/local.js");
+var import_exception = require("../exception.js");
+var import_lodash = __toESM(require("lodash"));
+var import_util = require("../call/util.js");
+var import_local2 = require("../local/index.js");
+var import_common = require("../common.js");
+var import_util2 = require("../util.js");
+const MAX_OBJECTS_PER_QUERY = 50;
+const WitnessSourceType = (type) => {
+  switch (type) {
+    case import_common.WitnessType.TypeArbArbitration:
+    case import_common.WitnessType.TypeArbOrder:
+    case import_common.WitnessType.TypeArbService:
+    case import_common.WitnessType.TypeArbProgress:
+    case import_common.WitnessType.TypeArbMachine:
+      return import_common.ObjectType.Arb;
+    case import_common.WitnessType.TypeOrderMachine:
+    case import_common.WitnessType.TypeOrderService:
+    case import_common.WitnessType.TypeOrderProgress:
+      return import_common.ObjectType.Order;
+    case import_common.WitnessType.TypeProgressMachine:
+      return import_common.ObjectType.Progress;
+  }
+};
+const WitnessTargetType = (type) => {
+  switch (type) {
+    case import_common.WitnessType.TypeArbArbitration:
+      return import_common.ObjectType.Arbitration;
+    case import_common.WitnessType.TypeOrderMachine:
+    case import_common.WitnessType.TypeArbMachine:
+    case import_common.WitnessType.TypeProgressMachine:
+      return import_common.ObjectType.Machine;
+    case import_common.WitnessType.TypeOrderService:
+    case import_common.WitnessType.TypeArbService:
+      return import_common.ObjectType.Service;
+    case import_common.WitnessType.TypeOrderProgress:
+    case import_common.WitnessType.TypeArbProgress:
+      return import_common.ObjectType.Progress;
+    case import_common.WitnessType.TypeArbOrder:
+      return import_common.ObjectType.Order;
+  }
+};
+const OBJECT_TYPE_DEFINITIONS = {
+  [import_common.ObjectType.Permission]: {
+    name: import_common.ObjectType.Permission,
+    moveValue: 0,
+    moveName: "Permission"
+  },
+  [import_common.ObjectType.Repository]: {
+    name: import_common.ObjectType.Repository,
+    moveValue: 1,
+    moveName: "Repository"
+  },
+  [import_common.ObjectType.Arb]: {
+    name: import_common.ObjectType.Arb,
+    moveValue: 2,
+    moveName: "Arb"
+  },
+  [import_common.ObjectType.Arbitration]: {
+    name: import_common.ObjectType.Arbitration,
+    moveValue: 3,
+    moveName: "Arbitration"
+  },
+  [import_common.ObjectType.Service]: {
+    name: import_common.ObjectType.Service,
+    moveValue: 4,
+    moveName: "Service"
+  },
+  [import_common.ObjectType.Machine]: {
+    name: import_common.ObjectType.Machine,
+    moveValue: 5,
+    moveName: "Machine"
+  },
+  [import_common.ObjectType.Order]: {
+    name: import_common.ObjectType.Order,
+    moveValue: 6,
+    moveName: "Order"
+  },
+  [import_common.ObjectType.Progress]: {
+    name: import_common.ObjectType.Progress,
+    moveValue: 7,
+    moveName: "Progress"
+  },
+  [import_common.ObjectType.Payment]: {
+    name: import_common.ObjectType.Payment,
+    moveValue: 8,
+    moveName: "Payment"
+  },
+  [import_common.ObjectType.Treasury]: {
+    name: import_common.ObjectType.Treasury,
+    moveValue: 9,
+    moveName: "Treasury"
+  },
+  [import_common.ObjectType.Guard]: {
+    name: import_common.ObjectType.Guard,
+    moveValue: 10,
+    moveName: "Guard"
+  },
+  [import_common.ObjectType.Demand]: {
+    name: import_common.ObjectType.Demand,
+    moveValue: 11,
+    moveName: "Demand"
+  },
+  [import_common.ObjectType.Passport]: {
+    name: import_common.ObjectType.Passport,
+    moveValue: 12,
+    moveName: "Passport"
+  },
+  [import_common.ObjectType.Allocation]: {
+    name: import_common.ObjectType.Allocation,
+    moveValue: 13,
+    moveName: "Allocation"
+  },
+  [import_common.ObjectType.Resource]: {
+    name: import_common.ObjectType.Resource,
+    moveValue: 14,
+    moveName: "Resource"
+  },
+  [import_common.ObjectType.Reward]: {
+    name: import_common.ObjectType.Reward,
+    moveValue: 15,
+    moveName: "Reward"
+  },
+  [import_common.ObjectType.Discount]: {
+    name: import_common.ObjectType.Discount,
+    moveValue: 16,
+    moveName: "Discount"
+  },
+  [import_common.ObjectType.EntityRegistrar]: {
+    name: import_common.ObjectType.EntityRegistrar,
+    moveValue: 17,
+    moveName: "EntityRegistrar"
+  },
+  [import_common.ObjectType.EntityLinker]: {
+    name: import_common.ObjectType.EntityLinker,
+    moveValue: 18,
+    moveName: "EntityLinker"
+  },
+  [import_common.ObjectType.Proof]: {
+    name: import_common.ObjectType.Proof,
+    moveValue: 19,
+    moveName: "Proof"
+  },
+  [import_common.ObjectType.Contact]: {
+    name: import_common.ObjectType.Contact,
+    moveValue: 20,
+    moveName: "Contact"
+  },
+  [import_common.ObjectType.WReceivedObject]: {
+    name: import_common.ObjectType.WReceivedObject,
+    moveValue: 21,
+    moveName: "WReceivedObject"
+  },
+  [import_common.ObjectType.TableItem_ProgressHistory]: {
+    name: import_common.ObjectType.TableItem_ProgressHistory,
+    moveValue: 22,
+    moveName: "TableItem_ProgressHistory"
+  },
+  [import_common.ObjectType.TableItem_PermissionPerm]: {
+    name: import_common.ObjectType.TableItem_PermissionPerm,
+    moveValue: 23,
+    moveName: "TableItem_PermissionPerm"
+  },
+  [import_common.ObjectType.TableItem_DemandPresenter]: {
+    name: import_common.ObjectType.TableItem_DemandPresenter,
+    moveValue: 24,
+    moveName: "TableItem_DemandPresenter"
+  },
+  [import_common.ObjectType.TableItem_MachineNode]: {
+    name: import_common.ObjectType.TableItem_MachineNode,
+    moveValue: 25,
+    moveName: "TableItem_MachineNode"
+  },
+  [import_common.ObjectType.TableItem_TreasuryHistory]: {
+    name: import_common.ObjectType.TableItem_TreasuryHistory,
+    moveValue: 26,
+    moveName: "TableItem_TreasuryHistory"
+  },
+  [import_common.ObjectType.TableItem_RepositoryData]: {
+    name: import_common.ObjectType.TableItem_RepositoryData,
+    moveValue: 27,
+    moveName: "TableItem_RepositoryData"
+  },
+  [import_common.ObjectType.TableItem_RewardRecord]: {
+    name: import_common.ObjectType.TableItem_RewardRecord,
+    moveValue: 28,
+    moveName: "TableItem_RewardRecord"
+  },
+  [import_common.ObjectType.TableItem_AddressMark]: {
+    name: import_common.ObjectType.TableItem_AddressMark,
+    moveValue: 29,
+    moveName: "TableItem_AddressMark"
+  },
+  [import_common.ObjectType.TableItem_EntityLinker]: {
+    name: import_common.ObjectType.TableItem_EntityLinker,
+    moveValue: 30,
+    moveName: "TableItem_EntityLinker"
+  },
+  [import_common.ObjectType.TableItem_EntityRegistrar]: {
+    name: import_common.ObjectType.TableItem_EntityRegistrar,
+    moveValue: 31,
+    moveName: "TableItem_EntityRegistrar"
+  }
+};
+const objectTypeToNumber = Object.fromEntries(
+  Object.entries(OBJECT_TYPE_DEFINITIONS).map(([objectType, def]) => [
+    objectType,
+    def.moveValue
+  ])
+);
+const numberToObjectType = Object.fromEntries(
+  Object.entries(OBJECT_TYPE_DEFINITIONS).map(([objectType, def]) => [
+    def.moveValue,
+    objectType
+  ])
+);
+function getObjectTypeFromNumber(value) {
+  return numberToObjectType[value];
+}
+function getNumberFromObjectType(objectType) {
+  return objectTypeToNumber[objectType];
+}
+function getObjectTypeDefinition(objectType) {
+  return OBJECT_TYPE_DEFINITIONS[objectType];
+}
+function getObjectTypeDefinitionFromNumber(value) {
+  const objectType = numberToObjectType[value];
+  return objectType ? OBJECT_TYPE_DEFINITIONS[objectType] : void 0;
+}
+function getObjectTypeFromMoveName(moveName) {
+  return Object.values(OBJECT_TYPE_DEFINITIONS).find(
+    (def) => def.moveName === moveName
+  )?.name;
+}
+function getMoveNameFromObjectType(objectType) {
+  return OBJECT_TYPE_DEFINITIONS[objectType]?.moveName;
+}
+function getMoveNameFromNumber(value) {
+  return getObjectTypeDefinitionFromNumber(value)?.moveName;
+}
+function getNumberFromMoveName(moveName) {
+  return Object.values(OBJECT_TYPE_DEFINITIONS).find(
+    (def) => def.moveName === moveName
+  )?.moveValue;
+}
+function getObjectTypesFromNumbers(values) {
+  return values.map(getObjectTypeFromNumber);
+}
+function getNumbersFromObjectTypes(objectTypes) {
+  return objectTypes.map(getNumberFromObjectType);
+}
+var AmountType = /* @__PURE__ */ ((AmountType2) => {
+  AmountType2[AmountType2["GuardU64Identifier"] = 0] = "GuardU64Identifier";
+  AmountType2[AmountType2["Fixed"] = 1] = "Fixed";
+  return AmountType2;
+})(AmountType || {});
+var ArbStatus = /* @__PURE__ */ ((ArbStatus2) => {
+  ArbStatus2[ArbStatus2["Principal_confirming"] = 0] = "Principal_confirming";
+  ArbStatus2[ArbStatus2["Arbitrator_confirming"] = 1] = "Arbitrator_confirming";
+  ArbStatus2[ArbStatus2["Voting"] = 2] = "Voting";
+  ArbStatus2[ArbStatus2["Arbitrated"] = 3] = "Arbitrated";
+  ArbStatus2[ArbStatus2["Objectionable"] = 4] = "Objectionable";
+  ArbStatus2[ArbStatus2["Finished"] = 5] = "Finished";
+  ArbStatus2[ArbStatus2["Withdrawn"] = 6] = "Withdrawn";
+  return ArbStatus2;
+})(ArbStatus || {});
+var DiscountType = /* @__PURE__ */ ((DiscountType2) => {
+  DiscountType2[DiscountType2["RATES"] = 0] = "RATES";
+  DiscountType2[DiscountType2["FIXED"] = 1] = "FIXED";
+  return DiscountType2;
+})(DiscountType || {});
+var TreasuryOp = /* @__PURE__ */ ((TreasuryOp2) => {
+  TreasuryOp2[TreasuryOp2["Withdraw"] = 0] = "Withdraw";
+  TreasuryOp2[TreasuryOp2["Deposit"] = 1] = "Deposit";
+  TreasuryOp2[TreasuryOp2["Receive"] = 2] = "Receive";
+  return TreasuryOp2;
+})(TreasuryOp || {});
+var IdFrom = /* @__PURE__ */ ((IdFrom2) => {
+  IdFrom2[IdFrom2["None"] = 0] = "None";
+  IdFrom2[IdFrom2["Clock"] = 1] = "Clock";
+  IdFrom2[IdFrom2["Signer"] = 2] = "Signer";
+  return IdFrom2;
+})(IdFrom || {});
+const parseIdFrom = (input) => {
+  if (typeof input === "number") {
+    if (input >= 0 && input <= 2) return input;
+    throw new Error(`Invalid IdFrom number: ${input}. Valid range: 0-2`);
+  }
+  const validNames = Object.keys(IdFrom).filter((k) => isNaN(Number(k)));
+  const lowerInput = input.toLowerCase();
+  const enumValue = validNames.find(
+    (name) => name.toLowerCase() === lowerInput
+  );
+  if (enumValue === void 0) {
+    throw new Error(
+      `Invalid IdFrom string: "${input}". Valid values: ${validNames.join(", ")}`
+    );
+  }
+  return IdFrom[enumValue];
+};
+const idFromToString = (type) => {
+  return IdFrom[type];
+};
+const isValidIdFromInput = (input) => {
+  if (typeof input === "number") {
+    return input >= 0 && input <= 2;
+  }
+  if (typeof input === "string") {
+    const upperKey = input.toUpperCase();
+    const enumValue = IdFrom[upperKey];
+    return typeof enumValue === "number";
+  }
+  return false;
+};
+var AllocationMode = /* @__PURE__ */ ((AllocationMode2) => {
+  AllocationMode2[AllocationMode2["Amount"] = 0] = "Amount";
+  AllocationMode2[AllocationMode2["Rate"] = 1] = "Rate";
+  AllocationMode2[AllocationMode2["Surplus"] = 2] = "Surplus";
+  return AllocationMode2;
+})(AllocationMode || {});
+const query_objects_json = async (json) => {
+  try {
+    const q = JSON.parse(json);
+    return JSON.stringify({ data: await query_objects(q) });
+  } catch (e) {
+    return JSON.stringify({ error: e?.toString() });
+  }
+};
+const query_table_json = async (json) => {
+  try {
+    const q = JSON.parse(json);
+    return JSON.stringify({ data: await query_table(q) });
+  } catch (e) {
+    return JSON.stringify({ error: e?.toString() });
+  }
+};
+const query_objects = async (query) => {
+  const network = await import_config.Config.Instance().network_get(query.network);
+  const originalQueryObjects = import_lodash.default.uniq(query.objects);
+  if (originalQueryObjects.length > MAX_OBJECTS_PER_QUERY) {
+    (0, import_exception.W_ERROR)(import_exception.WErrors.MaxObjectsPerQuery, `max ${MAX_OBJECTS_PER_QUERY}`);
+  }
+  const resolvedAddresses = await import_local.LocalMark.Instance().get_many_address(originalQueryObjects);
+  const addressToQueryName = /* @__PURE__ */ new Map();
+  const validObjectIds = [];
+  originalQueryObjects.forEach((original, index) => {
+    const resolved = resolvedAddresses[index];
+    if (resolved) {
+      addressToQueryName.set(resolved, original);
+      validObjectIds.push(resolved);
+    }
+  });
+  if (validObjectIds.length === 0) {
+    return { objects: [] };
+  }
+  const prefix = `${import_cache.CachePrefix.object}:${network}`;
+  const objectIds = validObjectIds;
+  const cachedResults = await import_cache.Cache.read_many(
+    prefix,
+    objectIds,
+    async (_2, pendingObjIds) => {
+      const client = new import_client.SuiClient({ url: (0, import_network.getFullnodeUrl)(network) });
+      const res = await client.multiGetObjects({
+        ids: [...pendingObjIds],
+        options: {
+          showContent: true,
+          showOwner: true,
+          showPreviousTransaction: true
+        }
+      });
+      return res.map((result) => {
+        const d = result?.data;
+        if (!d) return void 0;
+        const type_raw = d?.type ?? d?.content?.type ?? void 0;
+        const type = type_raw ? (0, import_common.object_name_from_type)(type_raw) : void 0;
+        const expire = import_cache.Cache.DefaultExpireTime(
+          type === "Guard" || type === "Payment" || type === "Passport"
+        );
+        const objectData = data2object(d);
+        return {
+          expire,
+          data: objectData
+        };
+      }).filter(
+        (data) => data !== void 0
+      );
+    },
+    query.no_cache
+  );
+  const ret = cachedResults.map((cachedData) => {
+    const d = cachedData.data;
+    d.cache_expire = cachedData.expire;
+    d.query_name = addressToQueryName.get(d.object) ?? d.object;
+    return d;
+  });
+  return { objects: ret };
+};
+const query_personal = async (query) => {
+  const account = query.account ?? "";
+  const [network, addr] = await Promise.all([
+    import_config.Config.Instance().network_get(query.network),
+    (0, import_local2.GetAccountOrMark_Address)({ name_or_address: account })
+  ]);
+  if (!addr) {
+    (0, import_exception.W_ERROR)(
+      import_exception.WErrors.InvalidParam,
+      `query_personal.account ${account} not found`
+    );
+  }
+  const [entity, registrar] = await Promise.all([
+    queryTableItem_EntityRegistrar({
+      address: { name_or_address: account },
+      no_cache: query.no_cache,
+      network
+    }).catch((error) => {
+    }),
+    queryTableItem_EntityLinker({
+      address: { name_or_address: account },
+      no_cache: query.no_cache,
+      network
+    }).catch((error) => {
+    })
+  ]);
+  if (entity) {
+    return {
+      address: addr,
+      info: entity?.records ?? [],
+      description: entity?.description ?? "",
+      referrer: entity?.referrer ?? null,
+      mark_object: entity?.mark_object ?? null,
+      details: registrar?.votes ?? [],
+      like: registrar?.votes?.filter((v) => v.like).length ?? 0,
+      dislike: registrar?.votes?.filter((v) => v.dislike).length ?? 0,
+      active_tx: entity?.previousTransaction ?? null,
+      passive_tx: registrar?.previousTransaction ?? null,
+      time: entity?.time ?? 0
+    };
+  }
+  return void 0;
+};
+const query_table = async (query) => {
+  const network = await import_config.Config.Instance().network_get(query.network);
+  const addr = await import_local.LocalMark.Instance().get_address(query.parent);
+  if (!addr) {
+    (0, import_exception.W_ERROR)(
+      import_exception.WErrors.InvalidParam,
+      `query_table.query.parent ${query.parent} not found`
+    );
+  }
+  query.parent = addr;
+  const cachedResult = await import_cache.Cache.read(
+    [
+      import_cache.CachePrefix.table,
+      query.parent,
+      query.cursor ?? "",
+      query.limit?.toString() ?? "",
+      network
+    ],
+    async () => {
+      const client = new import_client.SuiClient({ url: (0, import_network.getFullnodeUrl)(network) });
+      const res = await client.getDynamicFields({
+        parentId: query.parent,
+        cursor: query.cursor,
+        limit: query.limit
+      });
+      if (!res?.data?.length || res?.data?.length === 0) {
+        (0, import_exception.W_ERROR)(
+          import_exception.WErrors.Fail,
+          `query_table.query.parent ${query.parent} failed`
+        );
+      }
+      const r = {
+        items: res?.data?.map((v) => {
+          return {
+            object: v.objectId,
+            type: v.type,
+            version: v.version,
+            key: {
+              type: v.name.type,
+              value: v.name.value
+            }
+          };
+        }),
+        nextCursor: res.nextCursor,
+        hasNextPage: res.hasNextPage
+      };
+      return { expire: import_cache.Cache.DefaultExpireTime(), data: r };
+    },
+    query.no_cache
+  );
+  if (cachedResult) {
+    const d = cachedResult.data;
+    d.cache_expire = cachedResult.expire;
+    return d;
+  }
+  return void 0;
+};
+const query_tableItem = async (query) => {
+  const network = await import_config.Config.Instance().network_get(query.network);
+  if (query.parent !== import_common.ENTITY_REGISTRAR_ADDRESS && query.parent !== import_common.ENTITY_LINKER_ADDRESS) {
+    const addr = await import_local.LocalMark.Instance().get_address(query.parent);
+    if (!addr) {
+      (0, import_exception.W_ERROR)(
+        import_exception.WErrors.InvalidParam,
+        `query_tableItem.query.parent ${query.parent} not found`
+      );
+    }
+    query.parent = addr;
+  }
+  const cacheKey = [
+    import_cache.CachePrefix.table,
+    query.parent,
+    //JSON.stringify(query.key.type),
+    JSON.stringify(query.key.value)
+  ];
+  const cachedData = await import_cache.Cache.read(
+    cacheKey,
+    async () => {
+      const client = new import_client.SuiClient({ url: (0, import_network.getFullnodeUrl)(network) });
+      const res = await client.getDynamicFieldObject({
+        parentId: query.parent,
+        name: { type: query.key.type, value: query.key.value }
+      });
+      if (!res?.data) {
+        (0, import_exception.W_ERROR)(
+          import_exception.WErrors.Fail,
+          `query_tableItem(${query.key.value}): ${JSON.stringify(res)} `
+        );
+      }
+      const data = data2object(res?.data);
+      return {
+        expire: import_cache.Cache.DefaultExpireTime(),
+        data
+      };
+    },
+    query.no_cache
+    // Use no_cache as bForceLoad parameter
+  );
+  if (cachedData) {
+    cachedData.data.cache_expire = cachedData.expire;
+    return cachedData.data;
+  }
+  return void 0;
+};
+const tableItemQuery_byString = async (query) => {
+  const parent = typeof query.parent === "string" ? query.parent : query.parent.object;
+  return await query_tableItem({
+    parent,
+    key: { type: "0x1::string::String", value: query.key },
+    no_cache: query.no_cache,
+    network: query.network
+  });
+};
+const queryTableItem_RepositoryData = async (query) => {
+  const parent = typeof query.parent === "string" ? query.parent : query.parent?.object;
+  let entityAddress;
+  if (typeof query.entity === "bigint" || typeof query.entity === "number") {
+    entityAddress = (0, import_util2.uint2address)(query.entity);
+  } else {
+    const addr = await (0, import_local2.GetAccountOrMark_Address)(query.entity);
+    if (addr) {
+      entityAddress = addr;
+    } else {
+      (0, import_exception.W_ERROR)(import_exception.WErrors.InvalidParam, "tableItem_RepositoryData.entity");
+      return void 0;
+    }
+  }
+  const r = await query_tableItem({
+    parent,
+    key: {
+      type: `${import_common.PackageAddress}::repository::DataKey`,
+      value: { id: entityAddress, key: query.name }
+    },
+    no_cache: query.no_cache,
+    network: query.network
+  });
+  if (r?.type !== "TableItem_RepositoryData") {
+    return void 0;
+  }
+  return r;
+};
+const tableItem_byAddress = async (query) => {
+  const parent = typeof query.parent === "string" ? query.parent : query.parent?.object;
+  let addr;
+  if (typeof query.address === "string") {
+    addr = query.address;
+  } else {
+    const v = await (0, import_local2.GetAccountOrMark_Address)(query.address);
+    if (!v) {
+      (0, import_exception.W_ERROR)(
+        import_exception.WErrors.InvalidParam,
+        `queryTableItem_byAddress.address ${query.address} not found`
+      );
+      return void 0;
+    }
+    addr = v;
+  }
+  return await query_tableItem({
+    parent,
+    key: { type: "address", value: addr },
+    no_cache: query.no_cache,
+    network: query.network
+  });
+};
+const queryTableItem_PermissionPerm = async (query) => {
+  const r = await tableItem_byAddress(query);
+  if (r?.type !== "TableItem_PermissionPerm") {
+    return void 0;
+  }
+  return r;
+};
+const queryTableItem_EntityRegistrar = async (query) => {
+  const r = await tableItem_byAddress({
+    parent: import_common.ENTITY_REGISTRAR_ADDRESS,
+    address: query.address,
+    no_cache: query.no_cache,
+    network: query.network
+  });
+  if (r?.type !== "TableItem_EntityRegistrar") {
+    return void 0;
+  }
+  return r;
+};
+const queryTableItem_EntityLinker = async (query) => {
+  const r = await tableItem_byAddress({
+    parent: import_common.ENTITY_LINKER_ADDRESS,
+    address: query.address,
+    no_cache: query.no_cache,
+    network: query.network
+  });
+  if (r?.type !== "TableItem_EntityLinker") {
+    return void 0;
+  }
+  return r;
+};
+const queryTableItem_RewardRecord = async (query) => {
+  const r = await tableItem_byAddress(query);
+  if (r?.type !== "TableItem_RewardRecord") {
+    return void 0;
+  }
+  return r;
+};
+const queryTableItem_DemandPresenter = async (query) => {
+  const r = await tableItem_byAddress(query);
+  if (r?.type !== "TableItem_DemandPresenter") {
+    return void 0;
+  }
+  return r;
+};
+const queryTableItem_TreasuryHistory = async (query) => {
+  const r = await tableItem_byAddress(query);
+  if (r?.type !== "TableItem_TreasuryHistory") {
+    return void 0;
+  }
+  return r;
+};
+const queryTableItem_MachineNode = async (query) => {
+  const r = await tableItemQuery_byString(query);
+  if (r?.type !== "TableItem_MachineNode") {
+    return void 0;
+  }
+  return r;
+};
+const queryTableItem_AddressMark = async (query) => {
+  const r = await tableItem_byAddress(query);
+  if (r?.type !== "TableItem_AddressMark") {
+    return void 0;
+  }
+  return r;
+};
+const queryTableItem_ProgressHistory = async (query) => {
+  const parent = typeof query.parent === "string" ? query.parent : query.parent.object;
+  const r = await query_tableItem({
+    parent,
+    //@ use string for type "u64"
+    key: { type: "u64", value: query.u64.toString() },
+    no_cache: query.no_cache,
+    network: query.network
+  });
+  if (r?.type !== "TableItem_ProgressHistory") {
+    return void 0;
+  }
+  return r;
+};
+function raw2type(type_raw) {
+  if (!type_raw) return void 0;
+  const t = (0, import_common.object_name_from_type)(type_raw);
+  if (t === "Resource") {
+    return import_common.ObjectType.Resource;
+  } else if (t === "CoinWrapper") {
+    return import_common.ObjectType.WReceivedObject;
+  } else if (Object.values(import_common.ObjectType).includes(t)) {
+    return t;
+  }
+  const start = type_raw?.indexOf("0x2::dynamic_field::Field<");
+  if (start === 0) {
+    const end = type_raw?.substring("0x2::dynamic_field::Field<".length);
+    if (end) {
+      if (end.includes("::demand::ServiceInfo>")) {
+        return import_common.ObjectType.TableItem_DemandPresenter;
+      } else if (end.includes("::machine::NodePair>>>")) {
+        return import_common.ObjectType.TableItem_MachineNode;
+      } else if (end.includes("::progress::History>")) {
+        return import_common.ObjectType.TableItem_ProgressHistory;
+      } else if (end.includes("::reward::RecipientRecord>")) {
+        return import_common.ObjectType.TableItem_RewardRecord;
+      } else if (end.includes("::treasury::Record>")) {
+        return import_common.ObjectType.TableItem_TreasuryHistory;
+      } else if (end.includes("::registrar::Votes>")) {
+        return import_common.ObjectType.TableItem_EntityLinker;
+      } else if (end.indexOf("address") < end.indexOf(
+        "0x2::parent_linked_table::Node<address, vector<u16>>>"
+      )) {
+        return import_common.ObjectType.TableItem_PermissionPerm;
+      } else if (end.includes("::repository::DataKey")) {
+        return import_common.ObjectType.TableItem_RepositoryData;
+      } else if (end.includes("::registrar::AddressInfo>")) {
+        return import_common.ObjectType.TableItem_EntityRegistrar;
+      } else if (end.includes("::resource::AddressTag>")) {
+        return import_common.ObjectType.TableItem_AddressMark;
+      }
+    }
+  }
+  return void 0;
+}
+function data2object(data) {
+  const content = data?.content?.fields;
+  const id = data?.objectId ?? content?.id?.id ?? void 0;
+  const type_raw = data?.type ?? data?.content?.type ?? void 0;
+  const version = data?.version ?? void 0;
+  const owner = data?.owner ?? void 0;
+  const type = raw2type(type_raw);
+  switch (type) {
+    case "Permission":
+      return {
+        object: id,
+        type,
+        type_raw,
+        owner,
+        version,
+        previousTransaction: data?.previousTransaction,
+        builder: content?.owner ?? "",
+        admin: content?.admin,
+        description: content?.description ?? "",
+        entity_count: parseInt(content?.table?.fields?.size),
+        perm_remark: content?.remark?.map((item) => {
+          return {
+            index: parseInt(item?.fields?.index),
+            remark: item?.fields?.remark
+          };
+        }),
+        um: content?.um ?? null
+      };
+    case "TableItem_PermissionPerm":
+      return {
+        object: id,
+        type,
+        type_raw,
+        owner,
+        version,
+        previousTransaction: data?.previousTransaction,
+        address: content?.name,
+        perm: content?.value?.fields?.value
+      };
+    case "Guard": {
+      console.dir(content, { depth: null, colors: true });
+      const item_types = content?.validated?.map((item) => {
+        return {
+          identifier: parseInt(item?.fields?.identifier),
+          object_type: numberToObjectType[item?.fields?.object_type]
+        };
+      });
+      const tb = content?.table?.map((item) => {
+        const i = parseInt(item?.fields?.identifier);
+        const value = (0, import_util2.bcsBytesToValue)(
+          Uint8Array.from(item?.fields?.value)
+        );
+        return {
+          identifier: i,
+          b_submission: item?.fields?.b_submission,
+          value_type: item?.fields?.value[0],
+          value,
+          name: item?.fields?.name,
+          object_type: item_types.find((it) => it.identifier === i)?.object_type
+        };
+      });
+      const r = (0, import_util.restoreNodeFromOutput)(
+        Uint8Array.from(content?.input),
+        tb
+      );
+      return {
+        object: id,
+        type,
+        type_raw,
+        owner,
+        version,
+        previousTransaction: data?.previousTransaction,
+        description: content?.description ?? "",
+        table: tb,
+        input: content?.input,
+        root: r.root,
+        rep_quote: r.rep_quote,
+        relies: content?.relies,
+        relies_logic_and: content?.relies_logic_and,
+        rep: content?.rep
+      };
+    }
+    case "Passport": {
+      return {
+        object: id,
+        type,
+        type_raw,
+        owner,
+        version,
+        previousTransaction: data?.previousTransaction,
+        info: content?.guard?.map((item) => {
+          return {
+            guard: item.fields.guard,
+            result: item.fields.result,
+            impack: item.fields.impack,
+            // Does the result of this guard participate in the formation of the result of the passport?
+            relies: item.fields.relies,
+            relies_logic_and: item.fields.relies_logic_and,
+            submission: item.fields.submission.map((sub) => {
+              return {
+                identifier: sub.fields.identifier,
+                value_type: sub.fields.value[0],
+                value: (0, import_util2.bcsBytesToValue)(
+                  Uint8Array.from(sub.fields.value)
+                )
+              };
+            })
+          };
+        }),
+        result: content?.result,
+        tx_hash: content?.tx_hash,
+        impack_guard: content?.impack,
+        time: content?.time,
+        signer: content?.signer,
+        has_verified: content?.has_verified
+      };
+    }
+    case "Allocation": {
+      return {
+        object: id,
+        type,
+        type_raw,
+        owner,
+        version,
+        previousTransaction: data?.previousTransaction,
+        description: content?.allocators?.fields?.description ?? "",
+        threshold: content?.allocators?.fields?.threshold,
+        balance: content?.balance,
+        payment_info: content?.payment_info?.fields,
+        payment: content?.payment ?? [],
+        allocators: content?.allocators?.fields?.allocators?.map(
+          (item) => {
+            return {
+              guard: item.fields.guard,
+              fix: item.fields.fix,
+              max: item.fields.max ?? void 0,
+              sharing: item.fields.sharing.map((sh) => {
+                let who;
+                const whoData = sh.fields.who;
+                if (!whoData || !whoData.variant) {
+                  (0, import_exception.W_ERROR)(
+                    import_exception.WErrors.ParseObjectContentFailed,
+                    `Invalid who data: ${JSON.stringify(whoData)}`
+                  );
+                }
+                if (whoData.variant === "GuardIdentifier" && whoData.fields) {
+                  who = {
+                    GuardIdentifier: Number(
+                      whoData.fields.pos0
+                    )
+                  };
+                } else if (whoData.variant === "Entity" && whoData.fields) {
+                  who = {
+                    Entity: {
+                      name_or_address: whoData.fields.pos0
+                    }
+                  };
+                } else if (whoData.variant === "Signer") {
+                  who = {
+                    Signer: null
+                  };
+                } else {
+                  (0, import_exception.W_ERROR)(
+                    import_exception.WErrors.ParseObjectContentFailed,
+                    `Invalid who variant: ${whoData.variant}`
+                  );
+                }
+                return {
+                  who,
+                  sharing: sh.fields.sharing,
+                  mode: sh.fields.mode
+                };
+              })
+            };
+          }
+        )
+      };
+    }
+    case "Payment": {
+      return {
+        object: id,
+        type,
+        type_raw,
+        owner,
+        version,
+        previousTransaction: data?.previousTransaction,
+        amount: content?.amount,
+        time: content?.time,
+        from_object: content?.from_object,
+        signer: content?.signer,
+        info: content?.info?.fields,
+        record: content?.record?.map((item) => {
+          return {
+            recipient: item.fields.recipient,
+            amount: item.fields.amount
+          };
+        })
+      };
+    }
+    case "Contact": {
+      console.dir(content, { depth: null, colors: true });
+      return {
+        object: id,
+        type,
+        type_raw,
+        owner,
+        version,
+        previousTransaction: data?.previousTransaction,
+        description: content?.description,
+        ims: content?.ims.map((item) => {
+          return {
+            description: item.fields.description,
+            at: item.fields.at,
+            join_time: item.fields.join_time,
+            status: item.fields.status
+          };
+        }),
+        location: content?.location,
+        permission: content?.permission
+      };
+    }
+    case "Repository": {
+      console.dir(content, { depth: null, colors: true });
+      return {
+        object: id,
+        type,
+        type_raw,
+        owner,
+        version,
+        previousTransaction: data?.previousTransaction,
+        description: content?.description,
+        policies: content?.policies.map((item) => {
+          return {
+            description: item.fields.description,
+            id_from: item.fields.id_from,
+            name: item.fields.name,
+            quote_guard: item.fields.quote_guard,
+            value_type: item.fields.value_type,
+            write_guard: item.fields.write_guard
+          };
+        }),
+        rewards: content?.rewards,
+        um: content?.um ?? null,
+        permission: content?.permission
+      };
+    }
+    case "Demand": {
+      console.dir(content, { depth: null, colors: true });
+      return {
+        object: id,
+        type,
+        type_raw,
+        owner,
+        version,
+        previousTransaction: data?.previousTransaction,
+        description: content?.description,
+        location: content?.location,
+        rewards: content?.rewards,
+        guards: content?.guards.map((item) => {
+          return {
+            guard: item.fields.guard,
+            service_identifier: item.fields.service_identifier
+          };
+        }),
+        presenters_count: content?.presenters?.fields?.size,
+        um: content?.um ?? null,
+        permission: content?.permission
+      };
+    }
+    case "Machine": {
+      return {
+        object: id,
+        type,
+        type_raw,
+        owner,
+        version,
+        previousTransaction: data?.previousTransaction,
+        description: content?.description,
+        node_count: content?.nodes?.fields?.size,
+        consensus_repositories: content?.consensus_repositories,
+        bPaused: content?.bPaused,
+        bPublished: content?.bPublished,
+        um: content?.um ?? null,
+        permission: content?.permission
+      };
+    }
+    case "Order": {
+      console.dir(content, { depth: null, colors: true });
+      return {
+        object: id,
+        type,
+        type_raw,
+        owner,
+        version,
+        previousTransaction: data?.previousTransaction,
+        items: content?.items.map((item) => {
+          return {
+            name: item.fields.item,
+            price: item.fields.price,
+            quantity: item.fields.quantity,
+            wip_hash: item.fields.wip_hash
+          };
+        }),
+        discount: content?.discount,
+        progress: content?.progress,
+        machine: content?.machine,
+        amount: content?.amount,
+        builder: content?.owner,
+        service: content?.service,
+        dispute: content?.dispute,
+        agent: content?.agent,
+        allocation: content?.allocation,
+        claimed_by: content?.claimed_by,
+        required_info: content?.required_info,
+        time: content?.time
+      };
+    }
+    case "Progress": {
+      console.dir(content, { depth: null, colors: true });
+      return {
+        object: id,
+        type,
+        type_raw,
+        owner,
+        version,
+        previousTransaction: data?.previousTransaction,
+        machine: content?.machine,
+        context_repositories: content?.context_repositories,
+        current: content?.current,
+        task: content?.task,
+        namedOperator: content?.namedOperator.map((item) => {
+          return {
+            name: item.fields.name,
+            operators: item.fields.operators
+          };
+        }),
+        session: content?.session.map((item) => {
+          return {
+            next_node: item.fields.next_node,
+            forwards: item.fields.forwards.map((forward) => {
+              return {
+                forward: forward.fields.forward,
+                who: forward.fields.who,
+                retained_submission: forward.fields.retained_submission.map(
+                  (submission) => {
+                    return {
+                      identifier: submission.fields.identifier,
+                      value_type: submission.fields.value_type,
+                      value: (0, import_util2.bcsBytesToValue)(
+                        Uint8Array.from(
+                          submission.fields.value
+                        )
+                      )
+                    };
+                  }
+                ),
+                msg: forward.fields.msg,
+                accomplished: forward.fields.accomplished,
+                time: forward.fields.time
+              };
+            }),
+            weights: item.fields.weights,
+            threshold: item.fields.threshold
+          };
+        }),
+        history_count: content?.history?.fields?.contents?.fields?.size
+      };
+    }
+    case "Reward": {
+      console.dir(content, { depth: null, colors: true });
+      return {
+        object: id,
+        type,
+        type_raw,
+        owner,
+        version,
+        previousTransaction: data?.previousTransaction,
+        description: content?.description,
+        guards: content?.guards.map((guard) => {
+          const amount_type = guard.fields.amount.variant === "Fixed" ? 1 /* Fixed */ : 0 /* GuardU64Identifier */;
+          const recipient = (0, import_util2.parseRecipient)(
+            guard.fields.recipient
+          );
+          return {
+            guard: guard.fields.guard,
+            expiration_time: guard.fields.expiration_time,
+            amount: {
+              type: amount_type,
+              value: guard.fields.amount.fields?.pos0
+            },
+            recipient
+          };
+        }),
+        balance: content?.balance,
+        guard_not_added_expiration_time: content?.guard_not_added_expiration_time,
+        record_count: content?.record?.fields?.size,
+        um: content?.um ?? null,
+        permission: content?.permission
+      };
+    }
+    case "Service": {
+      console.dir(content, { depth: null, colors: true });
+      return {
+        object: id,
+        type,
+        type_raw,
+        owner,
+        version,
+        previousTransaction: data?.previousTransaction,
+        description: content?.description,
+        location: content?.location,
+        sales: content?.sales?.map((sale) => {
+          return {
+            name: sale.fields.name,
+            stock: sale.fields.stock,
+            suspension: sale.fields.suspension,
+            price: sale.fields.price,
+            wip: sale.fields.wip,
+            wip_hash: sale.fields.wip_hash
+          };
+        }),
+        repositories: content?.repositories,
+        buy_guard: content?.buy_guard,
+        machine: content?.machine,
+        bPublished: content?.bPublished,
+        bPaused: content?.bPaused,
+        customer_required: content?.customer_required,
+        arbitrations: content?.arbitrations,
+        compensation_fund: content?.compensation_fund,
+        paused_time: content?.paused_time,
+        compensation_lock_duration: content?.compensation_lock_duration,
+        order_allocators: {
+          description: content?.order_allocators?.fields?.description,
+          threshold: content?.order_allocators?.fields?.threshold,
+          allocators: content?.order_allocators?.fields?.allocators.map(
+            (allocator) => {
+              return {
+                guard: allocator.fields.guard,
+                sharing: allocator.fields.sharing.map(
+                  (sharing) => {
+                    const who = (0, import_util2.parseRecipient)(
+                      sharing.fields.who
+                    );
+                    return {
+                      who,
+                      sharing: sharing.fields.sharing,
+                      mode: sharing.fields.mode
+                    };
+                  }
+                ),
+                fix: allocator.fields.fix,
+                max: allocator.fields.max
+              };
+            }
+          )
+        },
+        rewards: content?.rewards,
+        um: content?.um ?? null,
+        permission: content?.permission
+      };
+    }
+    case "Discount": {
+      console.dir(content, { depth: null, colors: true });
+      return {
+        object: id,
+        type,
+        type_raw,
+        owner,
+        version,
+        previousTransaction: data?.previousTransaction,
+        name: content?.name,
+        discount_type: content?.discount_type,
+        benchmark: content?.benchmark,
+        off: content?.off,
+        time_start: content?.time_start,
+        time_end: content?.time_end,
+        service: content?.service,
+        transferable: content?.transferable
+      };
+    }
+    case "Arb": {
+      console.dir(content, { depth: null, colors: true });
+      return {
+        object: id,
+        type,
+        type_raw,
+        owner,
+        version,
+        previousTransaction: data?.previousTransaction,
+        description: content?.description,
+        order: content?.order,
+        arbitration: content?.arbitration,
+        voted: content?.voted?.map((voted) => {
+          return {
+            voter: voted.fields.voter,
+            agrees: voted.fields.agrees,
+            weight: voted.fields.weight,
+            time: voted.fields.time
+          };
+        }),
+        proposition: content?.proposition?.map((proposition) => {
+          return {
+            name: proposition.fields.name,
+            votes: proposition.fields.votes
+          };
+        }),
+        fee: content?.fee,
+        feedback: content?.feedback,
+        indemnity: content?.indemnity ? {
+          amount: content?.indemnity?.fields?.amount,
+          time: content?.indemnity?.fields?.time
+        } : null,
+        voting_deadline: content?.voting_deadline,
+        objection: content?.objection,
+        status: content?.status,
+        compensation_time: content?.compensation_time,
+        time: content?.time
+      };
+    }
+    case "Arbitration": {
+      console.dir(content, { depth: null, colors: true });
+      return {
+        object: id,
+        type,
+        type_raw,
+        owner,
+        version,
+        previousTransaction: data?.previousTransaction,
+        description: content?.description,
+        location: content?.location,
+        fee: content?.fee,
+        bPaused: content?.bPaused,
+        balance: content?.balance,
+        usage_guard: content?.usage_guard,
+        um: content?.um ?? null,
+        permission: content?.permission,
+        voting_guard: content?.voting_guard.map((guard) => {
+          let vote_weight;
+          if (guard.fields.vote_weight.variant === "GuardIdentifier") {
+            vote_weight = {
+              GuardIdentifier: guard.fields.vote_weight.fields?.pos0
+            };
+          } else if (guard.fields.vote_weight.variant === "FixedValue") {
+            vote_weight = {
+              FixedValue: guard.fields.vote_weight.fields?.pos0
+            };
+          } else {
+            (0, import_exception.W_ERROR)(
+              import_exception.WErrors.InvalidParam,
+              `vote_weight${guard.fields.vote_weight.variant} invalid`
+            );
+          }
+          return {
+            guard: guard.fields.guard,
+            vote_weight
+          };
+        })
+      };
+    }
+    case "Proof": {
+      return {
+        object: id,
+        type,
+        type_raw,
+        owner,
+        version,
+        previousTransaction: data?.previousTransaction,
+        description: content?.description,
+        proof: content?.proof,
+        server_pubkey: content?.server_pubkey,
+        server_signature: content?.server_signature,
+        proof_type: content?.proof_type,
+        item_count: content?.item_count ?? null,
+        about_address: content?.about_address ?? null,
+        signer: content?.signer,
+        time: content?.time
+      };
+    }
+    case "Treasury": {
+      console.dir(content, { depth: null, colors: true });
+      return {
+        object: id,
+        type,
+        type_raw,
+        owner,
+        version,
+        previousTransaction: data?.previousTransaction,
+        description: content?.description,
+        balance: content?.balance,
+        history_count: parseInt(content?.history?.fields?.size),
+        external_deposit_guard: content?.external_deposit_guard.map(
+          (guard) => ({
+            guard: guard.fields.guard,
+            identifier: guard.fields.identifier ?? null
+          })
+        ),
+        external_withdraw_guard: content?.external_withdraw_guard.map(
+          (guard) => ({
+            guard: guard.fields.guard,
+            identifier: guard.fields.identifier
+          })
+        ),
+        inflow: content?.inflow,
+        outflow: content?.outflow,
+        um: content?.um ?? null,
+        permission: content?.permission
+      };
+    }
+    case "TableItem_DemandPresenter": {
+      console.dir(content, { depth: null, colors: true });
+      return {
+        object: id,
+        type,
+        type_raw,
+        owner,
+        version,
+        previousTransaction: data?.previousTransaction,
+        address: content?.name,
+        recommend: content?.value?.fields?.recommend,
+        service: content?.value?.fields?.service,
+        update_time: content?.value?.fields?.update_time,
+        acceptance_score: content?.value?.fields?.acceptance_score,
+        feedback: content?.value?.fields?.feedback,
+        feedback_time: content?.value?.fields?.feedback_time
+      };
+    }
+    case "TableItem_MachineNode": {
+      console.dir(JSON.stringify(content.value.fields.value), {
+        depth: null,
+        colors: true
+      });
+      return {
+        object: id,
+        type,
+        type_raw,
+        owner,
+        version,
+        previousTransaction: data?.previousTransaction,
+        name: content?.name,
+        value: content?.value?.fields?.value?.map((item) => {
+          return {
+            prev_node: item.fields.prev_node,
+            threshold: item.fields.threshold,
+            forwards: item.fields.forwards.map((forward) => {
+              return {
+                name: forward.fields.name,
+                weight: forward.fields.weight,
+                namedOperator: forward.fields?.namedOperator,
+                permissionIndex: forward.fields?.permissionIndex,
+                guard: forward.fields?.guard ? {
+                  guard: forward.fields.guard.fields?.guard,
+                  retained_submission: forward.fields.guard.fields?.retained_submission
+                } : void 0
+              };
+            })
+          };
+        })
+      };
+    }
+    case "TableItem_ProgressHistory": {
+      console.dir(content, { depth: null, colors: true });
+      return {
+        object: id,
+        type,
+        type_raw,
+        owner,
+        version,
+        previousTransaction: data?.previousTransaction,
+        index: content?.name,
+        node: content?.value?.fields?.node,
+        next_node: content?.value?.fields?.next_node,
+        session: content?.value?.fields?.session.map((session) => {
+          return {
+            next_node: session.fields.next_node,
+            weights: session.fields.weights,
+            threshold: session.fields.threshold,
+            forwards: session.fields.forwards?.map(
+              (holder) => {
+                return {
+                  forward: holder.fields.forward,
+                  who: holder.fields.who,
+                  msg: holder.fields.msg,
+                  accomplished: holder.fields.accomplished,
+                  time: holder.fields.time,
+                  retained_submission: holder.fields.retained_submission?.map(
+                    (submission) => {
+                      return {
+                        identifier: submission.fields.identifier,
+                        value_type: submission.fields.value_type[0],
+                        value: (0, import_util2.bcsBytesToValue)(
+                          Uint8Array.from(
+                            submission.fields.value
+                          )
+                        )
+                      };
+                    }
+                  )
+                };
+              }
+            )
+          };
+        }),
+        time: content?.value?.time
+      };
+    }
+    case "TableItem_TreasuryHistory": {
+      console.dir(content, { depth: null, colors: true });
+      return {
+        object: id,
+        type,
+        type_raw,
+        owner,
+        version,
+        previousTransaction: data?.previousTransaction,
+        payment: content?.name,
+        op: content?.value?.fields?.op,
+        signer: content?.value?.fields?.signer,
+        external_guard: content?.value?.fields?.external_guard,
+        amount: content?.value?.fields?.amount,
+        time: content?.value?.fields?.time
+      };
+    }
+    case "TableItem_EntityLinker": {
+      console.dir(content, { depth: null, colors: true });
+      return {
+        object: id,
+        type,
+        type_raw,
+        owner,
+        version,
+        previousTransaction: data?.previousTransaction,
+        address: content?.name,
+        pos: content?.value?.fields?.pos,
+        count: content?.value?.fields?.count,
+        votes: content?.value?.fields?.votes?.map((vote) => {
+          return {
+            who: vote.fields.who,
+            info: vote.fields.info,
+            like: (vote.fields.info & 2) !== 0,
+            dislike: (vote.fields.info & 4) !== 0,
+            affiliation: (vote.fields.info & 8) !== 0,
+            time: vote.fields.time
+          };
+        })
+      };
+    }
+    case "TableItem_EntityRegistrar": {
+      console.dir(content, { depth: null, colors: true });
+      return {
+        object: id,
+        type,
+        type_raw,
+        owner,
+        version,
+        previousTransaction: data?.previousTransaction,
+        address: content?.name,
+        description: content?.value?.fields?.description,
+        time: content?.value?.fields?.time,
+        referrer: content?.referrer,
+        mark_object: content?.value?.fields?.resource,
+        records: content?.value?.fields?.records?.map((record) => {
+          return {
+            name: record.fields.name,
+            typed_value: record.fields.typed_value,
+            value: (0, import_util2.bcsBytesToValue)(
+              Uint8Array.from(record.fields.typed_value)
+            )
+          };
+        })
+      };
+    }
+    case "Resource": {
+      return {
+        object: id,
+        type,
+        type_raw,
+        owner,
+        version,
+        previousTransaction: data?.previousTransaction,
+        entity_count: parseInt(content?.table?.fields?.size)
+      };
+    }
+    case "TableItem_AddressMark": {
+      console.dir(content, { depth: null, colors: true });
+      return {
+        object: id,
+        type,
+        type_raw,
+        owner,
+        version,
+        previousTransaction: data?.previousTransaction,
+        entity: content?.name,
+        name: content?.value?.fields?.name,
+        tags: content?.value?.fields?.tags
+      };
+    }
+    case "TableItem_RepositoryData": {
+      console.dir(content, { depth: null, colors: true });
+      return {
+        object: id,
+        type,
+        type_raw,
+        owner,
+        version,
+        previousTransaction: data?.previousTransaction,
+        entity: content?.name?.fields?.id,
+        name: content?.name?.fields?.key,
+        value: content?.value,
+        data: {
+          value_type: content?.value[0],
+          value: (0, import_util2.bcsBytesToValue)(Uint8Array.from(content.value))
+        }
+      };
+    }
+    case "TableItem_RewardRecord": {
+      console.dir(content, { depth: null, colors: true });
+      return {
+        object: id,
+        type,
+        type_raw,
+        owner,
+        version,
+        previousTransaction: data?.previousTransaction,
+        recipient: content?.name,
+        guard: content?.value?.fields?.guard,
+        total: content?.value?.fields?.total,
+        record: content?.value?.fields?.amount.map((record) => {
+          return {
+            amount: record.fields.amount,
+            time: record.fields.time
+          };
+        })
+      };
+    }
+    case "EntityRegistrar": {
+      console.dir(content, { depth: null, colors: true });
+      return {
+        object: id,
+        type,
+        type_raw,
+        owner,
+        version,
+        previousTransaction: data?.previousTransaction,
+        entity_count: parseInt(content?.table?.fields?.size)
+      };
+    }
+    case "EntityLinker": {
+      console.dir(content, { depth: null, colors: true });
+      return {
+        object: id,
+        type,
+        type_raw,
+        owner,
+        version,
+        previousTransaction: data?.previousTransaction,
+        entity_count: parseInt(content?.table?.fields?.size)
+      };
+    }
+  }
+  return {
+    object: id,
+    type: void 0,
+    type_raw,
+    owner,
+    version
+  };
+}