@shelby-protocol/sdk 0.0.8 → 0.1.0

package/dist/chunk-MSCUDBMH.mjs

@@ -0,0 +1,83 @@
+import {
+  getShelbyIndexerClient
+} from "./chunk-3ZL3FSNA.mjs";
+
+// src/core/clients/ShelbyPlacementGroupClient.ts
+var ShelbyPlacementGroupClient = class {
+  indexer;
+  /**
+   * Creates a new ShelbyPlacementGroupClient.
+   *
+   * @param config - The client configuration object.
+   *
+   * @example
+   * ```typescript
+   * const pgClient = new ShelbyPlacementGroupClient({
+   *   network: Network.SHELBYNET,
+   * });
+   * ```
+   */
+  constructor(config) {
+    this.indexer = getShelbyIndexerClient(config);
+  }
+  /**
+   * Retrieves placement group slots from the indexer.
+   *
+   * @param params.where (optional) - The where clause to filter slots by.
+   * @param params.pagination (optional) - The pagination options.
+   * @param params.orderBy (optional) - The order by clause to sort slots by.
+   * @returns The placement group slots that match the filter.
+   *
+   * @example
+   * ```typescript
+   * // Get all active slots
+   * const slots = await client.getPlacementGroupSlots({
+   *   where: { status: { _eq: "active" } },
+   * });
+   * ```
+   */
+  async getPlacementGroupSlots(params) {
+    const { limit, offset } = params.pagination ?? {};
+    const { orderBy, where } = params;
+    const { placement_group_slots } = await this.indexer.getPlacementGroupSlots(
+      {
+        where,
+        limit,
+        offset,
+        orderBy
+      }
+    );
+    return placement_group_slots.map(
+      (slot) => ({
+        placementGroup: slot.placement_group,
+        slotIndex: Number(slot.slot_index),
+        storageProvider: slot.storage_provider,
+        status: slot.status,
+        updatedAt: Number(slot.updated_at)
+      })
+    );
+  }
+  /**
+   * Retrieves the total count of placement group slots from the indexer.
+   *
+   * @param params.where (optional) - The where clause to filter slots by.
+   * @returns The count of placement group slots that match the filter.
+   *
+   * @example
+   * ```typescript
+   * // Get count of active slots
+   * const count = await client.getPlacementGroupSlotsCount({
+   *   where: { status: { _eq: "active" } },
+   * });
+   * ```
+   */
+  async getPlacementGroupSlotsCount(params) {
+    const { where } = params;
+    const { placement_group_slots_aggregate } = await this.indexer.getPlacementGroupSlotsCount({ where });
+    return placement_group_slots_aggregate?.aggregate?.count ?? 0;
+  }
+};
+
+export {
+  ShelbyPlacementGroupClient
+};

package/dist/{chunk-CPNZAQVY.mjs → chunk-OMZOR2ZF.mjs}

@@ -1,6 +1,6 @@
 import {
   ClayErasureCodingProvider
-} from "./chunk-NLPIHQ7K.mjs";
+} from "./chunk-UCDAABAS.mjs";
 import {
   DEFAULT_CHUNK_SIZE_BYTES
 } from "./chunk-67F5YZ25.mjs";
@@ -8,7 +8,7 @@ import {
   DEFAULT_ERASURE_D,
   DEFAULT_ERASURE_K,
   DEFAULT_ERASURE_N
-} from "./chunk-ZPW742E7.mjs";
+} from "./chunk-LZSIZJYR.mjs";
 
 // src/core/erasure/default.ts
 var defaultProviderPromise;

package/dist/{chunk-XWAPNLU6.mjs → chunk-RLRI2533.mjs}

@@ -9,11 +9,12 @@ import {
 import {
   DEFAULT_ERASURE_K,
   DEFAULT_ERASURE_M
-} from "./chunk-ZPW742E7.mjs";
+} from "./chunk-LZSIZJYR.mjs";
 
 // src/core/commitments.ts
 import { Hex } from "@aptos-labs/ts-sdk";
 import { z } from "zod";
+var COMMITMENT_SCHEMA_VERSION = "1.3";
 var ChunksetCommitmentSchema = z.object({
   // Chunkset root (vector commitment of child chunks)
   chunkset_root: z.string(),
@@ -143,7 +144,7 @@ async function generateCommitments(provider, fullData, onChunk, options) {
     chunksetCommitmentHashes.push(h);
   }
   return {
-    schema_version: "1.3",
+    schema_version: COMMITMENT_SCHEMA_VERSION,
     raw_data_size: rawDataSize,
     blob_merkle_root: (await generateMerkleRoot(chunksetCommitmentHashes)).toString(),
     chunkset_commitments: chunksetCommitments
@@ -159,6 +160,7 @@ function validatePrePaddedChunkset(chunkset, expectedSize, chunksetIdx) {
 }
 
 export {
+  COMMITMENT_SCHEMA_VERSION,
   ChunksetCommitmentSchema,
   expectedTotalChunksets,
   BlobCommitmentsSchema,

package/dist/{chunk-NLPIHQ7K.mjs → chunk-UCDAABAS.mjs}

@@ -5,7 +5,7 @@ import {
   DEFAULT_ERASURE_D,
   DEFAULT_ERASURE_K,
   DEFAULT_ERASURE_N
-} from "./chunk-ZPW742E7.mjs";
+} from "./chunk-LZSIZJYR.mjs";
 
 // src/core/erasure/clay-codes.ts
 import {

package/dist/{chunk-GY5DCVVL.mjs → chunk-W5NRGZEP.mjs}

@@ -5,7 +5,7 @@ import {
 import {
   DEFAULT_ERASURE_K,
   DEFAULT_ERASURE_N
-} from "./chunk-ZPW742E7.mjs";
+} from "./chunk-LZSIZJYR.mjs";
 
 // src/core/layout.ts
 import { AccountAddress } from "@aptos-labs/ts-sdk";

package/dist/{chunk-MGAN2SBA.mjs → chunk-W6YL46DT.mjs}

@@ -1,24 +1,24 @@
-import {
-  ShelbyRPCClient
-} from "./chunk-QRGZJBAG.mjs";
 import {
   ShelbyBlobClient
-} from "./chunk-BBOG5JSX.mjs";
-import {
-  getAptosConfig
-} from "./chunk-RBFWGDMY.mjs";
+} from "./chunk-AGRRYZWV.mjs";
 import {
   ClayErasureCodingProvider
-} from "./chunk-NLPIHQ7K.mjs";
+} from "./chunk-UCDAABAS.mjs";
+import {
+  ShelbyRPCClient
+} from "./chunk-ZAM2EUVN.mjs";
+import {
+  getAptosConfig
+} from "./chunk-AABBONAF.mjs";
 import {
   createBlobKey
 } from "./chunk-OTBLZL2S.mjs";
 import {
   generateCommitments
-} from "./chunk-XWAPNLU6.mjs";
+} from "./chunk-RLRI2533.mjs";
 import {
   NetworkToShelbyRPCBaseUrl
-} from "./chunk-SEXQTDX6.mjs";
+} from "./chunk-FLLOQZVD.mjs";
 
 // src/core/clients/ShelbyClient.ts
 import {
@@ -109,6 +109,11 @@ var ShelbyClient = class {
    * This method handles the complete upload flow including commitment generation,
    * blockchain registration, and storage upload.
    *
+   * Note: This method accepts only `Uint8Array` and buffers the entire blob in memory.
+   * For streaming uploads of large files (e.g. >2 GiB), orchestrate the steps manually
+   * using `generateCommitments()`, `coordination.registerBlob()`, and `rpc.putBlob()`
+   * with a `ReadableStream`.
+   *
    * @param params.blobData - The raw data to upload as a Uint8Array.
    * @param params.signer - The account that signs and pays for the transaction.
    * @param params.blobName - The name/path of the blob (e.g. "folder/file.txt").
@@ -145,7 +150,8 @@ var ShelbyClient = class {
         blobName: params.blobName,
         blobMerkleRoot: blobCommitments.blob_merkle_root,
         size: params.blobData.length,
-        expirationMicros: params.expirationMicros
+        expirationMicros: params.expirationMicros,
+        options: params.options
       });
       await this.coordination.aptos.waitForTransaction({
         transactionHash: pendingRegisterBlobTransaction.hash
@@ -162,6 +168,11 @@ var ShelbyClient = class {
    * This method handles the complete upload flow including commitment generation,
    * blockchain registration, and storage upload.
    *
+   * Note: This method accepts only `Uint8Array` and buffers each blob in memory.
+   * For streaming uploads of large files, orchestrate the steps manually using
+   * `generateCommitments()`, `coordination.registerBlob()`, and `rpc.putBlob()`
+   * with a `ReadableStream`.
+   *
    * @param params.blobs - The blobs to upload.
    * @param params.blobs.blobData - The raw data to upload as a Uint8Array.
    * @param params.blobs.blobName - The name/path of the blob (e.g. "folder/file.txt").
@@ -279,7 +290,8 @@ var ShelbyClient = class {
   async fundAccountWithShelbyUSD(params) {
     const { address, amount } = params;
     try {
-      const faucet = this.config.faucet ?? "https://faucet.shelbynet.shelby.xyz/fund?asset=shelbyusd";
+      const faucet = this.config.faucet?.baseUrl ?? "https://faucet.shelbynet.shelby.xyz/fund?asset=shelbyusd";
+      const authToken = this.config.faucet?.authToken;
       const response = await fetch(`${faucet}`, {
         method: "POST",
         body: JSON.stringify({
@@ -287,11 +299,13 @@ var ShelbyClient = class {
           amount
         }),
         headers: {
-          "Content-Type": "application/json"
+          "Content-Type": "application/json",
+          ...authToken ? { Authorization: `Bearer ${authToken}` } : {}
         }
       });
       if (!response.ok) {
-        throw new Error("Failed to fund account");
+        const errorBody = await response.text();
+        throw new Error(`Failed to fund account: ${errorBody}`);
       }
       const json = await response.json();
       const res = await this.aptos.waitForTransaction({

package/dist/{chunk-CTGCK3H2.mjs → chunk-YZXIPUVQ.mjs}

@@ -1,9 +1,9 @@
 import {
   getAptosConfig
-} from "./chunk-RBFWGDMY.mjs";
+} from "./chunk-AABBONAF.mjs";
 import {
   SHELBY_DEPLOYER
-} from "./chunk-SEXQTDX6.mjs";
+} from "./chunk-FLLOQZVD.mjs";
 
 // src/node/clients/ShelbyMetadataClient.ts
 import {
@@ -11,6 +11,29 @@ import {
   Aptos,
   Hex
 } from "@aptos-labs/ts-sdk";
+function parseStorageProviderState(raw) {
+  switch (raw.variant) {
+    case "Active":
+      return {
+        variant: "Active",
+        quota: raw.Active.quota.value,
+        stakeAtStartOfStakingEpoch: raw.Active.stake_at_start_of_staking_epoch,
+        faulty: raw.Active.faulty,
+        leaving: raw.Active.leaving
+      };
+    case "Waitlisted":
+      return {
+        variant: "Waitlisted"
+      };
+    case "Frozen":
+      return {
+        variant: "Frozen",
+        frozenReason: raw.Frozen.frozen_reason,
+        frozenFrom: raw.Frozen.frozen_from,
+        frozenTill: raw.Frozen.frozen_till
+      };
+  }
+}
 var ShelbyMetadataClient = class {
   aptos;
   deployer;
@@ -45,7 +68,7 @@ var ShelbyMetadataClient = class {
     try {
       const rawMetadata = await this.aptos.view({
         payload: {
-          function: `${this.deployer.toString()}::global_metadata::get_all_storage_providers`,
+          function: `${this.deployer.toString()}::storage_provider_registry::get_all_storage_providers`,
           functionArguments: []
         }
       });
@@ -55,7 +78,8 @@ var ShelbyMetadataClient = class {
         ipAddress: provider.ip_address,
         port: provider.port,
         blsPublicKey: Hex.fromHexInput(provider.bls_public_key).toUint8Array(),
-        failureDomain: provider.failure_domain
+        failureDomain: provider.failure_domain,
+        state: parseStorageProviderState(provider.state)
       }));
     } catch (error) {
       if (error instanceof Error && // Depending on the network, the error message may show up differently.
@@ -79,14 +103,14 @@ var ShelbyMetadataClient = class {
     try {
       const pgSizeMetadata = await this.aptos.view({
         payload: {
-          function: `${this.deployer.toString()}::global_metadata::get_number_of_placement_groups`,
+          function: `${this.deployer.toString()}::placement_group_registry::get_number_of_placement_groups`,
           functionArguments: []
         }
       });
       const finalPlacementGroupIndex = pgSizeMetadata[0] - 1;
       const addressMetadataArray = await this.aptos.view({
         payload: {
-          function: `${this.deployer.toString()}::global_metadata::get_placement_group_addresses`,
+          function: `${this.deployer.toString()}::placement_group_registry::get_placement_group_addresses`,
           functionArguments: [0, finalPlacementGroupIndex]
         }
       });
@@ -114,14 +138,14 @@ var ShelbyMetadataClient = class {
     try {
       const sliceSizeMetadata = await this.aptos.view({
         payload: {
-          function: `${this.deployer.toString()}::global_metadata::get_number_of_slices`,
+          function: `${this.deployer.toString()}::slice_registry::get_number_of_slices`,
           functionArguments: []
         }
       });
       const finalSliceIndex = sliceSizeMetadata[0] - 1;
       const addressMetadataArray = await this.aptos.view({
         payload: {
-          function: `${this.deployer.toString()}::global_metadata::get_slice_addresses`,
+          function: `${this.deployer.toString()}::slice_registry::get_slice_addresses`,
           functionArguments: [0, finalSliceIndex]
         }
       });

package/dist/{chunk-QRGZJBAG.mjs → chunk-ZAM2EUVN.mjs}

@@ -1,24 +1,48 @@
+import {
+  StaleChannelStateError
+} from "./chunk-4MG4XGY4.mjs";
+import {
+  getShelbyIndexerClient
+} from "./chunk-3ZL3FSNA.mjs";
+import {
+  BlobNameSchema
+} from "./chunk-W5NRGZEP.mjs";
 import {
   sleep
 } from "./chunk-I6NG5GNL.mjs";
 import {
-  getShelbyIndexerClient
-} from "./chunk-HFGEQP5N.mjs";
+  StaleMicropaymentErrorResponseSchema,
+  StartMultipartUploadResponseSchema
+} from "./chunk-IE6LYVIA.mjs";
 import {
-  buildRequestUrl
+  buildRequestUrl,
+  readInChunks
 } from "./chunk-4JZO2D7T.mjs";
 import {
   NetworkToShelbyRPCBaseUrl
-} from "./chunk-SEXQTDX6.mjs";
-import {
-  BlobNameSchema
-} from "./chunk-GY5DCVVL.mjs";
+} from "./chunk-FLLOQZVD.mjs";
 
 // src/core/clients/ShelbyRPCClient.ts
 import { AccountAddress } from "@aptos-labs/ts-sdk";
+var MICROPAYMENT_HEADER = "X-Shelby-Micropayment";
 function encodeURIComponentKeepSlashes(str) {
   return encodeURIComponent(str).replace(/%2F/g, "/");
 }
+function validateTotalBytes(totalBytes) {
+  if (!Number.isInteger(totalBytes) || totalBytes < 0) {
+    throw new Error("totalBytes must be a non-negative integer");
+  }
+}
+function getErrorCode(error) {
+  if (typeof error === "object" && error !== null && "code" in error && typeof error.code === "string") {
+    return error.code;
+  }
+  if (error instanceof Error) {
+    const match = error.message.match(/\bE[A-Z0-9_]+\b/);
+    return match?.[0];
+  }
+  return void 0;
+}
 var ShelbyRPCClient = class {
   baseUrl;
   apiKey;
@@ -47,30 +71,53 @@ var ShelbyRPCClient = class {
   }
   async #uploadPart(uploadId, partIdx, partData) {
     const nRetries = 5;
+    let lastResponse;
+    let lastError;
+    const partUrl = buildRequestUrl(
+      `/v1/multipart-uploads/${uploadId}/parts/${partIdx}`,
+      this.baseUrl
+    );
     for (let i = 0; i < nRetries; ++i) {
-      const partResponse = await fetch(
-        buildRequestUrl(
-          `/v1/multipart-uploads/${uploadId}/parts/${partIdx}`,
-          this.baseUrl
-        ),
-        {
+      try {
+        lastResponse = await fetch(partUrl, {
           method: "PUT",
           headers: {
             "Content-Type": "application/octet-stream",
             ...this.apiKey ? { Authorization: `Bearer ${this.apiKey}` } : {}
           },
           body: partData
+        });
+        lastError = void 0;
+      } catch (error) {
+        lastError = error;
+        if (i < nRetries - 1) {
+          const delay = 2 ** i * 100;
+          await sleep(delay);
+          continue;
         }
-      );
-      if (partResponse.ok) return;
+        break;
+      }
+      if (lastResponse.ok) return;
       if (i < nRetries - 1) {
         const delay = 2 ** i * 100;
         await sleep(delay);
       }
     }
-    throw new Error(`Failed to upload part ${partIdx}.`);
+    if (lastError !== void 0) {
+      const errorCode = getErrorCode(lastError);
+      const errorMessage = lastError instanceof Error ? lastError.message : String(lastError);
+      throw new Error(
+        `Failed to upload part ${partIdx} for multipart upload ${uploadId} after ${nRetries} attempts. The connection to the Shelby RPC endpoint was interrupted while sending data${errorCode ? ` (${errorCode})` : ""}. Endpoint: ${partUrl.toString()}, partBytes: ${partData.length}. Last error: ${errorMessage}`,
+        { cause: lastError }
+      );
+    }
+    const errorBody = await lastResponse?.text().catch(() => "");
+    throw new Error(
+      `Failed to upload part ${partIdx} for multipart upload ${uploadId} after ${nRetries} attempts. status: ${lastResponse?.status}, body: ${errorBody}`
+    );
   }
-  async #putBlobMultipart(account, blobName, blobData, partSize = 5 * 1024 * 1024) {
+  async #putBlobMultipart(account, blobName, blobData, totalBytes, partSize = 5 * 1024 * 1024, onProgress) {
+    validateTotalBytes(totalBytes);
     const startResponse = await fetch(
       buildRequestUrl("/v1/multipart-uploads", this.baseUrl),
       {
@@ -96,14 +143,38 @@ var ShelbyRPCClient = class {
         `Failed to start multipart upload! status: ${startResponse.status}, body: ${errorBodyText}`
       );
     }
-    const { uploadId } = await startResponse.json();
-    const totalParts = Math.ceil(blobData.length / partSize);
-    for (let partIdx = 0; partIdx < totalParts; partIdx++) {
-      const start = partIdx * partSize;
-      const end = Math.min(start + partSize, blobData.length);
-      const partData = blobData.slice(start, end);
+    const { uploadId } = StartMultipartUploadResponseSchema.parse(
+      await startResponse.json()
+    );
+    const totalParts = Math.ceil(totalBytes / partSize);
+    let uploadedBytes = 0;
+    for await (const [partIdx, partData] of readInChunks(blobData, partSize)) {
       await this.#uploadPart(uploadId, partIdx, partData);
+      uploadedBytes += partData.length;
+      onProgress?.({
+        phase: "uploading",
+        partIdx,
+        totalParts,
+        partBytes: partData.length,
+        uploadedBytes,
+        totalBytes
+      });
+    }
+    if (uploadedBytes !== totalBytes) {
+      throw new Error(
+        `Uploaded bytes (${uploadedBytes}) did not match declared totalBytes (${totalBytes})`
+      );
     }
+    const finalPartIdx = totalParts > 0 ? totalParts - 1 : 0;
+    onProgress?.({
+      phase: "finalizing",
+      partIdx: finalPartIdx,
+      totalParts,
+      // no part uploaded in this phase
+      partBytes: 0,
+      uploadedBytes: totalBytes,
+      totalBytes
+    });
     const completeResponse = await fetch(
       buildRequestUrl(
         `/v1/multipart-uploads/${uploadId}/complete`,
@@ -135,7 +206,8 @@ var ShelbyRPCClient = class {
    *
    * @param params.account - The account that owns the blob.
    * @param params.blobName - The name/path of the blob (e.g. "folder/file.txt").
-   * @param params.blobData - The raw blob data as a Uint8Array.
+   * @param params.blobData - The raw blob data as a Uint8Array or ReadableStream.
+   * @param params.totalBytes - Total byte length. Required for streams; optional for Uint8Array.
    *
    * @example
    * ```typescript
@@ -144,19 +216,38 @@ var ShelbyRPCClient = class {
    * await client.putBlob({
    *   account: AccountAddress.from("0x1"),
    *   blobName: "greetings/hello.txt",
-   *   blobData
+   *   blobData,
    * });
    * ```
    */
   async putBlob(params) {
     BlobNameSchema.parse(params.blobName);
+    let totalBytes;
+    if (params.blobData instanceof Uint8Array) {
+      totalBytes = params.totalBytes ?? params.blobData.length;
+      if (totalBytes !== params.blobData.length) {
+        throw new Error(
+          "totalBytes must match blobData.length when blobData is a Uint8Array"
+        );
+      }
+    } else {
+      if (params.totalBytes === void 0) {
+        throw new Error(
+          "totalBytes is required when blobData is a ReadableStream"
+        );
+      }
+      totalBytes = params.totalBytes;
+    }
+    validateTotalBytes(totalBytes);
     await this.#putBlobMultipart(
       params.account,
       params.blobName,
-      params.blobData
+      params.blobData,
+      totalBytes,
+      void 0,
+      params.onProgress
     );
   }
-  // FIXME make this possible to stream in put ^^^
   /**
    * Downloads a blob from the Shelby RPC node.
    * Returns a streaming response with validation to ensure data integrity.
@@ -166,10 +257,12 @@ var ShelbyRPCClient = class {
    * @param params.range - Optional byte range for partial downloads.
    * @param params.range.start - Starting byte position (inclusive).
    * @param params.range.end - Ending byte position (inclusive, optional).
+   * @param params.micropayment - Optional micropayment to attach to the request.
    *
    * @returns A ShelbyBlob object containing the account, name, readable stream, and content length.
    *
    * @throws Error if the download fails or content length doesn't match.
+   * @throws StaleChannelStateError if the micropayment is stale (server has newer state).
    *
    * @example
    * ```typescript
@@ -185,6 +278,13 @@ var ShelbyRPCClient = class {
    *   blobName: "large-file.bin",
    *   range: { start: 100, end: 199 }
    * });
+   *
+   * // Download with micropayment
+   * const blob = await client.getBlob({
+   *   account: AccountAddress.from("0x1"),
+   *   blobName: "documents/report.pdf",
+   *   micropayment: senderBuiltMicropayment
+   * });
    * ```
    */
   async getBlob(params) {
@@ -195,9 +295,8 @@ var ShelbyRPCClient = class {
       )}`,
       this.baseUrl
     );
-    const requestInit = {};
+    const headers = new Headers();
     if (params.range !== void 0) {
-      const headers = new Headers();
       const { start, end } = params.range;
       if (end === void 0) {
         headers.set("Range", `bytes=${start}-`);
@@ -207,15 +306,45 @@ var ShelbyRPCClient = class {
         }
         headers.set("Range", `bytes=${start}-${end}`);
       }
-      requestInit.headers = headers;
     }
-    const response = await fetch(url, {
-      ...requestInit,
-      headers: {
-        ...requestInit.headers,
-        ...this.apiKey ? { Authorization: `Bearer ${this.apiKey}` } : {}
+    if (this.apiKey) {
+      headers.set("Authorization", `Bearer ${this.apiKey}`);
+    }
+    if (params.micropayment) {
+      const bytes = params.micropayment.bcsToBytes();
+      const binaryString = Array.from(
+        bytes,
+        (byte) => String.fromCharCode(byte)
+      ).join("");
+      headers.set(MICROPAYMENT_HEADER, btoa(binaryString));
+    }
+    const response = await fetch(url, { headers });
+    if (response.status === 409) {
+      let json;
+      try {
+        json = await response.json();
+      } catch {
+        throw new Error(
+          `Failed to download blob: ${response.status} ${response.statusText}`
+        );
       }
-    });
+      const parseResult = StaleMicropaymentErrorResponseSchema.safeParse(json);
+      if (!parseResult.success) {
+        throw new Error(
+          `Failed to download blob: ${response.status} ${response.statusText}`
+        );
+      }
+      const errorBody = parseResult.data;
+      if (errorBody.storedMicropayment) {
+        throw StaleChannelStateError.fromBase64(
+          errorBody.storedMicropayment,
+          errorBody.error
+        );
+      }
+      throw new Error(
+        errorBody.error ?? `Failed to download blob: ${response.status} ${response.statusText}`
+      );
+    }
     if (!response.ok) {
       throw new Error(
         `Failed to download blob: ${response.status} ${response.statusText}`

package/dist/core/chunk.mjs

@@ -5,7 +5,7 @@ import {
   DEFAULT_CHUNK_SIZE_BYTES,
   ERASURE_CODE_AND_CHUNK_MAPPING
 } from "../chunk-67F5YZ25.mjs";
-import "../chunk-ZPW742E7.mjs";
+import "../chunk-LZSIZJYR.mjs";
 import "../chunk-7P6ASYW6.mjs";
 export {
   CHUNK_SIZE_PARAMS,