@net-protocol/storage 0.1.8 → 0.1.10

package/dist/index.js

@@ -1,19 +1,15 @@
 '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');
+var core = require('@net-protocol/core');
+var pako = require('pako');
 
 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/client/StorageClient.ts
 
 // src/abis/storage.json
 var storage_default = [
@@ -598,6 +594,150 @@ var SAFE_STORAGE_READER_CONTRACT = {
   abi: safe_storage_reader_default,
   address: "0x0000000d03bad401fae4935dc9cbbf8084347214"
 };
+function isBinaryString(str) {
+  return str.split("").some((char) => char.charCodeAt(0) > 127);
+}
+function formatStorageKeyForDisplay(storageKey) {
+  if (storageKey.startsWith("0x") && storageKey.length === 66 && /^0x[0-9a-fA-F]{64}$/.test(storageKey)) {
+    try {
+      const decoded = viem.fromHex(storageKey, "string");
+      const trimmed = decoded.replace(/\0/g, "");
+      if (!isBinaryString(trimmed) && trimmed.trim().length > 0) {
+        return {
+          displayText: trimmed,
+          isDecoded: true
+        };
+      }
+    } catch {
+    }
+  }
+  return {
+    displayText: storageKey,
+    isDecoded: false
+  };
+}
+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());
+}
+function encodeStorageKeyForUrl(key) {
+  return encodeURIComponent(key);
+}
+function generateStorageEmbedTag(params) {
+  const operator = params.operatorAddress.toLowerCase();
+  const indexAttr = params.versionIndex !== void 0 ? ` i="${params.versionIndex}"` : "";
+  const sourceAttr = params.isRegularStorage ? ` s="d"` : "";
+  return `<net k="${params.storageKeyBytes}" v="0.0.1"${indexAttr} o="${operator}"${sourceAttr} />`;
+}
+
+// src/client/storage.ts
+function getStorageReadConfig(params) {
+  const { chainId, key, operator, keyFormat } = params;
+  const storageKeyBytes = getStorageKeyBytes(key, keyFormat);
+  return {
+    abi: STORAGE_CONTRACT.abi,
+    address: STORAGE_CONTRACT.address,
+    functionName: "get",
+    args: [storageKeyBytes, operator],
+    chainId
+  };
+}
+function getStorageValueAtIndexReadConfig(params) {
+  const { chainId, key, operator, index, keyFormat } = params;
+  const storageKeyBytes = getStorageKeyBytes(key, keyFormat);
+  return {
+    abi: STORAGE_CONTRACT.abi,
+    address: STORAGE_CONTRACT.address,
+    functionName: "getValueAtIndex",
+    args: [storageKeyBytes, operator, index],
+    chainId
+  };
+}
+function getStorageTotalWritesReadConfig(params) {
+  const { chainId, key, operator, keyFormat } = params;
+  const storageKeyBytes = getStorageKeyBytes(key, keyFormat);
+  return {
+    abi: STORAGE_CONTRACT.abi,
+    address: STORAGE_CONTRACT.address,
+    functionName: "getTotalWrites",
+    args: [storageKeyBytes, operator],
+    chainId
+  };
+}
+function getStorageBulkGetReadConfig(params) {
+  const { chainId, keys, safe = false, keyFormat } = params;
+  const contract = safe ? SAFE_STORAGE_READER_CONTRACT : STORAGE_CONTRACT;
+  const bulkKeys = keys.map((k) => ({
+    key: getStorageKeyBytes(k.key, k.keyFormat ?? keyFormat),
+    operator: k.operator
+  }));
+  return {
+    abi: contract.abi,
+    address: contract.address,
+    functionName: "bulkGet",
+    args: [bulkKeys],
+    chainId
+  };
+}
+function getStorageRouterReadConfig(params) {
+  const { chainId, key, operator, keyFormat } = params;
+  const storageKeyBytes = getStorageKeyBytes(key, keyFormat);
+  return {
+    abi: STORAGE_ROUTER_CONTRACT.abi,
+    address: STORAGE_ROUTER_CONTRACT.address,
+    functionName: "get",
+    args: [storageKeyBytes, operator],
+    chainId
+  };
+}
+
+// src/client/chunkedStorage.ts
+function getChunkedStorageMetadataReadConfig(params) {
+  const { chainId, key, operator, index, keyFormat } = params;
+  const storageKeyBytes = getStorageKeyBytes(key, keyFormat);
+  const functionName = index !== void 0 ? "getMetadataAtIndex" : "getMetadata";
+  const args = index !== void 0 ? [storageKeyBytes, operator, index] : [storageKeyBytes, operator];
+  return {
+    abi: CHUNKED_STORAGE_READER_CONTRACT.abi,
+    address: CHUNKED_STORAGE_READER_CONTRACT.address,
+    functionName,
+    args,
+    chainId
+  };
+}
+function getChunkedStorageChunksReadConfig(params) {
+  const { chainId, key, operator, start, end, index, keyFormat } = params;
+  const storageKeyBytes = getStorageKeyBytes(key, keyFormat);
+  const functionName = index !== void 0 ? "getChunksAtIndex" : "getChunks";
+  const args = index !== void 0 ? [storageKeyBytes, operator, start, end, index] : [storageKeyBytes, operator, start, end];
+  return {
+    abi: CHUNKED_STORAGE_READER_CONTRACT.abi,
+    address: CHUNKED_STORAGE_READER_CONTRACT.address,
+    functionName,
+    args,
+    chainId
+  };
+}
+function getChunkedStorageTotalWritesReadConfig(params) {
+  const { chainId, key, operator, keyFormat } = params;
+  const storageKeyBytes = getStorageKeyBytes(key, keyFormat);
+  return {
+    abi: CHUNKED_STORAGE_READER_CONTRACT.abi,
+    address: CHUNKED_STORAGE_READER_CONTRACT.address,
+    functionName: "getTotalWrites",
+    args: [storageKeyBytes, operator],
+    chainId
+  };
+}
 
 // src/utils/xmlUtils.ts
 function parseNetReferences(metadata) {
@@ -688,406 +828,6 @@ function assembleChunks(chunks, returnHex) {
     throw new Error("Failed to decompress chunked data");
   }
 }
-function isBinaryString(str) {
-  return str.split("").some((char) => char.charCodeAt(0) > 127);
-}
-function formatStorageKeyForDisplay(storageKey) {
-  if (storageKey.startsWith("0x") && storageKey.length === 66 && /^0x[0-9a-fA-F]{64}$/.test(storageKey)) {
-    try {
-      const decoded = viem.fromHex(storageKey, "string");
-      const trimmed = decoded.replace(/\0/g, "");
-      if (!isBinaryString(trimmed) && trimmed.trim().length > 0) {
-        return {
-          displayText: trimmed,
-          isDecoded: true
-        };
-      }
-    } catch {
-    }
-  }
-  return {
-    displayText: storageKey,
-    isDecoded: false
-  };
-}
-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());
-}
-function encodeStorageKeyForUrl(key) {
-  return encodeURIComponent(key);
-}
-function generateStorageEmbedTag(params) {
-  const operator = params.operatorAddress.toLowerCase();
-  const indexAttr = params.versionIndex !== void 0 ? ` i="${params.versionIndex}"` : "";
-  const sourceAttr = params.isRegularStorage ? ` s="d"` : "";
-  return `<net k="${params.storageKeyBytes}" v="0.0.1"${indexAttr} o="${operator}"${sourceAttr} />`;
-}
-
-// 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) {
@@ -1233,308 +973,6 @@ async function resolveXmlRecursive(content, defaultOperator, client, maxDepth, v
   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;
-}
-
-// src/client/storage.ts
-function getStorageReadConfig(params) {
-  const { chainId, key, operator, keyFormat } = params;
-  const storageKeyBytes = getStorageKeyBytes(key, keyFormat);
-  return {
-    abi: STORAGE_CONTRACT.abi,
-    address: STORAGE_CONTRACT.address,
-    functionName: "get",
-    args: [storageKeyBytes, operator],
-    chainId
-  };
-}
-function getStorageValueAtIndexReadConfig(params) {
-  const { chainId, key, operator, index, keyFormat } = params;
-  const storageKeyBytes = getStorageKeyBytes(key, keyFormat);
-  return {
-    abi: STORAGE_CONTRACT.abi,
-    address: STORAGE_CONTRACT.address,
-    functionName: "getValueAtIndex",
-    args: [storageKeyBytes, operator, index],
-    chainId
-  };
-}
-function getStorageTotalWritesReadConfig(params) {
-  const { chainId, key, operator, keyFormat } = params;
-  const storageKeyBytes = getStorageKeyBytes(key, keyFormat);
-  return {
-    abi: STORAGE_CONTRACT.abi,
-    address: STORAGE_CONTRACT.address,
-    functionName: "getTotalWrites",
-    args: [storageKeyBytes, operator],
-    chainId
-  };
-}
-function getStorageBulkGetReadConfig(params) {
-  const { chainId, keys, safe = false, keyFormat } = params;
-  const contract = safe ? SAFE_STORAGE_READER_CONTRACT : STORAGE_CONTRACT;
-  const bulkKeys = keys.map((k) => ({
-    key: getStorageKeyBytes(k.key, k.keyFormat ?? keyFormat),
-    operator: k.operator
-  }));
-  return {
-    abi: contract.abi,
-    address: contract.address,
-    functionName: "bulkGet",
-    args: [bulkKeys],
-    chainId
-  };
-}
-function getStorageRouterReadConfig(params) {
-  const { chainId, key, operator, keyFormat } = params;
-  const storageKeyBytes = getStorageKeyBytes(key, keyFormat);
-  return {
-    abi: STORAGE_ROUTER_CONTRACT.abi,
-    address: STORAGE_ROUTER_CONTRACT.address,
-    functionName: "get",
-    args: [storageKeyBytes, operator],
-    chainId
-  };
-}
-
-// src/client/chunkedStorage.ts
-function getChunkedStorageMetadataReadConfig(params) {
-  const { chainId, key, operator, index, keyFormat } = params;
-  const storageKeyBytes = getStorageKeyBytes(key, keyFormat);
-  const functionName = index !== void 0 ? "getMetadataAtIndex" : "getMetadata";
-  const args = index !== void 0 ? [storageKeyBytes, operator, index] : [storageKeyBytes, operator];
-  return {
-    abi: CHUNKED_STORAGE_READER_CONTRACT.abi,
-    address: CHUNKED_STORAGE_READER_CONTRACT.address,
-    functionName,
-    args,
-    chainId
-  };
-}
-function getChunkedStorageChunksReadConfig(params) {
-  const { chainId, key, operator, start, end, index, keyFormat } = params;
-  const storageKeyBytes = getStorageKeyBytes(key, keyFormat);
-  const functionName = index !== void 0 ? "getChunksAtIndex" : "getChunks";
-  const args = index !== void 0 ? [storageKeyBytes, operator, start, end, index] : [storageKeyBytes, operator, start, end];
-  return {
-    abi: CHUNKED_STORAGE_READER_CONTRACT.abi,
-    address: CHUNKED_STORAGE_READER_CONTRACT.address,
-    functionName,
-    args,
-    chainId
-  };
-}
-function getChunkedStorageTotalWritesReadConfig(params) {
-  const { chainId, key, operator, keyFormat } = params;
-  const storageKeyBytes = getStorageKeyBytes(key, keyFormat);
-  return {
-    abi: CHUNKED_STORAGE_READER_CONTRACT.abi,
-    address: CHUNKED_STORAGE_READER_CONTRACT.address,
-    functionName: "getTotalWrites",
-    args: [storageKeyBytes, operator],
-    chainId
-  };
-}
 var MAX_CHUNKS = 255;
 var OPTIMAL_CHUNK_SIZE = 80 * 1e3;
 function chunkData(data, chunkSize = OPTIMAL_CHUNK_SIZE) {
@@ -2209,6 +1647,129 @@ function base64ToDataUri(base64Data) {
   const mimeType = detectFileTypeFromBase64(base64Data) || "application/octet-stream";
   return `data:${mimeType};base64,${base64Data}`;
 }
+var STREAMING_CHUNK_SIZE = 80 * 1e3;
+var BINARY_CHUNK_SIZE = 79998;
+function isBinaryFile(file) {
+  const mimeType = file.type.toLowerCase();
+  const textTypes = [
+    "text/",
+    "application/json",
+    "application/xml",
+    "application/javascript",
+    "application/typescript",
+    "application/x-javascript",
+    "application/ecmascript"
+  ];
+  for (const textType of textTypes) {
+    if (mimeType.startsWith(textType)) {
+      return false;
+    }
+  }
+  if (!mimeType || mimeType === "application/octet-stream") {
+    const extension = file.name.split(".").pop()?.toLowerCase() || "";
+    const textExtensions = [
+      "txt",
+      "md",
+      "json",
+      "xml",
+      "html",
+      "htm",
+      "css",
+      "js",
+      "ts",
+      "jsx",
+      "tsx",
+      "yaml",
+      "yml",
+      "toml",
+      "ini",
+      "cfg",
+      "conf",
+      "log",
+      "csv",
+      "svg"
+    ];
+    return !textExtensions.includes(extension);
+  }
+  return true;
+}
+async function readFileSlice(file, offset, size, isBinary, isFirstChunk) {
+  const blob = file.slice(offset, offset + size);
+  if (isBinary) {
+    const arrayBuffer = await blob.arrayBuffer();
+    const bytes = new Uint8Array(arrayBuffer);
+    let base64 = "";
+    const chunkSize = 32766;
+    for (let i = 0; i < bytes.length; i += chunkSize) {
+      const chunk = bytes.slice(i, i + chunkSize);
+      base64 += btoa(String.fromCharCode(...chunk));
+    }
+    if (isFirstChunk) {
+      const mimeType = detectFileTypeFromBase64(base64) || file.type || "application/octet-stream";
+      return `data:${mimeType};base64,${base64}`;
+    }
+    return base64;
+  } else {
+    return await blob.text();
+  }
+}
+async function* processFileStreaming(file, chunkSize = STREAMING_CHUNK_SIZE) {
+  const binary = isBinaryFile(file);
+  const effectiveChunkSize = binary ? BINARY_CHUNK_SIZE : chunkSize;
+  let offset = 0;
+  let chunkIndex = 0;
+  while (offset < file.size) {
+    const chunkString = await readFileSlice(
+      file,
+      offset,
+      effectiveChunkSize,
+      binary,
+      chunkIndex === 0
+    );
+    const hash = core.keccak256HashString(chunkString);
+    const compressedChunks = chunkDataForStorage(chunkString);
+    yield {
+      chunkIndex,
+      hash,
+      compressedChunks
+    };
+    offset += effectiveChunkSize;
+    chunkIndex++;
+  }
+  if (chunkIndex === 0) {
+    const emptyString = binary ? `data:${file.type || "application/octet-stream"};base64,` : "";
+    const hash = core.keccak256HashString(emptyString);
+    const compressedChunks = chunkDataForStorage(emptyString);
+    yield {
+      chunkIndex: 0,
+      hash,
+      compressedChunks
+    };
+  }
+}
+async function processFileStreamingComplete(file, onProgress) {
+  const totalChunks = Math.max(1, Math.ceil(file.size / STREAMING_CHUNK_SIZE));
+  const hashes = [];
+  const allCompressedChunks = [];
+  const binary = isBinaryFile(file);
+  let processed = 0;
+  for await (const result of processFileStreaming(file)) {
+    hashes.push(result.hash);
+    allCompressedChunks.push(result.compressedChunks);
+    processed++;
+    onProgress?.(processed, totalChunks);
+  }
+  return {
+    hashes,
+    allCompressedChunks,
+    totalChunks: hashes.length,
+    isBinary: binary
+  };
+}
+function estimateChunkCount(fileSize, isBinary = true) {
+  const chunkSize = isBinary ? BINARY_CHUNK_SIZE : STREAMING_CHUNK_SIZE;
+  return Math.max(1, Math.ceil(fileSize / chunkSize));
+}
 
 exports.CHUNKED_STORAGE_CONTRACT = CHUNKED_STORAGE_CONTRACT;
 exports.CHUNKED_STORAGE_READER_CONTRACT = CHUNKED_STORAGE_READER_CONTRACT;
@@ -2227,6 +1788,7 @@ exports.containsXmlReferences = containsXmlReferences;
 exports.detectFileTypeFromBase64 = detectFileTypeFromBase64;
 exports.detectStorageType = detectStorageType;
 exports.encodeStorageKeyForUrl = encodeStorageKeyForUrl;
+exports.estimateChunkCount = estimateChunkCount;
 exports.fileToDataUri = fileToDataUri;
 exports.formatStorageKeyForDisplay = formatStorageKeyForDisplay;
 exports.generateStorageEmbedTag = generateStorageEmbedTag;
@@ -2235,18 +1797,15 @@ exports.generateXmlMetadataWithSource = generateXmlMetadataWithSource;
 exports.getChunkCount = getChunkCount;
 exports.getReferenceKey = getReferenceKey;
 exports.getStorageKeyBytes = getStorageKeyBytes;
+exports.isBinaryFile = isBinaryFile;
 exports.parseNetReferences = parseNetReferences;
 exports.processDataForStorage = processDataForStorage;
+exports.processFileStreaming = processFileStreaming;
+exports.processFileStreamingComplete = processFileStreamingComplete;
+exports.readFileSlice = readFileSlice;
 exports.resolveOperator = resolveOperator;
 exports.resolveXmlRecursive = resolveXmlRecursive;
 exports.shouldSuggestXmlStorage = shouldSuggestXmlStorage;
-exports.useBulkStorage = useBulkStorage;
-exports.useStorage = useStorage;
-exports.useStorageForOperator = useStorageForOperator;
-exports.useStorageForOperatorAndKey = useStorageForOperatorAndKey;
-exports.useStorageFromRouter = useStorageFromRouter;
-exports.useStorageTotalWrites = useStorageTotalWrites;
-exports.useXmlStorage = useXmlStorage;
 exports.validateDataSize = validateDataSize;
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map