@shelby-protocol/sdk 0.0.1-experimental.1 → 0.0.1-experimental.3

package/README.md

@@ -7,9 +7,6 @@ A TypeScript SDK providing core encoding and decoding utilities for both Node.js
 ```bash
 # Installing the shelby sdk
 pnpm install @shelby-protocol/sdk @aptos-labs/ts-sdk
-
-# If you plan to use the Node.js entrypoint, also install its peer dependencies:
-pnpm install fs-extra glob node-fetch yaml
 ```
 
 ## Usage
@@ -36,15 +33,6 @@ import { ShelbyBlob } from '@shelby-protocol/sdk/browser';
 
 - `@aptos-labs/ts-sdk`
 
-When using the **Node.js** entrypoint (`@shelby-protocol/sdk/node`), make sure you have the following installed in your project:
-
-- `fs-extra`
-- `glob`
-- `node-fetch`
-- `yaml`
-
-These are marked as **peerDependencies** and are **optional** for browser usage.
-
 ## Scripts
 
 ```bash

package/dist/browser/index.d.ts

@@ -1,10 +1,14 @@
-export { BlobCommitments, BlobCommitmentsSchema, ChunksetCommitment, ChunksetCommitmentSchema } from '../core/commitments.js';
-export { BlobName, BlobNameSchema, ChunkKey, allChunksForBlob, roundSize } from '../core/layout.js';
+export { ShelbyBlob, createBlobKey } from '../core/blobs.js';
+export { ShelbyBlobClient } from '../core/clients/ShelbyBlobClient.js';
+export { ShelbyClient } from '../core/clients/ShelbyClient.js';
+export { ShelbyClientConfig } from '../core/clients/ShelbyClientConfig.js';
+export { ShelbyRPCClient } from '../core/clients/ShelbyRPCClient.js';
+export { BlobCommitments, BlobCommitmentsSchema, ChunksetCommitment, ChunksetCommitmentSchema, generateCommitments } from '../core/commitments.js';
 export { CHUNKSET_SIZE_BYTES, DEFAULT_PROJECT_DESCRIPTION, DEFAULT_PROJECT_NAME, DEFAULT_SHELBY_BASE_URL, ERASURE_K, ERASURE_M, SHELBY_DEPLOYER, TOKEN_DEPLOYER, TOKEN_OBJECT_ADDRESS, getChunkSizeBytes, getChunksetSizeBytes } from '../core/constants.js';
+export { erasureEncode } from '../core/erasure.js';
+export { BlobName, BlobNameSchema, ChunkKey, allChunksForBlob, roundSize } from '../core/layout.js';
 export { BlobChunk, BlobEncoding, BlobMetadata, ChunkLocation, ClayEncoding, PendingChunkLocation, SignedChunkCommitment, StoredChunkLocation } from '../core/types/blobs.js';
 export { EncodingOptions } from '../core/types/encodings.js';
-export { ShelbyBlob, createBlobKey } from '../core/blobs.js';
-export { ShelbyClient, ShelbyClientConfig } from '../core/ShelbyClient.js';
-import 'zod';
+export { concatHashes, readInChunks, zeroPadBuffer } from '../core/utils.js';
 import '@aptos-labs/ts-sdk';
-import 'node:stream';
+import 'zod';

package/dist/browser/index.mjs

@@ -1,17 +1,33 @@
-import "../chunk-PZPMURE4.mjs";
+import "../chunk-PLUDE5C3.mjs";
 import "../chunk-MWDW4ROU.mjs";
 import "../chunk-ZHXCVRZX.mjs";
 import "../chunk-IHTPXUYI.mjs";
+import "../chunk-QKT5R735.mjs";
 import {
   ShelbyClient
-} from "../chunk-YV67F5NY.mjs";
+} from "../chunk-RYJCDQEK.mjs";
+import {
+  ShelbyBlobClient
+} from "../chunk-B3CB2YEO.mjs";
+import {
+  ShelbyRPCClient
+} from "../chunk-IAHEBEM6.mjs";
 import {
   createBlobKey
 } from "../chunk-QEMIORTL.mjs";
 import {
   BlobCommitmentsSchema,
-  ChunksetCommitmentSchema
-} from "../chunk-NPM7WXK3.mjs";
+  ChunksetCommitmentSchema,
+  generateCommitments
+} from "../chunk-G263DBCY.mjs";
+import {
+  concatHashes,
+  readInChunks,
+  zeroPadBuffer
+} from "../chunk-5Z3RVWU3.mjs";
+import {
+  erasureEncode
+} from "../chunk-P7BVGLTV.mjs";
 import {
   BlobNameSchema,
   ChunkKey,
@@ -31,6 +47,7 @@ import {
   getChunkSizeBytes,
   getChunksetSizeBytes
 } from "../chunk-D2FERD4A.mjs";
+import "../chunk-I6NG5GNL.mjs";
 import "../chunk-7P6ASYW6.mjs";
 export {
   BlobCommitmentsSchema,
@@ -44,12 +61,19 @@ export {
   ERASURE_K,
   ERASURE_M,
   SHELBY_DEPLOYER,
+  ShelbyBlobClient,
   ShelbyClient,
+  ShelbyRPCClient,
   TOKEN_DEPLOYER,
   TOKEN_OBJECT_ADDRESS,
   allChunksForBlob,
+  concatHashes,
   createBlobKey,
+  erasureEncode,
+  generateCommitments,
   getChunkSizeBytes,
   getChunksetSizeBytes,
-  roundSize
+  readInChunks,
+  roundSize,
+  zeroPadBuffer
 };

package/dist/chunk-5Z3RVWU3.mjs

@@ -0,0 +1,67 @@
+// src/core/utils.ts
+import { Hex } from "@aptos-labs/ts-sdk";
+async function* readInChunks(input, chunkSize) {
+  let idx = 0;
+  if (Buffer.isBuffer(input)) {
+    for (let offset = 0; offset < input.length; offset += chunkSize) {
+      yield [idx++, Buffer.from(input.subarray(offset, offset + chunkSize))];
+    }
+    return;
+  }
+  const reader = input.getReader();
+  let buffer = new Uint8Array(chunkSize);
+  let bufferWriteOffset = 0;
+  try {
+    while (true) {
+      const { value, done } = await reader.read();
+      if (done) break;
+      if (value === void 0) continue;
+      let srcOffset = 0;
+      while (srcOffset < value.length) {
+        const remainingCapacity = chunkSize - bufferWriteOffset;
+        const bytesToCopy = Math.min(
+          remainingCapacity,
+          value.length - srcOffset
+        );
+        buffer.set(
+          value.subarray(srcOffset, srcOffset + bytesToCopy),
+          bufferWriteOffset
+        );
+        bufferWriteOffset += bytesToCopy;
+        srcOffset += bytesToCopy;
+        if (bufferWriteOffset >= chunkSize) {
+          yield [idx++, Buffer.from(buffer)];
+          buffer = new Uint8Array(chunkSize);
+          bufferWriteOffset = 0;
+        }
+      }
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  if (bufferWriteOffset > 0) {
+    yield [idx++, Buffer.from(buffer.subarray(0, bufferWriteOffset))];
+  }
+}
+function zeroPadBuffer(buffer, desiredLength) {
+  if (buffer.length >= desiredLength) {
+    return buffer;
+  }
+  const paddedBuffer = Buffer.alloc(desiredLength);
+  buffer.copy(paddedBuffer);
+  return paddedBuffer;
+}
+async function concatHashes(parts) {
+  const combined = Buffer.concat(
+    parts.map((part) => Hex.fromHexInput(part).toUint8Array())
+  );
+  return Hex.fromHexInput(
+    new Uint8Array(await crypto.subtle.digest("SHA-256", combined))
+  );
+}
+
+export {
+  readInChunks,
+  zeroPadBuffer,
+  concatHashes
+};

package/dist/{chunk-EFE5Y7IE.mjs → chunk-B3CB2YEO.mjs}

@@ -1,6 +1,3 @@
-import {
-  generateCommitments
-} from "./chunk-VLLCOFH7.mjs";
 import {
   createBlobKey
 } from "./chunk-QEMIORTL.mjs";
@@ -8,8 +5,7 @@ import {
   SHELBY_DEPLOYER
 } from "./chunk-D2FERD4A.mjs";
 
-// src/node/clients/ShelbyBlobClient.ts
-import { Readable } from "stream";
+// src/core/clients/ShelbyBlobClient.ts
 import {
   AccountAddress,
   Aptos,
@@ -34,7 +30,7 @@ var ShelbyBlobClient = class _ShelbyBlobClient {
    */
   constructor(config) {
     this.aptos = new Aptos(config.aptos.config);
-    this.deployer = config.shelbyDeployer ?? AccountAddress.fromString(SHELBY_DEPLOYER);
+    this.deployer = config.shelby?.deployer ?? AccountAddress.fromString(SHELBY_DEPLOYER);
   }
   /**
    * Retrieves the blob metadata from the blockchain. If it does not exist,
@@ -181,7 +177,7 @@ var ShelbyBlobClient = class _ShelbyBlobClient {
    *
    * @example
    * ```typescript
-   * const blobCommitments = await generateCommitments(Readable.from(data));
+   * const blobCommitments = await generateCommitments(data);
    *
    * const { blobCommitments, transaction } = await client.writeBlobCommitments({
    *   signer,
@@ -192,16 +188,7 @@ var ShelbyBlobClient = class _ShelbyBlobClient {
    * ```
    */
   async writeBlobCommitments(params) {
-    let blobCommitments;
-    if ("blobCommitments" in params) {
-      blobCommitments = params.blobCommitments;
-    } else {
-      blobCommitments = await generateCommitments(
-        Readable.from(params.blobData),
-        void 0,
-        params.options?.encoding
-      );
-    }
+    const blobCommitments = params.blobCommitments;
     const transaction = await this.aptos.transaction.build.simple({
       ...params.options?.build,
       data: _ShelbyBlobClient.createWriteBlobCommitmentsPayload({

package/dist/chunk-G263DBCY.mjs

@@ -0,0 +1,105 @@
+import {
+  concatHashes,
+  readInChunks,
+  zeroPadBuffer
+} from "./chunk-5Z3RVWU3.mjs";
+import {
+  erasureEncode
+} from "./chunk-P7BVGLTV.mjs";
+import {
+  roundSize
+} from "./chunk-GGYTHP5F.mjs";
+import {
+  ERASURE_K,
+  ERASURE_M,
+  getChunksetSizeBytes
+} from "./chunk-D2FERD4A.mjs";
+
+// src/core/commitments.ts
+import { z } from "zod";
+var ChunksetCommitmentSchema = z.object({
+  // Chunkset root (vector commitment of child chunks)
+  chunkset_root: z.string().nullable(),
+  // the size is known statically from the current configuration
+  chunk_commitments: z.array(z.string())
+}).refine(
+  (data) => {
+    return data.chunk_commitments.length === ERASURE_K + ERASURE_M;
+  },
+  {
+    message: `Chunkset must have exactly ${ERASURE_K + ERASURE_M} chunks (ERASURE_K + ERASURE_M = ${ERASURE_K} + ${ERASURE_M})`,
+    path: ["chunk_commitments"]
+  }
+);
+function expectedTotalChunksets(rawSize) {
+  return roundSize(rawSize) / getChunksetSizeBytes();
+}
+var BlobCommitmentsSchema = z.object({
+  schema_version: z.string(),
+  raw_data_size: z.number(),
+  // FIXME I am not sure about this being here, or if it should be somewhere else
+  blob_merkle_root: z.string(),
+  chunkset_commitments: z.array(ChunksetCommitmentSchema)
+}).refine(
+  (data) => {
+    return expectedTotalChunksets(data.raw_data_size) === data.chunkset_commitments.length;
+  },
+  {
+    message: "Total chunkset count mismatches with raw data size",
+    // FIXME put more details in here
+    path: ["chunkset_commitments"]
+  }
+);
+async function generateCommitments(fullData, onChunk, options) {
+  const chunksetCommitments = [];
+  const chunksetCommitmentHashes = [];
+  let rawDataSize = 0;
+  const chunksetGen = readInChunks(
+    fullData,
+    options?.chunksetSize ?? getChunksetSizeBytes()
+  );
+  for await (const [chunksetIdx, chunksetData] of chunksetGen) {
+    const chunkCommitments = [];
+    rawDataSize += chunksetData.length;
+    const paddedChunksetData = zeroPadBuffer(
+      chunksetData,
+      options?.chunksetSize ?? getChunksetSizeBytes()
+    );
+    const chunks = await erasureEncode(
+      paddedChunksetData,
+      options?.erasureK ?? ERASURE_K,
+      options?.erasureM ?? ERASURE_M
+    );
+    let chunkIdx = 0;
+    for (const chunkData of chunks) {
+      if (onChunk !== void 0) {
+        await onChunk(chunksetIdx, chunkIdx, chunkData);
+      }
+      const chunkHash = await concatHashes([chunkData]);
+      chunkCommitments.push(chunkHash);
+      chunkIdx += 1;
+    }
+    const h = await concatHashes(
+      chunkCommitments.map((chunk) => chunk.toUint8Array())
+    );
+    chunksetCommitments.push({
+      chunkset_root: h.toString(),
+      chunk_commitments: chunkCommitments.map((chunk) => chunk.toString())
+    });
+    chunksetCommitmentHashes.push(h);
+  }
+  return {
+    schema_version: "1.3",
+    raw_data_size: rawDataSize,
+    blob_merkle_root: (await concatHashes(
+      chunksetCommitmentHashes.map((chunk) => chunk.toUint8Array())
+    )).toString(),
+    chunkset_commitments: chunksetCommitments
+  };
+}
+
+export {
+  ChunksetCommitmentSchema,
+  BlobCommitmentsSchema,
+  generateCommitments
+};

package/dist/chunk-HMKVGTZV.mjs

@@ -0,0 +1,11 @@
+import {
+  ShelbyClient
+} from "./chunk-RYJCDQEK.mjs";
+
+// src/node/clients/ShelbyNodeClient.ts
+var ShelbyNodeClient = class extends ShelbyClient {
+};
+
+export {
+  ShelbyNodeClient
+};

package/dist/{chunk-DBTBUKCW.mjs → chunk-IAHEBEM6.mjs}

@@ -1,20 +1,20 @@
-import {
-  ShelbyClient
-} from "./chunk-YV67F5NY.mjs";
 import {
   BlobNameSchema
 } from "./chunk-GGYTHP5F.mjs";
+import {
+  DEFAULT_SHELBY_BASE_URL
+} from "./chunk-D2FERD4A.mjs";
 import {
   sleep
 } from "./chunk-I6NG5GNL.mjs";
 
-// src/node/clients/ShelbyRPCClient.ts
-import { Readable, Transform } from "stream";
+// src/core/clients/ShelbyRPCClient.ts
 import { AccountAddress } from "@aptos-labs/ts-sdk";
 function encodeURIComponentKeepSlashes(str) {
   return encodeURIComponent(str).replace(/%2F/g, "/");
 }
-var ShelbyRPCClient = class extends ShelbyClient {
+var ShelbyRPCClient = class {
+  baseUrl;
   /**
    * The ShelbyRPCClient is used to interact with the Shelby RPC node. This
    * includes functions like uploading blobs after they have been committed to the
@@ -25,19 +25,18 @@ var ShelbyRPCClient = class extends ShelbyClient {
    *
    * @example
    * ```typescript
-   * const aptos = new Aptos(new AptosConfig({ network: Network.DEVNET }));
+   * const aptos = new Aptos(new AptosConfig({ network: Network.TESTNET }));
    * const client = new ShelbyRPCClient({ aptos, shelby: { baseUrl: "https://api.shelby.dev" } });
    * ```
    */
-  // biome-ignore lint/complexity/noUselessConstructor: Add JSDoc
   constructor(config) {
-    super(config);
+    this.baseUrl = config.shelby?.baseUrl ?? DEFAULT_SHELBY_BASE_URL;
   }
   async #uploadPart(uploadId, partIdx, partData) {
     const nRetries = 5;
     for (let i = 0; i < nRetries; ++i) {
       const partResponse = await fetch(
-        `${this.baseUrl}/api/v1/multipartUpload/uploadPart/${uploadId}/${partIdx}`,
+        `${this.baseUrl}/v1/multipart-uploads/${uploadId}/parts/${partIdx}`,
         {
           method: "PUT",
           headers: {
@@ -55,25 +54,22 @@ var ShelbyRPCClient = class extends ShelbyClient {
     throw new Error(`Failed to upload part ${partIdx}.`);
   }
   async #putBlobMultipart(account, blobName, blobData, partSize = 5 * 1024 * 1024) {
-    const startResponse = await fetch(
-      `${this.baseUrl}/api/v1/multipartUpload/start`,
-      {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify({
-          rawAccount: account.toString(),
-          rawBlobName: blobName,
-          rawPartSize: partSize
-        })
-      }
-    );
+    const startResponse = await fetch(`${this.baseUrl}/v1/multipart-uploads`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        rawAccount: account.toString(),
+        rawBlobName: blobName,
+        rawPartSize: partSize
+      })
+    });
     if (!startResponse.ok) {
       let errorBodyText = "Could not read error body";
       try {
         errorBodyText = await startResponse.text();
-      } catch (e) {
+      } catch (_e) {
       }
       throw new Error(
         `Failed to start multipart upload! status: ${startResponse.status}, body: ${errorBodyText}`
@@ -84,11 +80,11 @@ var ShelbyRPCClient = class extends ShelbyClient {
     for (let partIdx = 0; partIdx < totalParts; partIdx++) {
       const start = partIdx * partSize;
       const end = Math.min(start + partSize, blobData.length);
-      const partData = blobData.subarray(start, end);
+      const partData = blobData.slice(start, end);
       await this.#uploadPart(uploadId, partIdx, partData);
     }
     const completeResponse = await fetch(
-      `${this.baseUrl}/api/v1/multipartUpload/complete/${uploadId}`,
+      `${this.baseUrl}/v1/multipart-uploads/${uploadId}/complete`,
       {
         method: "POST",
         headers: {
@@ -100,7 +96,7 @@ var ShelbyRPCClient = class extends ShelbyClient {
       let errorBodyText = "Could not read error body";
       try {
         errorBodyText = await completeResponse.text();
-      } catch (e) {
+      } catch (_e) {
       }
       throw new Error(
         `Failed to complete multipart upload! status: ${completeResponse.status}, body: ${errorBodyText}`
@@ -117,7 +113,7 @@ var ShelbyRPCClient = class extends ShelbyClient {
    *
    * @example
    * ```typescript
-   * const blobData = Buffer.from("Hello, world!");
+   * const blobData = new TextEncoder().encode("Hello, world!");
    *
    * await client.putBlob({ account, blobName: "foo/bar.txt", blobData });
    * ```
@@ -186,45 +182,43 @@ var ShelbyRPCClient = class extends ShelbyClient {
         `Invalid content-length header received: ${contentLengthHeader}`
       );
     }
-    let bytesReceived = 0;
-    const reader = response.body.getReader();
-    const sourceStream = new Readable({
-      async read() {
-        try {
-          const { done, value } = await reader.read();
-          if (done) {
-            this.push(null);
-          } else {
-            this.push(Buffer.from(value));
-          }
-        } catch (error) {
-          this.destroy(error);
+    const validatingStream = new ReadableStream({
+      start(controller) {
+        const maybeReader = response.body?.getReader();
+        if (!maybeReader) {
+          controller.error(new Error("Response body reader is unavailable"));
+          return;
         }
-      }
-    });
-    const validationTransform = new Transform({
-      transform(chunk, encoding, callback) {
-        bytesReceived += chunk.length;
-        callback(null, chunk);
-      },
-      flush(callback) {
-        if (bytesReceived !== expectedContentLength) {
-          callback(
-            new Error(
-              `Downloaded data size (${bytesReceived} bytes) does not match content-length header (${expectedContentLength} bytes). This might indicate a partial or corrupted download.`
-            )
-          );
-        } else {
-          callback();
+        const reader = maybeReader;
+        let bytesReceived = 0;
+        function pump() {
+          return reader.read().then(({ done, value }) => {
+            if (done) {
+              if (bytesReceived !== expectedContentLength) {
+                controller.error(
+                  new Error(
+                    `Downloaded data size (${bytesReceived} bytes) does not match content-length header (${expectedContentLength} bytes). This might indicate a partial or corrupted download.`
+                  )
+                );
+                return;
+              }
+              controller.close();
+              return;
+            }
+            bytesReceived += value.byteLength;
+            controller.enqueue(value);
+            return pump();
+          }).catch((error) => {
+            controller.error(error);
+          });
         }
+        return pump();
       }
     });
-    sourceStream.pipe(validationTransform);
     return {
       account: AccountAddress.from(params.account),
       name: params.blobName,
-      readable: response.body,
-      stream: validationTransform,
+      readable: validatingStream,
       contentLength: expectedContentLength
     };
   }

package/dist/chunk-P7BVGLTV.mjs

@@ -0,0 +1,32 @@
+// src/core/erasure.ts
+import { createWasmReedSolomonBinding } from "@shelby-protocol/reed-solomon";
+function erasureEncode(data, k, m) {
+  const rawShardSize = Math.ceil(data.length / k);
+  const shardSize = Math.ceil(rawShardSize / 8) * 8;
+  const dataSize = shardSize * k;
+  const paritySize = shardSize * m;
+  const reedSolomon = createWasmReedSolomonBinding();
+  const dataBuf = Buffer.alloc(dataSize);
+  data.copy(dataBuf, 0);
+  const shards = new Uint8Array(dataSize + paritySize);
+  shards.set(new Uint8Array(dataBuf), 0);
+  reedSolomon.encode(shards, k, m);
+  const res = [];
+  for (let i = 0; i < k; i++) {
+    res.push(
+      Buffer.from(shards.slice(i * shardSize, i * shardSize + shardSize))
+    );
+  }
+  for (let j = 0; j < m; j++) {
+    res.push(
+      Buffer.from(
+        shards.slice((k + j) * shardSize, (k + j) * shardSize + shardSize)
+      )
+    );
+  }
+  return new Promise((resolve) => resolve(res));
+}
+
+export {
+  erasureEncode
+};

package/dist/{chunk-77TSD6TQ.mjs → chunk-RYJCDQEK.mjs}

@@ -1,15 +1,21 @@
 import {
   ShelbyBlobClient
-} from "./chunk-EFE5Y7IE.mjs";
+} from "./chunk-B3CB2YEO.mjs";
 import {
   ShelbyRPCClient
-} from "./chunk-DBTBUKCW.mjs";
+} from "./chunk-IAHEBEM6.mjs";
 import {
-  ShelbyClient
-} from "./chunk-YV67F5NY.mjs";
+  generateCommitments
+} from "./chunk-G263DBCY.mjs";
+import {
+  DEFAULT_SHELBY_BASE_URL
+} from "./chunk-D2FERD4A.mjs";
 
-// src/node/clients/ShelbyNodeClient.ts
-var ShelbyNodeClient = class extends ShelbyClient {
+// src/core/clients/ShelbyClient.ts
+import {
+  Aptos
+} from "@aptos-labs/ts-sdk";
+var ShelbyClient = class {
   /**
    * The coordination client is used to interact with the Aptos blockchain which handles the commitments
    * and metadata for blobs.
@@ -21,26 +27,31 @@ var ShelbyNodeClient = class extends ShelbyClient {
    */
   rpc;
   /**
-   * The ShelbyNodeClient is used to interact with the Shelby network.
+   * The configuration for the Shelby client.
+   */
+  config;
+  /**
+   * The Aptos client.
+   */
+  aptos;
+  /**
+   * The base class for Shelby clients
    *
    * @param config.aptos.config - The Aptos config.
    * @param config.shelby.baseUrl - The base URL of the Shelby RPC node. If not provided, the default base URL will be used.
-   * @param config.shelby.deployer - The deployer account address of the Shelby contract. If not provided, the default deployer address will be used.
-   *
-   * @example
-   * ```typescript
-   * const aptos = new Aptos(new AptosConfig({ network: Network.DEVNET }));
-   * const client = new ShelbyNodeClient({ aptos, shelby: { baseUrl: "https://api.shelby.dev" } });
-   * ```
    */
   constructor(config) {
-    super(config);
-    this.coordination = new ShelbyBlobClient({
-      aptos: this.aptos,
-      shelbyDeployer: config.shelby?.deployer
-    });
+    this.config = config;
+    this.aptos = new Aptos(this.config.aptos.config);
+    this.coordination = new ShelbyBlobClient(config);
     this.rpc = new ShelbyRPCClient(config);
   }
+  /**
+   * The base URL for the Shelby RPC node.
+   */
+  get baseUrl() {
+    return this.config.shelby?.baseUrl ?? DEFAULT_SHELBY_BASE_URL;
+  }
   /**
    * Uploads a blob to the Shelby network.
    *
@@ -53,7 +64,15 @@ var ShelbyNodeClient = class extends ShelbyClient {
    * @returns The transaction and generated blob commitments.
    */
   async upload(params) {
-    const { transaction, blobCommitments } = await this.coordination.writeBlobCommitments(params);
+    const generatedBlobCommitments = await generateCommitments(
+      params.blobData,
+      void 0,
+      params.options?.encoding
+    );
+    const { transaction, blobCommitments } = await this.coordination.writeBlobCommitments({
+      ...params,
+      blobCommitments: generatedBlobCommitments
+    });
     const confirmedTransaction = await this.aptos.waitForTransaction({
       transactionHash: transaction.hash
     });
@@ -86,5 +105,5 @@ var ShelbyNodeClient = class extends ShelbyClient {
 };
 
 export {
-  ShelbyNodeClient
+  ShelbyClient
 };