@net-protocol/storage 0.1.8 → 0.1.10

package/dist/react.js

@@ -0,0 +1,1380 @@
+'use strict';
+
+var wagmi = require('wagmi');
+var react = require('react');
+var core = require('@net-protocol/core');
+var viem = require('viem');
+var pako = require('pako');
+var actions = require('viem/actions');
+var useAsyncEffect = require('use-async-effect');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var pako__default = /*#__PURE__*/_interopDefault(pako);
+var useAsyncEffect__default = /*#__PURE__*/_interopDefault(useAsyncEffect);
+
+// src/hooks/useStorage.ts
+
+// src/abis/storage.json
+var storage_default = [
+  {
+    type: "function",
+    name: "bulkGet",
+    inputs: [
+      {
+        name: "params",
+        type: "tuple[]",
+        internalType: "struct Storage.BulkGetParams[]",
+        components: [
+          { name: "key", type: "bytes32", internalType: "bytes32" },
+          { name: "operator", type: "address", internalType: "address" }
+        ]
+      }
+    ],
+    outputs: [
+      {
+        name: "results",
+        type: "tuple[]",
+        internalType: "struct Storage.BulkGetResult[]",
+        components: [
+          { name: "text", type: "string", internalType: "string" },
+          { name: "value", type: "bytes", internalType: "bytes" }
+        ]
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "bulkGetTotalWrites",
+    inputs: [
+      {
+        name: "params",
+        type: "tuple[]",
+        internalType: "struct Storage.BulkGetParams[]",
+        components: [
+          { name: "key", type: "bytes32", internalType: "bytes32" },
+          { name: "operator", type: "address", internalType: "address" }
+        ]
+      }
+    ],
+    outputs: [
+      { name: "results", type: "uint256[]", internalType: "uint256[]" }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "bulkGetValueAtIndex",
+    inputs: [
+      {
+        name: "params",
+        type: "tuple[]",
+        internalType: "struct Storage.BulkGetValueAtIndexParams[]",
+        components: [
+          { name: "key", type: "bytes32", internalType: "bytes32" },
+          {
+            name: "operator",
+            type: "address",
+            internalType: "address"
+          },
+          { name: "idx", type: "uint256", internalType: "uint256" }
+        ]
+      }
+    ],
+    outputs: [
+      {
+        name: "results",
+        type: "tuple[]",
+        internalType: "struct Storage.BulkGetResult[]",
+        components: [
+          { name: "text", type: "string", internalType: "string" },
+          { name: "value", type: "bytes", internalType: "bytes" }
+        ]
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "bulkPut",
+    inputs: [
+      {
+        name: "params",
+        type: "tuple[]",
+        internalType: "struct Storage.BulkPutParams[]",
+        components: [
+          { name: "key", type: "bytes32", internalType: "bytes32" },
+          { name: "text", type: "string", internalType: "string" },
+          { name: "value", type: "bytes", internalType: "bytes" }
+        ]
+      }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "get",
+    inputs: [
+      { name: "key", type: "bytes32", internalType: "bytes32" },
+      { name: "operator", type: "address", internalType: "address" }
+    ],
+    outputs: [
+      { name: "", type: "string", internalType: "string" },
+      { name: "", type: "bytes", internalType: "bytes" }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "getTotalWrites",
+    inputs: [
+      { name: "key", type: "bytes32", internalType: "bytes32" },
+      { name: "operator", type: "address", internalType: "address" }
+    ],
+    outputs: [{ name: "", type: "uint256", internalType: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "getValueAtIndex",
+    inputs: [
+      { name: "key", type: "bytes32", internalType: "bytes32" },
+      { name: "operator", type: "address", internalType: "address" },
+      { name: "idx", type: "uint256", internalType: "uint256" }
+    ],
+    outputs: [
+      { name: "", type: "string", internalType: "string" },
+      { name: "", type: "bytes", internalType: "bytes" }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "put",
+    inputs: [
+      { name: "key", type: "bytes32", internalType: "bytes32" },
+      { name: "text", type: "string", internalType: "string" },
+      { name: "value", type: "bytes", internalType: "bytes" }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "event",
+    name: "Stored",
+    inputs: [
+      {
+        name: "key",
+        type: "bytes32",
+        indexed: true,
+        internalType: "bytes32"
+      },
+      {
+        name: "operator",
+        type: "address",
+        indexed: true,
+        internalType: "address"
+      }
+    ],
+    anonymous: false
+  }
+];
+
+// src/abis/chunked-storage.json
+var chunked_storage_default = [
+  {
+    type: "function",
+    name: "get",
+    inputs: [
+      { name: "key", type: "bytes32", internalType: "bytes32" },
+      { name: "operator", type: "address", internalType: "address" }
+    ],
+    outputs: [
+      { name: "", type: "string", internalType: "string" },
+      { name: "", type: "bytes", internalType: "bytes" }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "getChunk",
+    inputs: [
+      { name: "key", type: "bytes32", internalType: "bytes32" },
+      { name: "operator", type: "address", internalType: "address" },
+      { name: "chunkIndex", type: "uint8", internalType: "uint8" }
+    ],
+    outputs: [
+      { name: "chunkData", type: "bytes", internalType: "bytes" }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "getChunks",
+    inputs: [
+      { name: "key", type: "bytes32", internalType: "bytes32" },
+      { name: "operator", type: "address", internalType: "address" },
+      { name: "startIndex", type: "uint8", internalType: "uint8" },
+      { name: "endIndex", type: "uint8", internalType: "uint8" }
+    ],
+    outputs: [
+      { name: "chunks", type: "bytes[]", internalType: "bytes[]" }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "getMetadata",
+    inputs: [
+      { name: "key", type: "bytes32", internalType: "bytes32" },
+      { name: "operator", type: "address", internalType: "address" }
+    ],
+    outputs: [
+      { name: "chunkCount", type: "uint8", internalType: "uint8" },
+      { name: "originalText", type: "string", internalType: "string" }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "put",
+    inputs: [
+      { name: "key", type: "bytes32", internalType: "bytes32" },
+      { name: "text", type: "string", internalType: "string" },
+      { name: "chunks", type: "bytes[]", internalType: "bytes[]" }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "event",
+    name: "ChunkedStoragePut",
+    inputs: [
+      {
+        name: "originalKey",
+        type: "bytes32",
+        indexed: true,
+        internalType: "bytes32"
+      },
+      {
+        name: "sender",
+        type: "address",
+        indexed: true,
+        internalType: "address"
+      },
+      {
+        name: "hashedKey",
+        type: "bytes32",
+        indexed: false,
+        internalType: "bytes32"
+      }
+    ],
+    anonymous: false
+  },
+  { type: "error", name: "DataTooLarge", inputs: [] }
+];
+
+// src/abis/chunked-storage-reader.json
+var chunked_storage_reader_default = [
+  {
+    type: "function",
+    name: "get",
+    inputs: [
+      { name: "key", type: "bytes32", internalType: "bytes32" },
+      { name: "operator", type: "address", internalType: "address" }
+    ],
+    outputs: [
+      { name: "", type: "string", internalType: "string" },
+      { name: "", type: "bytes", internalType: "bytes" }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "getChunk",
+    inputs: [
+      { name: "key", type: "bytes32", internalType: "bytes32" },
+      { name: "operator", type: "address", internalType: "address" },
+      { name: "chunkIndex", type: "uint8", internalType: "uint8" }
+    ],
+    outputs: [
+      { name: "chunkData", type: "bytes", internalType: "bytes" }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "getChunkAtIndex",
+    inputs: [
+      { name: "key", type: "bytes32", internalType: "bytes32" },
+      { name: "operator", type: "address", internalType: "address" },
+      { name: "chunkIndex", type: "uint8", internalType: "uint8" },
+      { name: "idx", type: "uint256", internalType: "uint256" }
+    ],
+    outputs: [
+      { name: "chunkData", type: "bytes", internalType: "bytes" }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "getChunks",
+    inputs: [
+      { name: "key", type: "bytes32", internalType: "bytes32" },
+      { name: "operator", type: "address", internalType: "address" },
+      { name: "startIndex", type: "uint8", internalType: "uint8" },
+      { name: "endIndex", type: "uint8", internalType: "uint8" }
+    ],
+    outputs: [
+      { name: "chunks", type: "bytes[]", internalType: "bytes[]" }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "getChunksAtIndex",
+    inputs: [
+      { name: "key", type: "bytes32", internalType: "bytes32" },
+      { name: "operator", type: "address", internalType: "address" },
+      { name: "startIndex", type: "uint8", internalType: "uint8" },
+      { name: "endIndex", type: "uint8", internalType: "uint8" },
+      { name: "idx", type: "uint256", internalType: "uint256" }
+    ],
+    outputs: [
+      { name: "chunks", type: "bytes[]", internalType: "bytes[]" }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "getMetadata",
+    inputs: [
+      { name: "key", type: "bytes32", internalType: "bytes32" },
+      { name: "operator", type: "address", internalType: "address" }
+    ],
+    outputs: [
+      { name: "chunkCount", type: "uint8", internalType: "uint8" },
+      { name: "originalText", type: "string", internalType: "string" }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "getMetadataAtIndex",
+    inputs: [
+      { name: "key", type: "bytes32", internalType: "bytes32" },
+      { name: "operator", type: "address", internalType: "address" },
+      { name: "idx", type: "uint256", internalType: "uint256" }
+    ],
+    outputs: [
+      { name: "chunkCount", type: "uint8", internalType: "uint8" },
+      { name: "originalText", type: "string", internalType: "string" }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "getTotalWrites",
+    inputs: [
+      { name: "key", type: "bytes32", internalType: "bytes32" },
+      { name: "operator", type: "address", internalType: "address" }
+    ],
+    outputs: [{ name: "", type: "uint256", internalType: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "getValueAtIndex",
+    inputs: [
+      { name: "key", type: "bytes32", internalType: "bytes32" },
+      { name: "operator", type: "address", internalType: "address" },
+      { name: "idx", type: "uint256", internalType: "uint256" }
+    ],
+    outputs: [
+      { name: "", type: "string", internalType: "string" },
+      { name: "", type: "bytes", internalType: "bytes" }
+    ],
+    stateMutability: "view"
+  }
+];
+
+// src/abis/storage-router.json
+var storage_router_default = [
+  {
+    type: "function",
+    name: "get",
+    inputs: [
+      { name: "key", type: "bytes32", internalType: "bytes32" },
+      { name: "operator", type: "address", internalType: "address" }
+    ],
+    outputs: [
+      { name: "isChunkedStorage", type: "bool", internalType: "bool" },
+      { name: "text", type: "string", internalType: "string" },
+      { name: "data", type: "bytes", internalType: "bytes" }
+    ],
+    stateMutability: "view"
+  },
+  { type: "error", name: "StoredDataNotFound", inputs: [] }
+];
+
+// src/abis/safe-storage-reader.json
+var safe_storage_reader_default = [
+  {
+    type: "function",
+    name: "bulkGet",
+    inputs: [
+      {
+        name: "params",
+        type: "tuple[]",
+        internalType: "struct IStorage.BulkGetParams[]",
+        components: [
+          {
+            name: "key",
+            type: "bytes32",
+            internalType: "bytes32"
+          },
+          {
+            name: "operator",
+            type: "address",
+            internalType: "address"
+          }
+        ]
+      }
+    ],
+    outputs: [
+      {
+        name: "results",
+        type: "tuple[]",
+        internalType: "struct IStorage.BulkGetResult[]",
+        components: [
+          {
+            name: "text",
+            type: "string",
+            internalType: "string"
+          },
+          {
+            name: "value",
+            type: "bytes",
+            internalType: "bytes"
+          }
+        ]
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "bulkGetValueAtIndex",
+    inputs: [
+      {
+        name: "params",
+        type: "tuple[]",
+        internalType: "struct IStorage.BulkGetValueAtIndexParams[]",
+        components: [
+          {
+            name: "key",
+            type: "bytes32",
+            internalType: "bytes32"
+          },
+          {
+            name: "operator",
+            type: "address",
+            internalType: "address"
+          },
+          {
+            name: "idx",
+            type: "uint256",
+            internalType: "uint256"
+          }
+        ]
+      }
+    ],
+    outputs: [
+      {
+        name: "results",
+        type: "tuple[]",
+        internalType: "struct IStorage.BulkGetResult[]",
+        components: [
+          {
+            name: "text",
+            type: "string",
+            internalType: "string"
+          },
+          {
+            name: "value",
+            type: "bytes",
+            internalType: "bytes"
+          }
+        ]
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "get",
+    inputs: [
+      {
+        name: "key",
+        type: "bytes32",
+        internalType: "bytes32"
+      },
+      {
+        name: "operator",
+        type: "address",
+        internalType: "address"
+      }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "string",
+        internalType: "string"
+      },
+      {
+        name: "",
+        type: "bytes",
+        internalType: "bytes"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "getValueAtIndex",
+    inputs: [
+      {
+        name: "key",
+        type: "bytes32",
+        internalType: "bytes32"
+      },
+      {
+        name: "operator",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "idx",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "string",
+        internalType: "string"
+      },
+      {
+        name: "",
+        type: "bytes",
+        internalType: "bytes"
+      }
+    ],
+    stateMutability: "view"
+  }
+];
+
+// src/constants.ts
+var STORAGE_CONTRACT = {
+  abi: storage_default,
+  address: "0x00000000db40fcb9f4466330982372e27fd7bbf5"
+};
+var CHUNKED_STORAGE_CONTRACT = {
+  abi: chunked_storage_default,
+  address: "0x000000A822F09aF21b1951B65223F54ea392E6C6"
+};
+var CHUNKED_STORAGE_READER_CONTRACT = {
+  abi: chunked_storage_reader_default,
+  address: "0x00000005210a7532787419658f6162f771be62f8"
+};
+var STORAGE_ROUTER_CONTRACT = {
+  abi: storage_router_default,
+  address: "0x000000C0bbc2Ca04B85E77D18053e7c38bB97939"
+};
+var SAFE_STORAGE_READER_CONTRACT = {
+  abi: safe_storage_reader_default,
+  address: "0x0000000d03bad401fae4935dc9cbbf8084347214"
+};
+
+// src/utils/xmlUtils.ts
+function parseNetReferences(metadata) {
+  const regex = /<net\s+k="([^"]+)"\s+v="([^"]+)"(?:\s+i="([^"]+)")?(?:\s+o="([^"]+)")?(?:\s+s="([^"]+)")?\s*\/>/g;
+  const references = [];
+  let match;
+  while ((match = regex.exec(metadata)) !== null) {
+    references.push({
+      hash: match[1],
+      version: match[2],
+      index: match[3] ? parseInt(match[3], 10) : void 0,
+      operator: match[4]?.toLowerCase(),
+      source: match[5]
+    });
+  }
+  return references;
+}
+function containsXmlReferences(data) {
+  return /<net\s+k="[^"]+"\s+v="[^"]+"(?:\s+i="[^"]+")?(?:\s+o="[^"]+")?(?:\s+s="[^"]+")?\s*\/>/.test(
+    data
+  );
+}
+function resolveOperator(reference, defaultOperator) {
+  return reference.operator?.toLowerCase() || defaultOperator.toLowerCase();
+}
+function getReferenceKey(reference, defaultOperator) {
+  const operator = resolveOperator(reference, defaultOperator);
+  const index = reference.index !== void 0 ? `-${reference.index}` : "";
+  return `${reference.hash}-${operator}${index}`;
+}
+function assembleChunks(chunks, returnHex) {
+  try {
+    let assembled = chunks[0] || "0x";
+    for (let i = 1; i < chunks.length; i++) {
+      const chunk = chunks[i];
+      if (chunk && chunk !== "0x") {
+        assembled += chunk.slice(2);
+      }
+    }
+    const bytes = viem.hexToBytes(assembled);
+    try {
+      const decompressed = pako__default.default.ungzip(bytes);
+      const hexString = Buffer.from(decompressed).toString("utf8");
+      if (returnHex) ;
+      const result = viem.hexToString(hexString);
+      return result;
+    } catch (error) {
+      return void 0;
+    }
+  } catch (error) {
+    console.error("[assembleChunks] Failed to assemble chunks:", error);
+    throw new Error("Failed to decompress chunked data");
+  }
+}
+function getStorageKeyBytes(input, keyFormat) {
+  if (keyFormat === "bytes32") {
+    return input.toLowerCase();
+  }
+  if (keyFormat === "raw") {
+    return input.length > 32 ? core.keccak256HashString(input.toLowerCase()) : core.toBytes32(input.toLowerCase());
+  }
+  if (input.startsWith("0x") && input.length === 66 && // 0x + 64 hex chars = bytes32
+  /^0x[0-9a-fA-F]{64}$/.test(input)) {
+    return input.toLowerCase();
+  }
+  return input.length > 32 ? core.keccak256HashString(input.toLowerCase()) : core.toBytes32(input.toLowerCase());
+}
+
+// src/hooks/useStorage.ts
+var BATCH_SIZE = 2;
+function useStorage({
+  chainId,
+  key,
+  operatorAddress,
+  enabled = true,
+  index,
+  keyFormat,
+  useRouter = false,
+  outputFormat = "hex"
+}) {
+  const isLatestVersion = index === void 0;
+  const shouldUseRouter = useRouter === true && isLatestVersion;
+  const outputAsString = outputFormat === "string";
+  const storageKeyBytes = key ? getStorageKeyBytes(key, keyFormat) : void 0;
+  const formatData = (text, dataHex) => {
+    return {
+      text,
+      value: outputAsString ? viem.hexToString(dataHex) : dataHex
+    };
+  };
+  const [routerData, setRouterData] = react.useState();
+  const [routerChunkLoading, setRouterChunkLoading] = react.useState(false);
+  const [routerChunkError, setRouterChunkError] = react.useState();
+  const routerHook = wagmi.useReadContract({
+    abi: STORAGE_ROUTER_CONTRACT.abi,
+    address: STORAGE_ROUTER_CONTRACT.address,
+    functionName: "get",
+    args: storageKeyBytes && operatorAddress ? [storageKeyBytes, operatorAddress] : void 0,
+    chainId,
+    query: {
+      enabled: shouldUseRouter && enabled && !!key && !!operatorAddress
+    }
+  });
+  react.useEffect(() => {
+    async function processRouterResult() {
+      if (!routerHook.data || routerHook.isLoading || routerHook.error) {
+        return;
+      }
+      const [isChunkedStorage, text, data] = routerHook.data;
+      if (!isChunkedStorage) {
+        if (!data || typeof data !== "string") {
+          setRouterData(void 0);
+          return;
+        }
+        const formatted = formatData(text, data);
+        setRouterData(formatted);
+        return;
+      }
+      setRouterChunkLoading(true);
+      setRouterChunkError(void 0);
+      try {
+        const [chunkCount] = viem.decodeAbiParameters([{ type: "uint8" }], data);
+        if (chunkCount === 0) {
+          setRouterData(void 0);
+          return;
+        }
+        const client = core.getPublicClient({ chainId });
+        if (!client) {
+          throw new Error(`Chain not found for chainId: ${chainId}`);
+        }
+        const allChunks = [];
+        for (let start = 0; start < Number(chunkCount); start += BATCH_SIZE) {
+          const end = Math.min(start + BATCH_SIZE, Number(chunkCount));
+          const batch = await actions.readContract(client, {
+            abi: CHUNKED_STORAGE_CONTRACT.abi,
+            address: CHUNKED_STORAGE_CONTRACT.address,
+            functionName: "getChunks",
+            args: [storageKeyBytes, operatorAddress, start, end]
+          });
+          allChunks.push(...batch);
+        }
+        const assembledString = assembleChunks(allChunks);
+        if (assembledString === void 0) {
+          setRouterData(void 0);
+        } else {
+          if (outputAsString) {
+            setRouterData({ text, value: assembledString });
+          } else {
+            const hexData = viem.stringToHex(assembledString);
+            setRouterData({ text, value: hexData });
+          }
+        }
+      } catch (error) {
+        setRouterChunkError(error);
+      } finally {
+        setRouterChunkLoading(false);
+      }
+    }
+    processRouterResult();
+  }, [
+    routerHook.data,
+    routerHook.isLoading,
+    routerHook.error,
+    operatorAddress,
+    chainId,
+    storageKeyBytes,
+    outputAsString
+  ]);
+  const {
+    data: latestData,
+    isLoading: latestLoading,
+    error: latestError
+  } = wagmi.useReadContract({
+    abi: STORAGE_CONTRACT.abi,
+    address: STORAGE_CONTRACT.address,
+    functionName: "get",
+    args: key && operatorAddress ? [getStorageKeyBytes(key, keyFormat), operatorAddress] : void 0,
+    chainId,
+    query: {
+      enabled: !shouldUseRouter && enabled && !!operatorAddress && !!key && isLatestVersion
+    }
+  });
+  const [historicalData, setHistoricalData] = react.useState(
+    void 0
+  );
+  const [historicalLoading, setHistoricalLoading] = react.useState(false);
+  const [historicalError, setHistoricalError] = react.useState();
+  react.useEffect(() => {
+    async function fetchHistoricalVersion() {
+      if (isLatestVersion || !key || !operatorAddress || !enabled) {
+        return;
+      }
+      setHistoricalLoading(true);
+      setHistoricalError(void 0);
+      setHistoricalData(void 0);
+      try {
+        const client = core.getPublicClient({ chainId });
+        if (!client) {
+          throw new Error(`Chain not found for chainId: ${chainId}`);
+        }
+        const storageKeyBytes2 = getStorageKeyBytes(
+          key,
+          keyFormat
+        );
+        try {
+          const metadata = await actions.readContract(client, {
+            abi: CHUNKED_STORAGE_READER_CONTRACT.abi,
+            address: CHUNKED_STORAGE_READER_CONTRACT.address,
+            functionName: "getMetadataAtIndex",
+            args: [storageKeyBytes2, operatorAddress, index]
+          });
+          const [chunkCount, text2] = metadata;
+          if (chunkCount > 0) {
+            const chunks = await actions.readContract(client, {
+              abi: CHUNKED_STORAGE_READER_CONTRACT.abi,
+              address: CHUNKED_STORAGE_READER_CONTRACT.address,
+              functionName: "getChunksAtIndex",
+              args: [storageKeyBytes2, operatorAddress, 0, chunkCount, index]
+            });
+            const assembledData = assembleChunks(chunks);
+            if (assembledData !== void 0) {
+              const hexData = viem.stringToHex(assembledData);
+              setHistoricalData(formatData(text2, hexData));
+              setHistoricalLoading(false);
+              return;
+            }
+          }
+        } catch (chunkedError) {
+        }
+        const result = await actions.readContract(client, {
+          abi: STORAGE_CONTRACT.abi,
+          address: STORAGE_CONTRACT.address,
+          functionName: "getValueAtIndex",
+          args: [storageKeyBytes2, operatorAddress, index]
+        });
+        const [text, data] = result;
+        if (!data || typeof data !== "string") {
+          setHistoricalData(void 0);
+          setHistoricalLoading(false);
+          return;
+        }
+        setHistoricalData(formatData(text, data));
+      } catch (error) {
+        console.error(
+          "[useStorage] Failed to fetch historical version:",
+          error
+        );
+        setHistoricalError(error);
+      } finally {
+        setHistoricalLoading(false);
+      }
+    }
+    fetchHistoricalVersion();
+  }, [
+    chainId,
+    key,
+    operatorAddress,
+    index,
+    enabled,
+    isLatestVersion,
+    outputAsString
+  ]);
+  if (!isLatestVersion) {
+    return {
+      data: historicalData,
+      isLoading: historicalLoading,
+      error: historicalError
+    };
+  }
+  if (shouldUseRouter) {
+    return {
+      data: routerData,
+      isLoading: routerHook.isLoading || routerChunkLoading,
+      error: routerHook.error || routerChunkError
+    };
+  }
+  const formattedDirectData = latestData ? (() => {
+    const result = latestData;
+    const [text, valueHex] = result;
+    if (!valueHex || typeof valueHex !== "string") {
+      return void 0;
+    }
+    return formatData(text, valueHex);
+  })() : void 0;
+  return {
+    data: formattedDirectData,
+    isLoading: latestLoading,
+    error: latestError
+  };
+}
+function useStorageForOperator({
+  chainId,
+  operatorAddress
+}) {
+  const netContract = core.getNetContract(chainId);
+  const { data: totalCount, isLoading: isLoadingCount } = wagmi.useReadContract({
+    abi: netContract.abi,
+    address: netContract.address,
+    functionName: "getTotalMessagesForAppUserCount",
+    args: [STORAGE_CONTRACT.address, operatorAddress],
+    chainId
+  });
+  const totalCountNumber = totalCount ? Number(totalCount) : 0;
+  const { data: messages, isLoading: isLoadingMessages } = wagmi.useReadContract({
+    abi: netContract.abi,
+    address: netContract.address,
+    functionName: "getMessagesInRangeForAppUser",
+    args: [0, totalCountNumber, STORAGE_CONTRACT.address, operatorAddress],
+    chainId
+  });
+  return {
+    data: messages?.map((msg) => [
+      msg.topic,
+      msg.text,
+      Number(msg.timestamp),
+      msg.data
+    ]) || [],
+    isLoading: isLoadingCount || isLoadingMessages,
+    error: void 0
+  };
+}
+function useStorageForOperatorAndKey({
+  chainId,
+  key,
+  operatorAddress,
+  keyFormat,
+  outputFormat = "hex"
+}) {
+  const storageKeyBytes = key ? getStorageKeyBytes(key, keyFormat) : void 0;
+  const outputAsString = outputFormat === "string";
+  const readContractArgs = {
+    abi: STORAGE_CONTRACT.abi,
+    address: STORAGE_CONTRACT.address,
+    functionName: "getForOperatorAndKey",
+    args: storageKeyBytes ? [operatorAddress, storageKeyBytes] : void 0,
+    chainId,
+    query: {
+      enabled: !!key && !!operatorAddress
+    }
+  };
+  const { data, isLoading, error } = wagmi.useReadContract(readContractArgs);
+  return {
+    data: data ? (() => {
+      const [text, valueHex] = data;
+      return {
+        text,
+        value: outputAsString ? viem.hexToString(valueHex) : valueHex
+      };
+    })() : void 0,
+    isLoading,
+    error
+  };
+}
+function useBulkStorage({
+  chainId,
+  keys,
+  safe = false,
+  keyFormat
+}) {
+  const contract = safe ? SAFE_STORAGE_READER_CONTRACT : STORAGE_CONTRACT;
+  const bulkKeys = keys.map((k) => ({
+    key: getStorageKeyBytes(k.key, keyFormat),
+    operator: k.operator
+  }));
+  const readContractArgs = {
+    abi: contract.abi,
+    address: contract.address,
+    functionName: "bulkGet",
+    args: [bulkKeys],
+    chainId
+  };
+  const { data, isLoading, error } = wagmi.useReadContract(readContractArgs);
+  return {
+    data,
+    isLoading,
+    error
+  };
+}
+function useStorageTotalWrites({
+  chainId,
+  key,
+  operatorAddress,
+  enabled = true,
+  keyFormat
+}) {
+  const storageKeyBytes = key ? getStorageKeyBytes(key, keyFormat) : void 0;
+  const {
+    data: chunkedTotal,
+    isLoading: chunkedLoading,
+    error: chunkedError
+  } = wagmi.useReadContract({
+    abi: CHUNKED_STORAGE_READER_CONTRACT.abi,
+    address: CHUNKED_STORAGE_READER_CONTRACT.address,
+    functionName: "getTotalWrites",
+    args: storageKeyBytes && operatorAddress ? [storageKeyBytes, operatorAddress] : void 0,
+    chainId,
+    query: {
+      enabled: enabled && !!key && !!operatorAddress
+    }
+  });
+  const {
+    data: regularTotal,
+    isLoading: regularLoading,
+    error: regularError
+  } = wagmi.useReadContract({
+    abi: STORAGE_CONTRACT.abi,
+    address: STORAGE_CONTRACT.address,
+    functionName: "getTotalWrites",
+    args: storageKeyBytes && operatorAddress ? [storageKeyBytes, operatorAddress] : void 0,
+    chainId,
+    query: {
+      enabled: enabled && !!key && !!operatorAddress && (chunkedTotal === void 0 || Number(chunkedTotal) === 0)
+    }
+  });
+  const chunkedTotalNumber = chunkedTotal ? Number(chunkedTotal) : 0;
+  const regularTotalNumber = regularTotal ? Number(regularTotal) : 0;
+  const totalWrites = chunkedTotalNumber > 0 ? chunkedTotalNumber : regularTotalNumber;
+  return {
+    data: totalWrites > 0 ? totalWrites : void 0,
+    isLoading: chunkedLoading || regularLoading,
+    error: chunkedTotalNumber === 0 && regularTotalNumber === 0 ? chunkedError || regularError : void 0
+  };
+}
+var MAX_XML_DEPTH = 3;
+var CONCURRENT_XML_FETCHES = 3;
+function assembleXmlData(metadata, chunks, references) {
+  const tagPositions = [];
+  for (let i = 0; i < references.length; i++) {
+    const ref = references[i];
+    const chunkData = chunks[i];
+    if (!chunkData) continue;
+    const indexAttr = ref.index !== void 0 ? ` i="${ref.index}"` : "";
+    const operatorAttr = ref.operator ? ` o="${ref.operator}"` : "";
+    const sourceAttr = ref.source ? ` s="${ref.source}"` : "";
+    const xmlTag = `<net k="${ref.hash}" v="${ref.version}"${indexAttr}${operatorAttr}${sourceAttr} />`;
+    const tagIndex = metadata.indexOf(xmlTag);
+    if (tagIndex === -1) {
+      continue;
+    }
+    tagPositions.push({
+      ref,
+      chunk: chunkData,
+      start: tagIndex,
+      end: tagIndex + xmlTag.length,
+      tag: xmlTag
+    });
+  }
+  tagPositions.sort((a, b) => b.start - a.start);
+  let result = metadata;
+  for (let i = 0; i < tagPositions.length; i++) {
+    const { ref, chunk, start, end } = tagPositions[i];
+    try {
+      result = result.substring(0, start) + chunk + result.substring(end);
+    } catch (error) {
+      throw error;
+    }
+  }
+  return result;
+}
+async function fetchFromDirectStorage(reference, operator, client) {
+  const functionName = reference.index !== void 0 ? "getValueAtIndex" : "get";
+  const args = reference.index !== void 0 ? [reference.hash, operator, reference.index] : [reference.hash, operator];
+  const result = await actions.readContract(client, {
+    address: STORAGE_CONTRACT.address,
+    abi: STORAGE_CONTRACT.abi,
+    functionName,
+    args
+  });
+  const content = viem.hexToString(result[1] || "");
+  return content;
+}
+async function fetchFromChunkedStorage(reference, operator, client) {
+  const contract = CHUNKED_STORAGE_READER_CONTRACT;
+  const functionName = reference.index !== void 0 ? "getMetadataAtIndex" : "getMetadata";
+  const chunksFunctionName = reference.index !== void 0 ? "getChunksAtIndex" : "getChunks";
+  const metadataArgs = reference.index !== void 0 ? [reference.hash, operator, reference.index] : [reference.hash, operator];
+  const metadata = await actions.readContract(client, {
+    abi: contract.abi,
+    address: contract.address,
+    functionName,
+    args: metadataArgs
+  });
+  const chunkCount = metadata[0];
+  if (chunkCount === 0) return "";
+  const chunksArgs = reference.index !== void 0 ? [reference.hash, operator, 0, chunkCount, reference.index] : [reference.hash, operator, 0, chunkCount];
+  const chunks = await actions.readContract(client, {
+    abi: contract.abi,
+    address: contract.address,
+    functionName: chunksFunctionName,
+    args: chunksArgs
+  });
+  const assembledResult = assembleChunks(chunks);
+  const content = assembledResult || "";
+  return content;
+}
+async function fetchSingleChunk(reference, defaultOperator, inheritedOperator, client) {
+  const effectiveOperator = reference.operator || inheritedOperator || defaultOperator;
+  if (reference.source === "d") {
+    return await fetchFromDirectStorage(reference, effectiveOperator, client);
+  } else {
+    return await fetchFromChunkedStorage(reference, effectiveOperator, client);
+  }
+}
+async function resolveXmlRecursive(content, defaultOperator, client, maxDepth, visited = /* @__PURE__ */ new Set(), inheritedOperator) {
+  if (maxDepth <= 0) {
+    return content;
+  }
+  if (!containsXmlReferences(content)) {
+    return content;
+  }
+  const references = parseNetReferences(content);
+  if (references.length === 0) {
+    return content;
+  }
+  const resolvedChunks = [];
+  for (let batchStart = 0; batchStart < references.length; batchStart += CONCURRENT_XML_FETCHES) {
+    const batchEnd = Math.min(
+      batchStart + CONCURRENT_XML_FETCHES,
+      references.length
+    );
+    const batch = references.slice(batchStart, batchEnd);
+    const batchResults = await Promise.all(
+      batch.map(async (ref, batchIndex) => {
+        const index = batchStart + batchIndex;
+        const effectiveOperator = ref.operator || inheritedOperator || defaultOperator;
+        const refKey = getReferenceKey(
+          { ...ref, operator: effectiveOperator },
+          defaultOperator
+        );
+        if (visited.has(refKey)) {
+          console.warn(
+            `[resolveXmlRecursive] Circular reference detected: ${refKey}`
+          );
+          return `[Circular: ${refKey}]`;
+        }
+        const newVisited = new Set(visited);
+        newVisited.add(refKey);
+        try {
+          const chunkContent = await fetchSingleChunk(
+            ref,
+            defaultOperator,
+            inheritedOperator,
+            client
+          );
+          const resolvedContent = await resolveXmlRecursive(
+            chunkContent,
+            defaultOperator,
+            client,
+            maxDepth - 1,
+            newVisited,
+            effectiveOperator
+            // Pass the effective operator to children
+          );
+          return resolvedContent;
+        } catch (error) {
+          console.error(
+            `[resolveXmlRecursive] Failed to fetch/resolve chunk ${index}:`,
+            error
+          );
+          return "";
+        }
+      })
+    );
+    resolvedChunks.push(...batchResults);
+  }
+  const assembled = assembleXmlData(content, resolvedChunks, references);
+  return assembled;
+}
+function useXmlStorage({
+  chainId,
+  key,
+  operatorAddress,
+  skipXmlParsing = false,
+  enabled = true,
+  content,
+  index,
+  keyFormat,
+  useRouter,
+  outputFormat = "hex"
+}) {
+  const isPreviewMode = !!content;
+  const outputAsString = outputFormat === "string";
+  const {
+    data: metadata,
+    isLoading: metadataLoading,
+    error: metadataError
+  } = useStorage({
+    chainId,
+    key: key || "",
+    operatorAddress,
+    enabled: enabled && !isPreviewMode,
+    index,
+    // Pass index to useStorage for historical versions
+    keyFormat,
+    // Pass keyFormat through
+    useRouter,
+    // Pass useRouter through to enable router path
+    outputFormat: "string"
+    // Always get plain string from useStorage, then convert based on our outputFormat
+  });
+  const metadataString = react.useMemo(() => {
+    if (skipXmlParsing) return "";
+    if (isPreviewMode) return content || "";
+    if (!metadata?.value) return "";
+    return metadata.value;
+  }, [skipXmlParsing, isPreviewMode, content, metadata]);
+  react.useMemo(() => {
+    if (!metadataString) return [];
+    return parseNetReferences(metadataString);
+  }, [metadataString]);
+  const [chunks, setChunks] = react.useState([]);
+  const [chunksLoading, setChunksLoading] = react.useState(false);
+  const [chunksError, setChunksError] = react.useState();
+  useAsyncEffect__default.default(async () => {
+    if (skipXmlParsing || !metadataString) {
+      setChunks([]);
+      setChunksLoading(false);
+      return;
+    }
+    if (!containsXmlReferences(metadataString)) {
+      setChunks([]);
+      setChunksLoading(false);
+      return;
+    }
+    setChunksLoading(true);
+    setChunksError(void 0);
+    try {
+      const client = core.getPublicClient({ chainId });
+      if (!client) {
+        throw new Error(`Chain not found for chainId: ${chainId}`);
+      }
+      const resolved = await resolveXmlRecursive(
+        metadataString,
+        operatorAddress,
+        client,
+        MAX_XML_DEPTH,
+        /* @__PURE__ */ new Set()
+      );
+      setChunks([resolved]);
+    } catch (error) {
+      console.error("[useXmlStorage] Error in recursive resolution:", error);
+      setChunksError(error);
+      setChunks([]);
+    } finally {
+      setChunksLoading(false);
+    }
+  }, [metadataString, operatorAddress, chainId, skipXmlParsing]);
+  const assembledData = react.useMemo(() => {
+    if (skipXmlParsing || !metadataString || !chunks.length) return void 0;
+    return chunks[0];
+  }, [metadataString, chunks, skipXmlParsing]);
+  const isXml = react.useMemo(() => {
+    if (skipXmlParsing || !metadataString) return false;
+    return containsXmlReferences(metadataString);
+  }, [metadataString, skipXmlParsing]);
+  const formatValue = (value) => {
+    if (!value) return "";
+    return outputAsString ? value : viem.stringToHex(value);
+  };
+  if (skipXmlParsing) {
+    return {
+      text: metadata?.text || "",
+      value: isPreviewMode ? content || "" : formatValue(metadata?.value),
+      isLoading: metadataLoading,
+      error: metadataError,
+      isXml: false
+    };
+  }
+  return {
+    text: metadata?.text || "",
+    value: isXml ? formatValue(assembledData) : isPreviewMode ? content || "" : formatValue(metadata?.value),
+    isLoading: metadataLoading || isXml && chunksLoading,
+    error: metadataError || chunksError,
+    isXml
+  };
+}
+var BATCH_SIZE2 = 2;
+function useStorageFromRouter({
+  chainId,
+  storageKey,
+  operatorAddress,
+  enabled = true
+}) {
+  const [assembledData, setAssembledData] = react.useState();
+  const [isChunkLoading, setIsChunkLoading] = react.useState(false);
+  const [chunkError, setChunkError] = react.useState();
+  const {
+    data: routerResult,
+    isLoading: routerLoading,
+    error: routerError
+  } = wagmi.useReadContract({
+    abi: STORAGE_ROUTER_CONTRACT.abi,
+    address: STORAGE_ROUTER_CONTRACT.address,
+    functionName: "get",
+    args: [storageKey, operatorAddress],
+    chainId,
+    query: {
+      enabled: enabled && !!operatorAddress
+    }
+  });
+  react.useEffect(() => {
+    async function processResult() {
+      if (!routerResult || routerLoading || routerError) {
+        return;
+      }
+      const [isChunkedStorage, text, data] = routerResult;
+      if (!isChunkedStorage) {
+        setAssembledData({ text, value: data });
+        return;
+      }
+      setIsChunkLoading(true);
+      setChunkError(void 0);
+      try {
+        const [chunkCount] = viem.decodeAbiParameters([{ type: "uint8" }], data);
+        if (chunkCount === 0) {
+          setAssembledData(void 0);
+          return;
+        }
+        const allChunks = await fetchChunksInBatches(
+          Number(chunkCount),
+          operatorAddress,
+          chainId,
+          storageKey
+        );
+        const assembledString = assembleChunks(allChunks);
+        if (assembledString === void 0) {
+          setAssembledData(void 0);
+        } else {
+          const hexData = viem.stringToHex(assembledString);
+          setAssembledData({ text, value: hexData });
+        }
+      } catch (error) {
+        setChunkError(error);
+      } finally {
+        setIsChunkLoading(false);
+      }
+    }
+    processResult();
+  }, [
+    routerResult,
+    routerLoading,
+    routerError,
+    operatorAddress,
+    chainId,
+    storageKey
+  ]);
+  return {
+    data: assembledData,
+    isLoading: routerLoading || isChunkLoading,
+    error: routerError || chunkError
+  };
+}
+async function fetchChunksInBatches(chunkCount, operatorAddress, chainId, storageKey) {
+  const client = core.getPublicClient({ chainId });
+  if (!client) {
+    throw new Error(`Chain not found for chainId: ${chainId}`);
+  }
+  const allChunks = [];
+  for (let start = 0; start < chunkCount; start += BATCH_SIZE2) {
+    const end = Math.min(start + BATCH_SIZE2, chunkCount);
+    const batch = await actions.readContract(client, {
+      abi: CHUNKED_STORAGE_CONTRACT.abi,
+      address: CHUNKED_STORAGE_CONTRACT.address,
+      functionName: "getChunks",
+      args: [storageKey, operatorAddress, start, end]
+    });
+    allChunks.push(...batch);
+  }
+  return allChunks;
+}
+
+exports.useBulkStorage = useBulkStorage;
+exports.useStorage = useStorage;
+exports.useStorageForOperator = useStorageForOperator;
+exports.useStorageForOperatorAndKey = useStorageForOperatorAndKey;
+exports.useStorageFromRouter = useStorageFromRouter;
+exports.useStorageTotalWrites = useStorageTotalWrites;
+exports.useXmlStorage = useXmlStorage;
+//# sourceMappingURL=react.js.map
+//# sourceMappingURL=react.js.map