@shelby-protocol/cli 0.0.19 → 0.0.20

package/bin/entry.js

@@ -505,7 +505,7 @@ import { Command } from "@commander-js/extra-typings";
 
 // package.json
 var name = "@shelby-protocol/cli";
-var version = "0.0.19";
+var version = "0.0.20";
 
 // src/commands/account.tsx
 import readline from "readline";
@@ -569,6 +569,93 @@ import {
   Hex
 } from "@aptos-labs/ts-sdk";
 
+// ../../packages/sdk/dist/chunk-4MG4XGY4.mjs
+import {
+  AccountAuthenticator,
+  Deserializer,
+  Hex as Hex2,
+  MultiAgentTransaction,
+  Serializer
+} from "@aptos-labs/ts-sdk";
+var StaleChannelStateError = class _StaleChannelStateError extends Error {
+  /**
+   * The last valid micropayment stored by the server.
+   * Clients can use this to reset their local channel state.
+   */
+  storedMicropayment;
+  constructor(storedMicropayment, message) {
+    super(
+      message ?? "Client has stale channel state. Use the returned micropayment to reset local state."
+    );
+    this.name = "StaleChannelStateError";
+    this.storedMicropayment = storedMicropayment;
+  }
+  /**
+   * Returns the stored micropayment as a base64-encoded string.
+   */
+  toBase64() {
+    const bytes = this.storedMicropayment.bcsToBytes();
+    const binaryString = Array.from(
+      bytes,
+      (byte) => String.fromCharCode(byte)
+    ).join("");
+    return btoa(binaryString);
+  }
+  /**
+   * Creates a StaleChannelStateError from a base64-encoded micropayment string.
+   */
+  static fromBase64(base64, message) {
+    const binaryString = atob(base64);
+    const bytes = Uint8Array.from(binaryString, (char) => char.charCodeAt(0));
+    const micropayment = SenderBuiltMicropayment.deserialize(bytes);
+    return new _StaleChannelStateError(micropayment, message);
+  }
+};
+var SenderBuiltMicropayment = class _SenderBuiltMicropayment {
+  /**
+   * The actual micropayment transaction. It is built with the receiver address as fee payer and also requires a signature from the receiver to submit.
+   */
+  micropayment;
+  /**
+   * The sender's signature.
+   */
+  senderSignature;
+  constructor(micropayment, senderSignature) {
+    this.micropayment = micropayment;
+    this.senderSignature = senderSignature;
+  }
+  serialize(serializer) {
+    this.micropayment.serialize(serializer);
+    this.senderSignature.serialize(serializer);
+  }
+  bcsToBytes() {
+    const serializer = new Serializer();
+    this.serialize(serializer);
+    return serializer.toUint8Array();
+  }
+  bcsToHex() {
+    return Hex2.fromHexInput(this.bcsToBytes());
+  }
+  toStringWithoutPrefix() {
+    return this.bcsToHex().toStringWithoutPrefix();
+  }
+  toString() {
+    return this.bcsToHex().toString();
+  }
+  /**
+   * Deserializes a SenderBuiltMicropayment from BCS bytes.
+   * @param bytes - The bytes to deserialize from (Uint8Array or hex string).
+   * @returns A new SenderBuiltMicropayment instance.
+   */
+  static deserialize(bytes) {
+    const bytesArray = typeof bytes === "string" ? Hex2.fromHexInput(bytes).toUint8Array() : bytes;
+    const deserializer = new Deserializer(bytesArray);
+    const micropayment = MultiAgentTransaction.deserialize(deserializer);
+    const senderSignature = AccountAuthenticator.deserialize(deserializer);
+    return new _SenderBuiltMicropayment(micropayment, senderSignature);
+  }
+};
+
 // ../../node_modules/.pnpm/tslib@2.8.1/node_modules/tslib/tslib.es6.mjs
 var __assign = function() {
   __assign = Object.assign || function __assign2(t) {
@@ -4388,14 +4475,96 @@ function getShelbyIndexerClient(config) {
   });
 }
 
-// ../../packages/sdk/dist/chunk-OTBLZL2S.mjs
-import { AccountAddress as AccountAddress2 } from "@aptos-labs/ts-sdk";
-var createBlobKey = (params) => {
-  return `@${AccountAddress2.from(params.account).toStringLongWithoutPrefix()}/${params.blobName}`;
+// ../../packages/sdk/dist/chunk-67F5YZ25.mjs
+var CHUNK_SIZE_PARAMS = {
+  [
+    "ChunkSet10MiB_Chunk1MiB"
+    /* ChunkSet10MiB_Chunk1MiB */
+  ]: {
+    // 1MiB
+    chunkSizeBytes: 1 * 1024 * 1024,
+    // 10MiB
+    chunksetSizeBytes: 10 * 1024 * 1024
+  }
+};
+var DEFAULT_CHUNK_SIZE_BYTES = CHUNK_SIZE_PARAMS[
+  "ChunkSet10MiB_Chunk1MiB"
+  /* ChunkSet10MiB_Chunk1MiB */
+].chunkSizeBytes;
+var DEFAULT_CHUNKSET_SIZE_BYTES = CHUNK_SIZE_PARAMS[
+  "ChunkSet10MiB_Chunk1MiB"
+  /* ChunkSet10MiB_Chunk1MiB */
+].chunksetSizeBytes;
+var ERASURE_CODE_AND_CHUNK_MAPPING = {
+  [
+    "ClayCode_16Total_10Data_13Helper"
+    /* ClayCode_16Total_10Data_13Helper */
+  ]: {
+    ...CHUNK_SIZE_PARAMS.ChunkSet10MiB_Chunk1MiB
+  }
+};
+
+// ../../packages/sdk/dist/chunk-LZSIZJYR.mjs
+var ERASURE_CODE_PARAMS = {
+  [
+    "ClayCode_16Total_10Data_13Helper"
+    /* ClayCode_16Total_10Data_13Helper */
+  ]: {
+    // total chunks (data + parity)
+    erasure_n: 16,
+    // data chunks
+    erasure_k: 10,
+    // helper nodes
+    erasure_d: 13
+  }
 };
+var DEFAULT_ERASURE_N = ERASURE_CODE_PARAMS[
+  "ClayCode_16Total_10Data_13Helper"
+  /* ClayCode_16Total_10Data_13Helper */
+].erasure_n;
+var DEFAULT_ERASURE_K = ERASURE_CODE_PARAMS[
+  "ClayCode_16Total_10Data_13Helper"
+  /* ClayCode_16Total_10Data_13Helper */
+].erasure_k;
+var DEFAULT_ERASURE_D = ERASURE_CODE_PARAMS[
+  "ClayCode_16Total_10Data_13Helper"
+  /* ClayCode_16Total_10Data_13Helper */
+].erasure_d;
+var DEFAULT_ERASURE_M = DEFAULT_ERASURE_N - DEFAULT_ERASURE_K;
+
+// ../../packages/sdk/dist/chunk-W5NRGZEP.mjs
+import { AccountAddress as AccountAddress2 } from "@aptos-labs/ts-sdk";
+import { z } from "zod";
+var BlobNameSchema = z.string().min(1, "Blob name path parameter cannot be empty.").max(1024, "Blob name cannot exceed 1024 characters.").refine((name2) => !name2.endsWith("/"), {
+  message: "Blob name cannot end with a slash"
+});
+
+// ../../packages/sdk/dist/chunk-I6NG5GNL.mjs
+function sleep(ms) {
+  return new Promise((resolve3) => setTimeout(resolve3, ms));
+}
+
+// ../../packages/sdk/dist/chunk-IE6LYVIA.mjs
+import { z as z2 } from "zod";
+var StartMultipartUploadResponseSchema = z2.object({
+  uploadId: z2.string()
+});
+var UploadPartResponseSchema = z2.object({
+  success: z2.literal(true)
+});
+var CompleteMultipartUploadResponseSchema = z2.object({
+  success: z2.literal(true)
+});
+var RPCErrorResponseSchema = z2.object({
+  error: z2.string()
+});
+var StaleMicropaymentErrorResponseSchema = z2.object({
+  error: z2.string().optional(),
+  storedMicropayment: z2.string().optional()
+});
 
 // ../../packages/sdk/dist/chunk-4JZO2D7T.mjs
-import { Hex as Hex2 } from "@aptos-labs/ts-sdk";
+import { Hex as Hex3 } from "@aptos-labs/ts-sdk";
 async function* readInChunks(input, chunkSize) {
   let idx = 0;
   if (isReadableStream(input)) {
@@ -4455,7 +4624,7 @@ function zeroPadBytes(buffer, desiredLength) {
   return paddedBuffer;
 }
 async function concatHashes(parts) {
-  const chunks = parts.map((part) => Hex2.fromHexInput(part).toUint8Array());
+  const chunks = parts.map((part) => Hex3.fromHexInput(part).toUint8Array());
   const totalLength = chunks.reduce((sum, chunk) => sum + chunk.byteLength, 0);
   const combined = new Uint8Array(totalLength);
   let offset = 0;
@@ -4463,7 +4632,7 @@ async function concatHashes(parts) {
     combined.set(chunk, offset);
     offset += chunk.byteLength;
   }
-  return Hex2.fromHexInput(
+  return Hex3.fromHexInput(
     new Uint8Array(await crypto.subtle.digest("SHA-256", combined))
   );
 }
@@ -4484,496 +4653,759 @@ function getBlobNameSuffix(blobName) {
   return parts.slice(1).join("/") || "";
 }
 
-// ../../packages/sdk/dist/chunk-67F5YZ25.mjs
-var CHUNK_SIZE_PARAMS = {
-  [
-    "ChunkSet10MiB_Chunk1MiB"
-    /* ChunkSet10MiB_Chunk1MiB */
-  ]: {
-    // 1MiB
-    chunkSizeBytes: 1 * 1024 * 1024,
-    // 10MiB
-    chunksetSizeBytes: 10 * 1024 * 1024
-  }
-};
-var DEFAULT_CHUNK_SIZE_BYTES = CHUNK_SIZE_PARAMS[
-  "ChunkSet10MiB_Chunk1MiB"
-  /* ChunkSet10MiB_Chunk1MiB */
-].chunkSizeBytes;
-var DEFAULT_CHUNKSET_SIZE_BYTES = CHUNK_SIZE_PARAMS[
-  "ChunkSet10MiB_Chunk1MiB"
-  /* ChunkSet10MiB_Chunk1MiB */
-].chunksetSizeBytes;
-var ERASURE_CODE_AND_CHUNK_MAPPING = {
-  [
-    "ClayCode_16Total_10Data_13Helper"
-    /* ClayCode_16Total_10Data_13Helper */
-  ]: {
-    ...CHUNK_SIZE_PARAMS.ChunkSet10MiB_Chunk1MiB
+// ../../packages/sdk/dist/chunk-PUYAZBYR.mjs
+import { AccountAddress as AccountAddress3 } from "@aptos-labs/ts-sdk";
+var MICROPAYMENT_HEADER = "X-Shelby-Micropayment";
+function encodeURIComponentKeepSlashes(str) {
+  return encodeURIComponent(str).replace(/%2F/g, "/");
+}
+var ShelbyRPCClient = class {
+  baseUrl;
+  apiKey;
+  rpcConfig;
+  indexer;
+  /**
+   * Creates a new ShelbyRPCClient for interacting with Shelby RPC nodes.
+   * This client handles blob storage operations including upload and download.
+   *
+   * @param config - The client configuration object.
+   * @param config.network - The Shelby network to use.
+   *
+   * @example
+   * ```typescript
+   * const client = new ShelbyRPCClient({
+   *   network: Network.SHELBYNET,
+   *   apiKey: "AG-***",
+   * });
+   * ```
+   */
+  constructor(config) {
+    this.baseUrl = config.rpc?.baseUrl ?? NetworkToShelbyRPCBaseUrl.shelbynet;
+    this.apiKey = config.apiKey ?? config.rpc?.apiKey;
+    this.rpcConfig = config.rpc ?? {};
+    this.indexer = getShelbyIndexerClient(config);
   }
-};
-
-// ../../packages/sdk/dist/chunk-LZSIZJYR.mjs
-var ERASURE_CODE_PARAMS = {
-  [
-    "ClayCode_16Total_10Data_13Helper"
-    /* ClayCode_16Total_10Data_13Helper */
-  ]: {
-    // total chunks (data + parity)
-    erasure_n: 16,
-    // data chunks
-    erasure_k: 10,
-    // helper nodes
-    erasure_d: 13
+  async #uploadPart(uploadId, partIdx, partData) {
+    const nRetries = 5;
+    for (let i = 0; i < nRetries; ++i) {
+      const partResponse = await fetch(
+        buildRequestUrl(
+          `/v1/multipart-uploads/${uploadId}/parts/${partIdx}`,
+          this.baseUrl
+        ),
+        {
+          method: "PUT",
+          headers: {
+            "Content-Type": "application/octet-stream",
+            ...this.apiKey ? { Authorization: `Bearer ${this.apiKey}` } : {}
+          },
+          body: partData
+        }
+      );
+      if (partResponse.ok) return;
+      if (i < nRetries - 1) {
+        const delay = 2 ** i * 100;
+        await sleep(delay);
+      }
+    }
+    throw new Error(`Failed to upload part ${partIdx}.`);
   }
-};
-var DEFAULT_ERASURE_N = ERASURE_CODE_PARAMS[
-  "ClayCode_16Total_10Data_13Helper"
-  /* ClayCode_16Total_10Data_13Helper */
-].erasure_n;
-var DEFAULT_ERASURE_K = ERASURE_CODE_PARAMS[
-  "ClayCode_16Total_10Data_13Helper"
-  /* ClayCode_16Total_10Data_13Helper */
-].erasure_k;
-var DEFAULT_ERASURE_D = ERASURE_CODE_PARAMS[
-  "ClayCode_16Total_10Data_13Helper"
-  /* ClayCode_16Total_10Data_13Helper */
-].erasure_d;
-var DEFAULT_ERASURE_M = DEFAULT_ERASURE_N - DEFAULT_ERASURE_K;
-
-// ../../packages/sdk/dist/chunk-RLRI2533.mjs
-import { Hex as Hex3 } 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(),
-  // the size is known statically from the current configuration
-  chunk_commitments: z.array(z.string())
-}).refine(
-  (data) => {
-    return data.chunk_commitments.length === DEFAULT_ERASURE_K + DEFAULT_ERASURE_M;
-  },
-  {
-    message: `Chunkset must have exactly ${DEFAULT_ERASURE_K + DEFAULT_ERASURE_M} chunks (ERASURE_K + ERASURE_M = ${DEFAULT_ERASURE_K} + ${DEFAULT_ERASURE_M})`,
-    path: ["chunk_commitments"]
-  }
-);
-function expectedTotalChunksets(rawSize, chunksetSize = DEFAULT_CHUNKSET_SIZE_BYTES) {
-  if (chunksetSize <= 0) {
-    throw new Error("chunksetSize must be positive");
-  }
-  if (rawSize === 0) return 1;
-  return Math.ceil(rawSize / chunksetSize);
-}
-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 generateMerkleRoot(leafHashes) {
-  if (!leafHashes.length) {
-    throw new Error(
-      "An empty array cannot be used to construct a Merkle tree."
+  async #putBlobMultipart(account, blobName, blobData, partSize = 5 * 1024 * 1024, onProgress) {
+    const startResponse = await fetch(
+      buildRequestUrl("/v1/multipart-uploads", this.baseUrl),
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          ...this.apiKey ? { Authorization: `Bearer ${this.apiKey}` } : {}
+        },
+        body: JSON.stringify({
+          rawAccount: account.toString(),
+          rawBlobName: blobName,
+          rawPartSize: partSize
+        })
+      }
     );
-  }
-  const zeroArray = new Uint8Array(leafHashes[0].toUint8Array().length);
-  const zeroBytes = Hex3.fromHexInput(zeroArray);
-  let currentLeaves = leafHashes;
-  while (currentLeaves.length > 1) {
-    if (currentLeaves.length % 2 !== 0) {
-      currentLeaves.push(zeroBytes);
-    }
-    const nextLeaves = [];
-    for (let i = 0; i < currentLeaves.length; i += 2) {
-      nextLeaves.push(
-        await concatHashes([
-          currentLeaves[i].toUint8Array(),
-          currentLeaves[i + 1].toUint8Array()
-        ])
+    if (!startResponse.ok) {
+      let errorBodyText = "Could not read error body";
+      try {
+        errorBodyText = await startResponse.text();
+      } catch (_e) {
+      }
+      throw new Error(
+        `Failed to start multipart upload! status: ${startResponse.status}, body: ${errorBodyText}`
       );
     }
-    currentLeaves = nextLeaves;
-  }
-  return currentLeaves[0];
-}
-async function generateChunksetCommitments(shouldPad, chunksetIdx, chunksetData, expectedChunksetSize, provider, onChunk) {
-  const { erasure_n } = provider.config;
-  const chunksetPayload = shouldPad ? zeroPadBytes(chunksetData, expectedChunksetSize) : validatePrePaddedChunkset(
-    chunksetData,
-    expectedChunksetSize,
-    chunksetIdx
-  );
-  const { chunks } = provider.encode(chunksetPayload);
-  if (chunks.length !== erasure_n) {
-    throw new Error(
-      `Erasure provider produced ${chunks.length} chunks, expected ${erasure_n}.`
+    const { uploadId } = StartMultipartUploadResponseSchema.parse(
+      await startResponse.json()
     );
-  }
-  const chunkRoots = provider.getChunkMerkleRoots();
-  let chunkIdx = 0;
-  for (const chunkData of chunks) {
-    if (onChunk !== void 0) {
-      await onChunk(chunksetIdx, chunkIdx, chunkData);
+    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);
+      await this.#uploadPart(uploadId, partIdx, partData);
+      onProgress?.({
+        partIdx,
+        totalParts,
+        partBytes: partData.length,
+        uploadedBytes: end,
+        totalBytes: blobData.length
+      });
     }
-    chunkIdx += 1;
-  }
-  const a = await generateMerkleRoot(
-    chunkRoots.map((a2) => Hex3.fromHexInput(a2))
-  );
-  const entry = {
-    chunkset_root: a.toString(),
-    chunk_commitments: chunkRoots.map(
-      (chunk) => Hex3.fromHexInput(chunk).toString()
-    )
-  };
-  return { h: a, entry };
-}
-async function generateCommitments(provider, fullData, onChunk, options) {
-  const expectedChunksetSize = DEFAULT_CHUNKSET_SIZE_BYTES;
-  const shouldPad = options?.pad ?? true;
-  const chunksetCommitments = [];
-  const chunksetCommitmentHashes = [];
-  let rawDataSize = 0;
-  const chunksetGen = readInChunks(fullData, expectedChunksetSize);
-  for await (const [chunksetIdx, chunksetData] of chunksetGen) {
-    rawDataSize += chunksetData.length;
-    const { h, entry } = await generateChunksetCommitments(
-      shouldPad,
-      chunksetIdx,
-      chunksetData,
-      expectedChunksetSize,
-      provider,
-      onChunk
-    );
-    chunksetCommitments.push(entry);
-    chunksetCommitmentHashes.push(h);
-  }
-  if (rawDataSize === 0) {
-    const zeroChunkset = new Uint8Array(expectedChunksetSize);
-    const { h, entry } = await generateChunksetCommitments(
-      shouldPad,
-      0,
-      zeroChunkset,
-      expectedChunksetSize,
-      provider,
-      onChunk
-    );
-    chunksetCommitments.push(entry);
-    chunksetCommitmentHashes.push(h);
-  }
-  return {
-    schema_version: COMMITMENT_SCHEMA_VERSION,
-    raw_data_size: rawDataSize,
-    blob_merkle_root: (await generateMerkleRoot(chunksetCommitmentHashes)).toString(),
-    chunkset_commitments: chunksetCommitments
-  };
-}
-function validatePrePaddedChunkset(chunkset, expectedSize, chunksetIdx) {
-  if (chunkset.byteLength !== expectedSize) {
-    throw new Error(
-      `Chunkset ${chunksetIdx} has size ${chunkset.byteLength} bytes but expected ${expectedSize} bytes. Enable padding or supply pre-padded data before calling generateCommitments.`
+    const completeResponse = await fetch(
+      buildRequestUrl(
+        `/v1/multipart-uploads/${uploadId}/complete`,
+        this.baseUrl
+      ),
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          ...this.apiKey ? { Authorization: `Bearer ${this.apiKey}` } : {}
+        }
+      }
     );
+    if (!completeResponse.ok) {
+      let errorBodyText = "Could not read error body";
+      try {
+        errorBodyText = await completeResponse.text();
+      } catch (_e) {
+      }
+      throw new Error(
+        `Failed to complete multipart upload! status: ${completeResponse.status}, body: ${errorBodyText}`
+      );
+    }
   }
-  return chunkset;
-}
-
-// ../../packages/sdk/dist/chunk-JWVMZ2Y7.mjs
-import {
-  AccountAddress as AccountAddress3,
-  Aptos as Aptos2,
-  AptosConfig as AptosConfig2,
-  Hex as Hex4,
-  MoveVector,
-  U32
-} from "@aptos-labs/ts-sdk";
-var ShelbyBlobClient = class _ShelbyBlobClient {
-  aptos;
-  deployer;
-  indexer;
   /**
-   * The ShelbyBlobClient is used to interact with the Shelby contract on the Aptos blockchain. This
-   * includes functions for registering blob commitments and retrieving blob metadata.
+   * Uploads blob data to the Shelby RPC node for storage by storage providers.
+   * This method should be called after blob commitments have been registered on the blockchain.
+   * Uses multipart upload for efficient handling of large files.
    *
-   * @param config - The client configuration object.
-   * @param config.network - The Shelby network to use.
+   * @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.
    *
    * @example
    * ```typescript
-   * const blobClient = new ShelbyBlobClient({
-   *   aptos: {
-   *     network: Network.SHELBYNET,
-   *     clientConfig: {
-   *       API_KEY: "AG-***",
-   *     },
-   *   },
+   * const blobData = new TextEncoder().encode("Hello, world!");
+   *
+   * await client.putBlob({
+   *   account: AccountAddress.from("0x1"),
+   *   blobName: "greetings/hello.txt",
+   *   blobData
    * });
    * ```
    */
-  constructor(config) {
-    const baseAptosConfig = getAptosConfig(config);
-    const aptosConfig = new AptosConfig2({
-      ...baseAptosConfig,
-      clientConfig: {
-        ...baseAptosConfig.clientConfig,
-        // Only use top-level apiKey if no API_KEY is already provided in Aptos settings
-        API_KEY: baseAptosConfig.clientConfig?.API_KEY ?? config.apiKey
-      }
-    });
-    this.aptos = new Aptos2(aptosConfig);
-    this.deployer = config.deployer ?? AccountAddress3.fromString(SHELBY_DEPLOYER);
-    this.indexer = getShelbyIndexerClient(config);
+  async putBlob(params) {
+    BlobNameSchema.parse(params.blobName);
+    await this.#putBlobMultipart(
+      params.account,
+      params.blobName,
+      params.blobData,
+      void 0,
+      params.onProgress
+    );
   }
+  // FIXME make this possible to stream in put ^^^
   /**
-   * Retrieves the blob metadata from the blockchain. If it does not exist,
-   * returns `undefined`.
+   * Downloads a blob from the Shelby RPC node.
+   * Returns a streaming response with validation to ensure data integrity.
    *
-   * @param params.account - The account namespace the blob is stored in (e.g. "0x1")
-   * @param params.name - The name of the blob (e.g. "foo/bar")
-   * @returns The blob metadata.
+   * @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.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
-   * const metadata = await client.getBlobMetadata({
-   *   account: AccountAddress.fromString("0x1"),
-   *   name: "foo/bar.txt",
+   * // Download entire blob
+   * const blob = await client.getBlob({
+   *   account: AccountAddress.from("0x1"),
+   *   blobName: "documents/report.pdf"
+   * });
+   *
+   * // Download partial content (bytes 100-199)
+   * const partial = await client.getBlob({
+   *   account: AccountAddress.from("0x1"),
+   *   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 getBlobMetadata(params) {
-    try {
-      const rawMetadata = await this.aptos.view({
-        payload: {
-          function: `${this.deployer.toString()}::blob_metadata::get_blob_metadata`,
-          functionArguments: [
-            createBlobKey({
-              account: params.account,
-              blobName: params.name
-            })
-          ]
+  async getBlob(params) {
+    BlobNameSchema.parse(params.blobName);
+    const url = buildRequestUrl(
+      `/v1/blobs/${params.account.toString()}/${encodeURIComponentKeepSlashes(
+        params.blobName
+      )}`,
+      this.baseUrl
+    );
+    const headers = new Headers();
+    if (params.range !== void 0) {
+      const { start, end } = params.range;
+      if (end === void 0) {
+        headers.set("Range", `bytes=${start}-`);
+      } else {
+        if (end < start) {
+          throw new Error("Range end cannot be less than start.");
         }
-      });
-      if (!rawMetadata?.[0]?.vec?.[0]) {
-        return void 0;
+        headers.set("Range", `bytes=${start}-${end}`);
       }
-      const metadata = rawMetadata[0].vec[0];
-      let encoding;
-      if (metadata.encoding.__variant__ === "ClayCode_16Total_10Data_13Helper") {
-        encoding = {
-          variant: "clay",
-          ...ERASURE_CODE_PARAMS[metadata.encoding.__variant__],
-          ...ERASURE_CODE_AND_CHUNK_MAPPING[metadata.encoding.__variant__]
-        };
-      } else {
+    }
+    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(
-          "Could not parse encoding from Shelby Smart Contract, this SDK is out of date."
+          `Failed to download blob: ${response.status} ${response.statusText}`
         );
       }
-      return {
-        blobMerkleRoot: Hex4.fromHexInput(
-          metadata.blob_commitment
-        ).toUint8Array(),
-        owner: AccountAddress3.fromString(metadata.owner),
-        name: params.name,
-        blobNameSuffix: getBlobNameSuffix(params.name),
-        size: Number(metadata.blob_size),
-        encoding,
-        expirationMicros: Number(metadata.expiration_micros),
-        creationMicros: Number(metadata.creation_micros),
-        sliceAddress: AccountAddress3.fromString(metadata.slice.inner),
-        isWritten: metadata.is_written
-      };
-    } catch (error) {
-      if (error instanceof Error && // Depending on the network, the error message may show up differently.
-      (error.message?.includes("sub_status: Some(404)") || error.message?.includes("EBLOB_NOT_FOUND"))) {
-        return void 0;
+      const parseResult = StaleMicropaymentErrorResponseSchema.safeParse(json);
+      if (!parseResult.success) {
+        throw new Error(
+          `Failed to download blob: ${response.status} ${response.statusText}`
+        );
       }
-      throw error;
+      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}`
+      );
     }
-  }
-  /**
-   * Retrieves all the blobs and their metadata for an account from the
-   * blockchain.
-   *
-   * @param params.account - The account namespace the blobs are stored in (e.g. "0x1")
-   * @param params.pagination (optional) - The pagination options.
-   * @param params.orderBy (optional) - The order by clause to sort the blobs by.
-   * @returns The blob metadata for all the blobs for the account.
-   *
-   * @example
-   * ```typescript
-   * // BlobMetadata[]
-   * const blobs = await client.getAccountBlobs({
-   *   account: AccountAddress.fromString("0x1"),
-   * });
-   * ```
-   */
-  getAccountBlobs(params) {
-    const { where, ...rest } = params;
-    return this.getBlobs({
-      where: {
-        ...where ?? {},
-        owner: { _eq: AccountAddress3.from(params.account).toString() }
-      },
-      pagination: rest.pagination,
-      orderBy: rest.orderBy
+    if (!response.ok) {
+      throw new Error(
+        `Failed to download blob: ${response.status} ${response.statusText}`
+      );
+    }
+    if (!response.body) {
+      throw new Error("Response body is null");
+    }
+    const contentLengthHeader = response.headers.get("content-length");
+    if (contentLengthHeader === null) {
+      throw new Error(
+        "Response did not have content-length header, which is required"
+      );
+    }
+    const expectedContentLength = Number.parseInt(contentLengthHeader, 10);
+    if (Number.isNaN(expectedContentLength)) {
+      throw new Error(
+        `Invalid content-length header received: ${contentLengthHeader}`
+      );
+    }
+    const validatingStream = new ReadableStream({
+      start(controller) {
+        const maybeReader = response.body?.getReader();
+        if (!maybeReader) {
+          controller.error(new Error("Response body reader is unavailable"));
+          return;
+        }
+        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();
+      }
     });
-  }
-  /**
-   * Retrieves blobs and their metadata from the blockchain.
-   *
-   * @param params.where (optional) - The where clause to filter the blobs by.
-   * @param params.pagination (optional) - The pagination options.
-   * @param params.orderBy (optional) - The order by clause to sort the blobs by.
-   * @returns The blob metadata for all the blobs that match the where clause.
-   *
-   * @example
-   * ```typescript
-   * // BlobMetadata[]
-   * const blobs = await client.getBlobs({
-   *   where: { owner: { _eq: AccountAddress.fromString("0x1").toString() } },
-   * });
-   * ```
-   */
-  async getBlobs(params = {}) {
-    const { limit, offset } = params.pagination ?? {};
-    const { orderBy, where } = params;
-    const currentMicros = Date.now() * 1e3;
-    const defaultActiveFilter = {
-      expires_at: { _gte: currentMicros },
-      is_deleted: { _eq: "0" }
+    return {
+      account: AccountAddress3.from(params.account),
+      name: params.blobName,
+      readable: validatingStream,
+      contentLength: expectedContentLength
     };
-    const finalWhere = where !== void 0 ? { ...defaultActiveFilter, ...where } : defaultActiveFilter;
-    const { blobs } = await this.indexer.getBlobs({
-      where: finalWhere,
-      limit,
-      offset,
-      orderBy
-    });
-    return blobs.map(
-      (blob) => ({
-        owner: AccountAddress3.from(blob.owner),
-        name: blob.blob_name,
-        blobNameSuffix: getBlobNameSuffix(blob.blob_name),
-        blobMerkleRoot: Hex4.fromHexInput(blob.blob_commitment).toUint8Array(),
-        size: Number(blob.size),
-        // TODO: Add encoding when supported in NCI
-        encoding: {
-          variant: "clay",
-          ...ERASURE_CODE_PARAMS.ClayCode_16Total_10Data_13Helper,
-          ...ERASURE_CODE_AND_CHUNK_MAPPING.ClayCode_16Total_10Data_13Helper
-        },
-        expirationMicros: Number(blob.expires_at),
-        creationMicros: Number(blob.created_at),
-        sliceAddress: AccountAddress3.from(blob.slice_address),
-        isWritten: Boolean(Number(blob.is_written))
-      })
-    );
   }
-  async getBlobActivities(params) {
-    const { limit, offset } = params.pagination ?? {};
-    const { orderBy, where } = params;
-    const { blob_activities } = await this.indexer.getBlobActivities({
-      where,
-      limit,
-      offset,
-      orderBy
-    });
-    const activityTypeMapping = {
-      [`${this.deployer.toStringLong()}::blob_metadata::BlobRegisteredEvent`]: "register_blob",
-      [`${this.deployer.toStringLong()}::blob_metadata::BlobDeletedEvent`]: "delete_blob",
-      [`${this.deployer.toStringLong()}::blob_metadata::BlobExpirationExtendedEvent`]: "extend_blob_expiration",
-      [`${this.deployer.toStringLong()}::blob_metadata::BlobWrittenEvent`]: "write_blob"
-    };
-    return blob_activities.map(
-      (activity) => ({
-        blobName: activity.blob_name,
-        accountAddress: AccountAddress3.from(
-          activity.blob_name.substring(1, 65)
-        ),
-        type: activityTypeMapping[activity.event_type] ?? "unknown",
-        eventType: activity.event_type,
-        eventIndex: activity.event_index,
-        transactionHash: activity.transaction_hash,
-        transactionVersion: activity.transaction_version,
-        timestamp: activity.timestamp
-      })
+};
+
+// ../../packages/sdk/dist/chunk-OTBLZL2S.mjs
+import { AccountAddress as AccountAddress4 } from "@aptos-labs/ts-sdk";
+var createBlobKey = (params) => {
+  return `@${AccountAddress4.from(params.account).toStringLongWithoutPrefix()}/${params.blobName}`;
+};
+
+// ../../packages/sdk/dist/chunk-RLRI2533.mjs
+import { Hex as Hex4 } from "@aptos-labs/ts-sdk";
+import { z as z3 } from "zod";
+var COMMITMENT_SCHEMA_VERSION = "1.3";
+var ChunksetCommitmentSchema = z3.object({
+  // Chunkset root (vector commitment of child chunks)
+  chunkset_root: z3.string(),
+  // the size is known statically from the current configuration
+  chunk_commitments: z3.array(z3.string())
+}).refine(
+  (data) => {
+    return data.chunk_commitments.length === DEFAULT_ERASURE_K + DEFAULT_ERASURE_M;
+  },
+  {
+    message: `Chunkset must have exactly ${DEFAULT_ERASURE_K + DEFAULT_ERASURE_M} chunks (ERASURE_K + ERASURE_M = ${DEFAULT_ERASURE_K} + ${DEFAULT_ERASURE_M})`,
+    path: ["chunk_commitments"]
+  }
+);
+function expectedTotalChunksets(rawSize, chunksetSize = DEFAULT_CHUNKSET_SIZE_BYTES) {
+  if (chunksetSize <= 0) {
+    throw new Error("chunksetSize must be positive");
+  }
+  if (rawSize === 0) return 1;
+  return Math.ceil(rawSize / chunksetSize);
+}
+var BlobCommitmentsSchema = z3.object({
+  schema_version: z3.string(),
+  raw_data_size: z3.number(),
+  // FIXME I am not sure about this being here, or if it should be somewhere else
+  blob_merkle_root: z3.string(),
+  chunkset_commitments: z3.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 generateMerkleRoot(leafHashes) {
+  if (!leafHashes.length) {
+    throw new Error(
+      "An empty array cannot be used to construct a Merkle tree."
     );
   }
-  /**
-   * Retrieves the total number of blobs from the blockchain.
-   *
-   * @param params.where (optional) - The where clause to filter the blobs by.
-   * @returns The total number of blobs.
-   *
-   * @example
-   * ```typescript
-   * const count = await client.getBlobsCount();
-   * ```
-   */
-  async getBlobsCount(params) {
-    const { where } = params;
-    const { blobs_aggregate } = await this.indexer.getBlobsCount({ where });
-    return blobs_aggregate?.aggregate?.count ?? 0;
+  const zeroArray = new Uint8Array(leafHashes[0].toUint8Array().length);
+  const zeroBytes = Hex4.fromHexInput(zeroArray);
+  let currentLeaves = leafHashes;
+  while (currentLeaves.length > 1) {
+    if (currentLeaves.length % 2 !== 0) {
+      currentLeaves.push(zeroBytes);
+    }
+    const nextLeaves = [];
+    for (let i = 0; i < currentLeaves.length; i += 2) {
+      nextLeaves.push(
+        await concatHashes([
+          currentLeaves[i].toUint8Array(),
+          currentLeaves[i + 1].toUint8Array()
+        ])
+      );
+    }
+    currentLeaves = nextLeaves;
+  }
+  return currentLeaves[0];
+}
+async function generateChunksetCommitments(shouldPad, chunksetIdx, chunksetData, expectedChunksetSize, provider, onChunk) {
+  const { erasure_n } = provider.config;
+  const chunksetPayload = shouldPad ? zeroPadBytes(chunksetData, expectedChunksetSize) : validatePrePaddedChunkset(
+    chunksetData,
+    expectedChunksetSize,
+    chunksetIdx
+  );
+  const { chunks } = provider.encode(chunksetPayload);
+  if (chunks.length !== erasure_n) {
+    throw new Error(
+      `Erasure provider produced ${chunks.length} chunks, expected ${erasure_n}.`
+    );
+  }
+  const chunkRoots = provider.getChunkMerkleRoots();
+  let chunkIdx = 0;
+  for (const chunkData of chunks) {
+    if (onChunk !== void 0) {
+      await onChunk(chunksetIdx, chunkIdx, chunkData);
+    }
+    chunkIdx += 1;
+  }
+  const a = await generateMerkleRoot(
+    chunkRoots.map((a2) => Hex4.fromHexInput(a2))
+  );
+  const entry = {
+    chunkset_root: a.toString(),
+    chunk_commitments: chunkRoots.map(
+      (chunk) => Hex4.fromHexInput(chunk).toString()
+    )
+  };
+  return { h: a, entry };
+}
+async function generateCommitments(provider, fullData, onChunk, options) {
+  const expectedChunksetSize = DEFAULT_CHUNKSET_SIZE_BYTES;
+  const shouldPad = options?.pad ?? true;
+  const chunksetCommitments = [];
+  const chunksetCommitmentHashes = [];
+  let rawDataSize = 0;
+  const chunksetGen = readInChunks(fullData, expectedChunksetSize);
+  for await (const [chunksetIdx, chunksetData] of chunksetGen) {
+    rawDataSize += chunksetData.length;
+    const { h, entry } = await generateChunksetCommitments(
+      shouldPad,
+      chunksetIdx,
+      chunksetData,
+      expectedChunksetSize,
+      provider,
+      onChunk
+    );
+    chunksetCommitments.push(entry);
+    chunksetCommitmentHashes.push(h);
+  }
+  if (rawDataSize === 0) {
+    const zeroChunkset = new Uint8Array(expectedChunksetSize);
+    const { h, entry } = await generateChunksetCommitments(
+      shouldPad,
+      0,
+      zeroChunkset,
+      expectedChunksetSize,
+      provider,
+      onChunk
+    );
+    chunksetCommitments.push(entry);
+    chunksetCommitmentHashes.push(h);
+  }
+  return {
+    schema_version: COMMITMENT_SCHEMA_VERSION,
+    raw_data_size: rawDataSize,
+    blob_merkle_root: (await generateMerkleRoot(chunksetCommitmentHashes)).toString(),
+    chunkset_commitments: chunksetCommitments
+  };
+}
+function validatePrePaddedChunkset(chunkset, expectedSize, chunksetIdx) {
+  if (chunkset.byteLength !== expectedSize) {
+    throw new Error(
+      `Chunkset ${chunksetIdx} has size ${chunkset.byteLength} bytes but expected ${expectedSize} bytes. Enable padding or supply pre-padded data before calling generateCommitments.`
+    );
   }
+  return chunkset;
+}
+
+// ../../packages/sdk/dist/chunk-JWVMZ2Y7.mjs
+import {
+  AccountAddress as AccountAddress5,
+  Aptos as Aptos2,
+  AptosConfig as AptosConfig2,
+  Hex as Hex5,
+  MoveVector,
+  U32
+} from "@aptos-labs/ts-sdk";
+var ShelbyBlobClient = class _ShelbyBlobClient {
+  aptos;
+  deployer;
+  indexer;
   /**
-   * Retrieves the total number of blob activities from the blockchain.
+   * The ShelbyBlobClient is used to interact with the Shelby contract on the Aptos blockchain. This
+   * includes functions for registering blob commitments and retrieving blob metadata.
    *
-   * @param params.where (optional) - The where clause to filter the blob activities by.
-   * @returns The total number of blob activities.
+   * @param config - The client configuration object.
+   * @param config.network - The Shelby network to use.
    *
    * @example
    * ```typescript
-   * const count = await client.getBlobActivitiesCount();
+   * const blobClient = new ShelbyBlobClient({
+   *   aptos: {
+   *     network: Network.SHELBYNET,
+   *     clientConfig: {
+   *       API_KEY: "AG-***",
+   *     },
+   *   },
+   * });
    * ```
    */
-  async getBlobActivitiesCount(params) {
-    const { where } = params;
-    const { blob_activities_aggregate } = await this.indexer.getBlobActivitiesCount({ where });
-    return blob_activities_aggregate?.aggregate?.count ?? 0;
+  constructor(config) {
+    const baseAptosConfig = getAptosConfig(config);
+    const aptosConfig = new AptosConfig2({
+      ...baseAptosConfig,
+      clientConfig: {
+        ...baseAptosConfig.clientConfig,
+        // Only use top-level apiKey if no API_KEY is already provided in Aptos settings
+        API_KEY: baseAptosConfig.clientConfig?.API_KEY ?? config.apiKey
+      }
+    });
+    this.aptos = new Aptos2(aptosConfig);
+    this.deployer = config.deployer ?? AccountAddress5.fromString(SHELBY_DEPLOYER);
+    this.indexer = getShelbyIndexerClient(config);
   }
   /**
-   * Registers a blob on the blockchain by writing its merkle root and metadata.
-   *
-   * @param params.account - The account that is signing and paying for the transaction.
-   * @param params.blobName - The name/path of the blob (e.g. "foo/bar.txt").
-   * @param params.blobMerkleRoot - The merkle root of the blob commitments.
-   * @param params.size - The size of the blob in bytes.
-   * @param params.expirationMicros - The expiration time of the blob in microseconds.
-   * @param params.options - Optional transaction building options.
-   * @param params.options.chunksetSizeBytes - Custom chunkset size (defaults to DEFAULT_CHUNKSET_SIZE_BYTES).
-   * @param params.options.build - Additional Aptos transaction building options.
+   * Retrieves the blob metadata from the blockchain. If it does not exist,
+   * returns `undefined`.
    *
-   * @returns An object containing the pending transaction.
+   * @param params.account - The account namespace the blob is stored in (e.g. "0x1")
+   * @param params.name - The name of the blob (e.g. "foo/bar")
+   * @returns The blob metadata.
    *
    * @example
    * ```typescript
-   * const provider = await ClayErasureCodingProvider.create();
-   * const blobCommitments = await generateCommitments(provider, data);
-   *
-   * const { transaction } = await client.registerBlob({
-   *   account: signer,
-   *   blobName: "foo/bar.txt",
-   *   blobMerkleRoot: blobCommitments.blob_merkle_root,
-   *   size: data.length,
-   *   expirationMicros: Date.now() * 1000 + 3600_000_000, // 1 hour from now in microseconds
+   * const metadata = await client.getBlobMetadata({
+   *   account: AccountAddress.fromString("0x1"),
+   *   name: "foo/bar.txt",
    * });
    * ```
    */
-  async registerBlob(params) {
-    const chunksetSize = params.options?.chunksetSizeBytes ?? DEFAULT_CHUNKSET_SIZE_BYTES;
-    const transaction = await this.aptos.transaction.build.simple({
+  async getBlobMetadata(params) {
+    try {
+      const rawMetadata = await this.aptos.view({
+        payload: {
+          function: `${this.deployer.toString()}::blob_metadata::get_blob_metadata`,
+          functionArguments: [
+            createBlobKey({
+              account: params.account,
+              blobName: params.name
+            })
+          ]
+        }
+      });
+      if (!rawMetadata?.[0]?.vec?.[0]) {
+        return void 0;
+      }
+      const metadata = rawMetadata[0].vec[0];
+      let encoding;
+      if (metadata.encoding.__variant__ === "ClayCode_16Total_10Data_13Helper") {
+        encoding = {
+          variant: "clay",
+          ...ERASURE_CODE_PARAMS[metadata.encoding.__variant__],
+          ...ERASURE_CODE_AND_CHUNK_MAPPING[metadata.encoding.__variant__]
+        };
+      } else {
+        throw new Error(
+          "Could not parse encoding from Shelby Smart Contract, this SDK is out of date."
+        );
+      }
+      return {
+        blobMerkleRoot: Hex5.fromHexInput(
+          metadata.blob_commitment
+        ).toUint8Array(),
+        owner: AccountAddress5.fromString(metadata.owner),
+        name: params.name,
+        blobNameSuffix: getBlobNameSuffix(params.name),
+        size: Number(metadata.blob_size),
+        encoding,
+        expirationMicros: Number(metadata.expiration_micros),
+        creationMicros: Number(metadata.creation_micros),
+        sliceAddress: AccountAddress5.fromString(metadata.slice.inner),
+        isWritten: metadata.is_written
+      };
+    } catch (error) {
+      if (error instanceof Error && // Depending on the network, the error message may show up differently.
+      (error.message?.includes("sub_status: Some(404)") || error.message?.includes("EBLOB_NOT_FOUND"))) {
+        return void 0;
+      }
+      throw error;
+    }
+  }
+  /**
+   * Retrieves all the blobs and their metadata for an account from the
+   * blockchain.
+   *
+   * @param params.account - The account namespace the blobs are stored in (e.g. "0x1")
+   * @param params.pagination (optional) - The pagination options.
+   * @param params.orderBy (optional) - The order by clause to sort the blobs by.
+   * @returns The blob metadata for all the blobs for the account.
+   *
+   * @example
+   * ```typescript
+   * // BlobMetadata[]
+   * const blobs = await client.getAccountBlobs({
+   *   account: AccountAddress.fromString("0x1"),
+   * });
+   * ```
+   */
+  getAccountBlobs(params) {
+    const { where, ...rest } = params;
+    return this.getBlobs({
+      where: {
+        ...where ?? {},
+        owner: { _eq: AccountAddress5.from(params.account).toString() }
+      },
+      pagination: rest.pagination,
+      orderBy: rest.orderBy
+    });
+  }
+  /**
+   * Retrieves blobs and their metadata from the blockchain.
+   *
+   * @param params.where (optional) - The where clause to filter the blobs by.
+   * @param params.pagination (optional) - The pagination options.
+   * @param params.orderBy (optional) - The order by clause to sort the blobs by.
+   * @returns The blob metadata for all the blobs that match the where clause.
+   *
+   * @example
+   * ```typescript
+   * // BlobMetadata[]
+   * const blobs = await client.getBlobs({
+   *   where: { owner: { _eq: AccountAddress.fromString("0x1").toString() } },
+   * });
+   * ```
+   */
+  async getBlobs(params = {}) {
+    const { limit, offset } = params.pagination ?? {};
+    const { orderBy, where } = params;
+    const currentMicros = Date.now() * 1e3;
+    const defaultActiveFilter = {
+      expires_at: { _gte: currentMicros },
+      is_deleted: { _eq: "0" }
+    };
+    const finalWhere = where !== void 0 ? { ...defaultActiveFilter, ...where } : defaultActiveFilter;
+    const { blobs } = await this.indexer.getBlobs({
+      where: finalWhere,
+      limit,
+      offset,
+      orderBy
+    });
+    return blobs.map(
+      (blob) => ({
+        owner: AccountAddress5.from(blob.owner),
+        name: blob.blob_name,
+        blobNameSuffix: getBlobNameSuffix(blob.blob_name),
+        blobMerkleRoot: Hex5.fromHexInput(blob.blob_commitment).toUint8Array(),
+        size: Number(blob.size),
+        // TODO: Add encoding when supported in NCI
+        encoding: {
+          variant: "clay",
+          ...ERASURE_CODE_PARAMS.ClayCode_16Total_10Data_13Helper,
+          ...ERASURE_CODE_AND_CHUNK_MAPPING.ClayCode_16Total_10Data_13Helper
+        },
+        expirationMicros: Number(blob.expires_at),
+        creationMicros: Number(blob.created_at),
+        sliceAddress: AccountAddress5.from(blob.slice_address),
+        isWritten: Boolean(Number(blob.is_written))
+      })
+    );
+  }
+  async getBlobActivities(params) {
+    const { limit, offset } = params.pagination ?? {};
+    const { orderBy, where } = params;
+    const { blob_activities } = await this.indexer.getBlobActivities({
+      where,
+      limit,
+      offset,
+      orderBy
+    });
+    const activityTypeMapping = {
+      [`${this.deployer.toStringLong()}::blob_metadata::BlobRegisteredEvent`]: "register_blob",
+      [`${this.deployer.toStringLong()}::blob_metadata::BlobDeletedEvent`]: "delete_blob",
+      [`${this.deployer.toStringLong()}::blob_metadata::BlobExpirationExtendedEvent`]: "extend_blob_expiration",
+      [`${this.deployer.toStringLong()}::blob_metadata::BlobWrittenEvent`]: "write_blob"
+    };
+    return blob_activities.map(
+      (activity) => ({
+        blobName: activity.blob_name,
+        accountAddress: AccountAddress5.from(
+          activity.blob_name.substring(1, 65)
+        ),
+        type: activityTypeMapping[activity.event_type] ?? "unknown",
+        eventType: activity.event_type,
+        eventIndex: activity.event_index,
+        transactionHash: activity.transaction_hash,
+        transactionVersion: activity.transaction_version,
+        timestamp: activity.timestamp
+      })
+    );
+  }
+  /**
+   * Retrieves the total number of blobs from the blockchain.
+   *
+   * @param params.where (optional) - The where clause to filter the blobs by.
+   * @returns The total number of blobs.
+   *
+   * @example
+   * ```typescript
+   * const count = await client.getBlobsCount();
+   * ```
+   */
+  async getBlobsCount(params) {
+    const { where } = params;
+    const { blobs_aggregate } = await this.indexer.getBlobsCount({ where });
+    return blobs_aggregate?.aggregate?.count ?? 0;
+  }
+  /**
+   * Retrieves the total number of blob activities from the blockchain.
+   *
+   * @param params.where (optional) - The where clause to filter the blob activities by.
+   * @returns The total number of blob activities.
+   *
+   * @example
+   * ```typescript
+   * const count = await client.getBlobActivitiesCount();
+   * ```
+   */
+  async getBlobActivitiesCount(params) {
+    const { where } = params;
+    const { blob_activities_aggregate } = await this.indexer.getBlobActivitiesCount({ where });
+    return blob_activities_aggregate?.aggregate?.count ?? 0;
+  }
+  /**
+   * Registers a blob on the blockchain by writing its merkle root and metadata.
+   *
+   * @param params.account - The account that is signing and paying for the transaction.
+   * @param params.blobName - The name/path of the blob (e.g. "foo/bar.txt").
+   * @param params.blobMerkleRoot - The merkle root of the blob commitments.
+   * @param params.size - The size of the blob in bytes.
+   * @param params.expirationMicros - The expiration time of the blob in microseconds.
+   * @param params.options - Optional transaction building options.
+   * @param params.options.chunksetSizeBytes - Custom chunkset size (defaults to DEFAULT_CHUNKSET_SIZE_BYTES).
+   * @param params.options.build - Additional Aptos transaction building options.
+   *
+   * @returns An object containing the pending transaction.
+   *
+   * @example
+   * ```typescript
+   * const provider = await ClayErasureCodingProvider.create();
+   * const blobCommitments = await generateCommitments(provider, data);
+   *
+   * const { transaction } = await client.registerBlob({
+   *   account: signer,
+   *   blobName: "foo/bar.txt",
+   *   blobMerkleRoot: blobCommitments.blob_merkle_root,
+   *   size: data.length,
+   *   expirationMicros: Date.now() * 1000 + 3600_000_000, // 1 hour from now in microseconds
+   * });
+   * ```
+   */
+  async registerBlob(params) {
+    const chunksetSize = params.options?.chunksetSizeBytes ?? DEFAULT_CHUNKSET_SIZE_BYTES;
+    const transaction = await this.aptos.transaction.build.simple({
       ...params.options?.build,
       data: _ShelbyBlobClient.createRegisterBlobPayload({
         deployer: this.deployer,
@@ -5082,777 +5514,373 @@ var ShelbyBlobClient = class _ShelbyBlobClient {
    * @param params.options - Additional options for transaction building and encoding.
    *
    * @returns The blob commitments and the pending transaction.
-   *
-   * @example
-   * ```typescript
-   * const { transaction } = await client.addChunksetAcknowledgements({
-   *   account: signer,
-   *   blobOwner: owner,
-   *   blobName: "foo/bar.txt",
-   *   creationMicros, // Taken from the blob metadata at registration time.
-   *   chunksetIdx,
-   *   storageProviderAcks: An array of StorageProviderAck types, each having the slot index and signature from the SP.
-   * });
-   * ```
-   */
-  async addChunksetAcknowledgements(params) {
-    const transaction = await this.aptos.transaction.build.simple({
-      ...params.options?.build,
-      data: _ShelbyBlobClient.createChunksetAcknowledgementsPayload({
-        blobOwner: params.blobOwner,
-        blobName: params.blobName,
-        creationMicros: params.creationMicros,
-        chunksetIdx: params.chunksetIdx,
-        storageProviderAcks: params.storageProviderAcks
-      }),
-      sender: params.account.accountAddress
-    });
-    return {
-      transaction: await this.aptos.signAndSubmitTransaction({
-        signer: params.account,
-        transaction
-      })
-    };
-  }
-  /**
-   * Registers multiple blobs on the blockchain by writing their merkle roots and metadata.
-   *
-   * @param params.account - The account that is signing and paying for the transaction.
-   * @param params.expirationMicros - The expiration time of the blobs in microseconds.
-   * @param params.blobs - The blobs to register.
-   * @param params.blobs.blobName - The name/path of the blob (e.g. "foo/bar.txt").
-   * @param params.blobs.blobSize - The size of the blob in bytes.
-   * @param params.blobs.blobMerkleRoot - The merkle root of the blob commitments as a hex string.
-   * @param params.options - Optional transaction building options.
-   * @param params.options.chunksetSizeBytes - Custom chunkset size (defaults to DEFAULT_CHUNKSET_SIZE_BYTES).
-   * @param params.options.build - Additional Aptos transaction building options.
-   *
-   * @returns An object containing the pending transaction.
-   *
-   * @example
-   * ```typescript
-   * const provider = await ClayErasureCodingProvider.create();
-   * const blobCommitments = await generateCommitments(provider, data);
-   *
-   * const { transaction } = await client.batchRegisterBlobs({
-   *   account: signer,
-   *   expirationMicros: Date.now() * 1000 + 3600_000_000, // 1 hour from now in microseconds
-   *   blobs: [
-   *     {
-   *       blobName: "foo/bar.txt",
-   *       blobSize: data.length,
-   *       blobMerkleRoot: blobCommitments.blob_merkle_root,
-   *     },
-   *   ],
-   * });
-   * ```
-   */
-  async batchRegisterBlobs(params) {
-    const chunksetSize = params.options?.chunksetSizeBytes ?? DEFAULT_CHUNKSET_SIZE_BYTES;
-    const transaction = await this.aptos.transaction.build.simple({
-      ...params.options?.build,
-      sender: params.account.accountAddress,
-      data: _ShelbyBlobClient.createBatchRegisterBlobsPayload({
-        deployer: this.deployer,
-        account: params.account.accountAddress,
-        expirationMicros: params.expirationMicros,
-        blobs: params.blobs.map((blob) => ({
-          blobName: blob.blobName,
-          blobSize: blob.blobSize,
-          blobMerkleRoot: blob.blobMerkleRoot,
-          numChunksets: expectedTotalChunksets(blob.blobSize, chunksetSize)
-        }))
-      })
-    });
-    return {
-      transaction: await this.aptos.signAndSubmitTransaction({
-        signer: params.account,
-        transaction
-      })
-    };
-  }
-  /**
-   * Creates a transaction payload to register a blob on the blockchain.
-   * This is a static helper method for constructing the Move function call payload.
-   *
-   * @param params.deployer - Optional deployer account address. Defaults to SHELBY_DEPLOYER.
-   * @param params.account - The account that will own the blob.
-   * @param params.blobName - The name/path of the blob (e.g. "foo/bar.txt").
-   * @param params.blobSize - The size of the blob in bytes.
-   * @param params.blobMerkleRoot - The merkle root of the blob commitments as a hex string.
-   * @param params.expirationMicros - The expiration time of the blob in microseconds.
-   * @param params.numChunksets - The total number of chunksets in the blob.
-   *
-   * @returns An Aptos transaction payload data object for the register_blob Move function.
-   *
-   * @see https://github.com/shelby/shelby/blob/e08e84742cf2b80ad8bb7227deb3013398076d53/move/shelby_contract/sources/global_metadata.move#L357
-   */
-  static createRegisterBlobPayload(params) {
-    return {
-      function: `${(params.deployer ?? SHELBY_DEPLOYER).toString()}::blob_metadata::register_blob`,
-      functionArguments: [
-        params.blobName,
-        params.expirationMicros,
-        MoveVector.U8(params.blobMerkleRoot),
-        params.numChunksets,
-        params.blobSize,
-        // TODO
-        0,
-        // payment tier
-        0
-        // encoding
-      ]
-    };
-  }
-  /**
-   * Creates a transaction payload to register multiple blobs on the blockchain.
-   * This is a static helper method for constructing the Move function call payload.
-   *
-   * @param params.deployer - Optional deployer account address. Defaults to SHELBY_DEPLOYER.
-   * @param params.account - The account that will own the blobs.
-   * @param params.expirationMicros - The expiration time of the blobs in microseconds.
-   * @param params.blobs - The blobs to register.
-   * @param params.blobs.blobName - The name/path of the blob (e.g. "foo/bar.txt").
-   * @param params.blobs.blobSize - The size of the blob in bytes.
-   * @param params.blobs.blobMerkleRoot - The merkle root of the blob commitments as a hex string.
-   * @param params.blobs.numChunksets - The total number of chunksets in the blob.
-   *
-   * @returns An Aptos transaction payload data object for the register_multiple_blobs Move function.
-   *
-   * @see https://github.com/shelby/shelby/blob/e08e84742cf2b80ad8bb7227deb3013398076d53/move/shelby_contract/sources/global_metadata.move#L357
-   */
-  static createBatchRegisterBlobsPayload(params) {
-    const blobNames = [];
-    const blobMerkleRoots = [];
-    const blobNumChunksets = [];
-    const blobSizes = [];
-    params.blobs.forEach((blob) => {
-      blobNames.push(blob.blobName);
-      blobMerkleRoots.push(MoveVector.U8(blob.blobMerkleRoot));
-      blobNumChunksets.push(blob.numChunksets);
-      blobSizes.push(blob.blobSize);
-    });
-    return {
-      function: `${(params.deployer ?? SHELBY_DEPLOYER).toString()}::blob_metadata::register_multiple_blobs`,
-      functionArguments: [
-        blobNames,
-        params.expirationMicros,
-        blobMerkleRoots,
-        blobNumChunksets,
-        blobSizes,
-        // TODO
-        0,
-        0
-      ]
-    };
-  }
-  /**
-   * Creates a transaction payload to delete a blob on the blockchain.
-   * This is a static helper method for constructing the Move function call payload.
-   *
-   * @param params.deployer - Optional deployer account address. Defaults to SHELBY_DEPLOYER.
-   * @param params.blobName - The blob name (e.g. "bar.txt", without the account address prefix).
-   *
-   * @returns An Aptos transaction payload data object for the delete_blob Move function.
-   *
-   * @see https://github.com/shelby/shelby/blob/64e9d7b4f0005e586faeb1e4085c79159234b6b6/move/shelby_contract/sources/global_metadata.move#L616
-   */
-  static createDeleteBlobPayload(params) {
-    return {
-      function: `${(params.deployer ?? SHELBY_DEPLOYER).toString()}::blob_metadata::delete_blob`,
-      functionArguments: [params.blobName]
-    };
-  }
-  /**
-   * Creates a transaction payload to delete multiple blobs on the blockchain.
-   * This is a static helper method for constructing the Move function call payload.
-   *
-   * **Note:** This function requires the `delete_multiple_blobs` entry function
-   * which will be deployed to the smart contract on 2026-02-04. Using this
-   * function before that date will result in a transaction failure.
-   *
-   * This operation is atomic: if any blob deletion fails (e.g., blob not found),
-   * the entire transaction fails and no blobs are deleted.
-   *
-   * @param params.deployer - Optional deployer account address. Defaults to SHELBY_DEPLOYER.
-   * @param params.blobNames - Array of blob name suffixes without the account address prefix
-   *   (e.g. ["foo/bar.txt", "baz.txt"], NOT ["0x1/foo/bar.txt"]). The account address
-   *   prefix is automatically derived from the transaction sender.
-   *
-   * @returns An Aptos transaction payload data object for the delete_multiple_blobs Move function.
-   *
-   * @see https://github.com/shelby/shelby/blob/main/move/shelby_contract/sources/blob_metadata.move
-   */
-  static createDeleteMultipleBlobsPayload(params) {
-    return {
-      function: `${(params.deployer ?? SHELBY_DEPLOYER).toString()}::blob_metadata::delete_multiple_blobs`,
-      functionArguments: [params.blobNames]
-    };
-  }
-  static createChunksetAcknowledgementsPayload(params) {
-    const ackBitMask = params.storageProviderAcks.reduce(
-      (acc, ack) => acc | 1 << ack.slot,
-      0
-    );
-    const signatures = new MoveVector(params.storageProviderAcks.map((ack) => MoveVector.U8(ack.signature)));
-    return {
-      function: `${SHELBY_DEPLOYER}::blob_metadata::add_chunkset_acknowledgements`,
-      functionArguments: [
-        createBlobKey({
-          account: params.blobOwner,
-          blobName: params.blobName
-        }),
-        params.chunksetIdx,
-        params.creationMicros,
-        new U32(Number(ackBitMask)),
-        signatures
-      ]
-    };
-  }
-};
-
-// ../../packages/sdk/dist/chunk-UCDAABAS.mjs
-import {
-  createDecoder,
-  createEncoder
-} from "@shelby-protocol/clay-codes";
-function getTotalChunks(config) {
-  return config.erasure_n;
-}
-var ClayErasureCodingProvider = class _ClayErasureCodingProvider {
-  config;
-  encoderCache;
-  decoderCache;
-  lastFunction;
-  constructor(config) {
-    this.config = config;
-    this.lastFunction = "none";
-  }
-  /**
-   * Static factory method to create an initialized ClayErasureCodingProvider
-   */
-  static async create(options) {
-    const config = buildClayConfig({
-      erasure_n: options?.erasure_n ?? DEFAULT_ERASURE_N,
-      erasure_k: options?.erasure_k ?? DEFAULT_ERASURE_K,
-      erasure_d: options?.erasure_d ?? DEFAULT_ERASURE_D,
-      chunkSizeBytes: options?.chunkSizeBytes ?? DEFAULT_CHUNK_SIZE_BYTES
-    });
-    const provider = new _ClayErasureCodingProvider(config);
-    [provider.encoderCache, provider.decoderCache] = await Promise.all([
-      createEncoder({
-        n: getTotalChunks(config),
-        k: config.erasure_k,
-        d: config.erasure_d,
-        chunkSizeBytes: config.chunkSizeBytes
-      }),
-      createDecoder({
-        n: getTotalChunks(config),
-        k: config.erasure_k,
-        d: config.erasure_d,
-        chunkSizeBytes: config.chunkSizeBytes,
-        erasedChunksMask: 0
-        // No chunks erased initially; will be reconfigured on decode
-      })
-    ]);
-    return provider;
-  }
-  encode(data) {
-    const { erasure_k, chunkSizeBytes } = this.config;
-    if (!this.encoderCache) {
-      throw new Error("Encoder cache is missing");
-    }
-    const systematicCapacity = erasure_k * chunkSizeBytes;
-    if (data.byteLength > systematicCapacity) {
-      throw new Error(
-        `Data size ${data.byteLength} bytes exceeds systematic capacity ${systematicCapacity} bytes (erasure_k=${erasure_k} * chunkSizeBytes=${chunkSizeBytes}).`
-      );
-    }
-    if (this.requiresPadding(data.length)) {
-      throw new Error(
-        `Data size ${data.length} bytes does not match systematic capacity ${systematicCapacity} bytes (erasure_k=${erasure_k} * chunkSizeBytes=${chunkSizeBytes}). Provide pre-padded data before encoding.`
-      );
-    }
-    this.lastFunction = "encoded";
-    return this.encoderCache.erasureCode(data);
-  }
-  decode(available, config) {
-    if (!this.decoderCache) {
-      throw new Error("Decoder cache is missing");
-    }
-    const { erasure_k, chunkSizeBytes } = this.config;
-    if (available.length < erasure_k) {
-      throw new Error(
-        `Insufficient available chunks: need at least ${erasure_k}, received ${available.length}.`
-      );
-    }
-    for (let i = 0; i < available.length; i++) {
-      const chunk = available[i];
-      if (chunk.length !== chunkSizeBytes) {
-        throw new Error(
-          `Chunk ${i} size ${chunk.length} bytes does not match expected chunkSizeBytes ${chunkSizeBytes}.`
-        );
-      }
-    }
-    this.lastFunction = "decoded";
-    return this.decoderCache.decode(available, config);
-  }
-  getChunkMerkleRoots() {
-    if (this.decoderCache && this.lastFunction === "decoded")
-      return this.decoderCache.getChunkMerkleRoots();
-    if (this.encoderCache && this.lastFunction === "encoded")
-      return this.encoderCache.getChunkMerkleRoots();
-    throw new Error(
-      "You must call encode or decode before calling getChunkMerkleRoots"
-    );
-  }
-  /**
-   * Determines if data can be erasure coded as-is or requires padding.
-   *
-   * Data can be erasure coded without padding if its size exactly matches
-   * the total systematic data capacity (k * chunkSizeBytes).
-   *
-   * @param dataSize - Size of the data in bytes
-   * @returns true if data needs padding, false if it can be coded as-is
-   */
-  requiresPadding(dataSize) {
-    const { erasure_k, chunkSizeBytes } = this.config;
-    const systematicCapacity = erasure_k * chunkSizeBytes;
-    return dataSize !== systematicCapacity;
-  }
-};
-function buildClayConfig(input) {
-  const { erasure_n, erasure_k, erasure_d, chunkSizeBytes } = input;
-  if (erasure_n <= 0)
-    throw new Error("erasure_n (total number of chunks) must be > 0");
-  if (erasure_k <= 0)
-    throw new Error("erasure_k (number of data chunks) must be > 0");
-  if (erasure_k >= erasure_n)
-    throw new Error(
-      `erasure_k (${erasure_k}) must be < erasure_n (${erasure_n})`
-    );
-  if (erasure_d <= erasure_k)
-    throw new Error(
-      `erasure_d (${erasure_d}) must be > erasure_k (${erasure_k})`
-    );
-  if (erasure_d >= erasure_n)
-    throw new Error(
-      `erasure_d (${erasure_d}) must be < erasure_n (${erasure_n})`
-    );
-  if (chunkSizeBytes <= 0) throw new Error("chunkSizeBytes must be > 0");
-  return {
-    erasure_n,
-    erasure_k,
-    erasure_d,
-    chunkSizeBytes
-  };
-}
-
-// ../../packages/sdk/dist/chunk-4MG4XGY4.mjs
-import {
-  AccountAuthenticator,
-  Deserializer,
-  Hex as Hex5,
-  MultiAgentTransaction,
-  Serializer
-} from "@aptos-labs/ts-sdk";
-var StaleChannelStateError = class _StaleChannelStateError extends Error {
-  /**
-   * The last valid micropayment stored by the server.
-   * Clients can use this to reset their local channel state.
-   */
-  storedMicropayment;
-  constructor(storedMicropayment, message) {
-    super(
-      message ?? "Client has stale channel state. Use the returned micropayment to reset local state."
-    );
-    this.name = "StaleChannelStateError";
-    this.storedMicropayment = storedMicropayment;
-  }
-  /**
-   * Returns the stored micropayment as a base64-encoded string.
-   */
-  toBase64() {
-    const bytes = this.storedMicropayment.bcsToBytes();
-    const binaryString = Array.from(
-      bytes,
-      (byte) => String.fromCharCode(byte)
-    ).join("");
-    return btoa(binaryString);
-  }
-  /**
-   * Creates a StaleChannelStateError from a base64-encoded micropayment string.
-   */
-  static fromBase64(base64, message) {
-    const binaryString = atob(base64);
-    const bytes = Uint8Array.from(binaryString, (char) => char.charCodeAt(0));
-    const micropayment = SenderBuiltMicropayment.deserialize(bytes);
-    return new _StaleChannelStateError(micropayment, message);
-  }
-};
-var SenderBuiltMicropayment = class _SenderBuiltMicropayment {
-  /**
-   * The actual micropayment transaction. It is built with the receiver address as fee payer and also requires a signature from the receiver to submit.
-   */
-  micropayment;
-  /**
-   * The sender's signature.
-   */
-  senderSignature;
-  constructor(micropayment, senderSignature) {
-    this.micropayment = micropayment;
-    this.senderSignature = senderSignature;
-  }
-  serialize(serializer) {
-    this.micropayment.serialize(serializer);
-    this.senderSignature.serialize(serializer);
-  }
-  bcsToBytes() {
-    const serializer = new Serializer();
-    this.serialize(serializer);
-    return serializer.toUint8Array();
-  }
-  bcsToHex() {
-    return Hex5.fromHexInput(this.bcsToBytes());
-  }
-  toStringWithoutPrefix() {
-    return this.bcsToHex().toStringWithoutPrefix();
-  }
-  toString() {
-    return this.bcsToHex().toString();
-  }
-  /**
-   * Deserializes a SenderBuiltMicropayment from BCS bytes.
-   * @param bytes - The bytes to deserialize from (Uint8Array or hex string).
-   * @returns A new SenderBuiltMicropayment instance.
-   */
-  static deserialize(bytes) {
-    const bytesArray = typeof bytes === "string" ? Hex5.fromHexInput(bytes).toUint8Array() : bytes;
-    const deserializer = new Deserializer(bytesArray);
-    const micropayment = MultiAgentTransaction.deserialize(deserializer);
-    const senderSignature = AccountAuthenticator.deserialize(deserializer);
-    return new _SenderBuiltMicropayment(micropayment, senderSignature);
-  }
-};
-
-// ../../packages/sdk/dist/chunk-W5NRGZEP.mjs
-import { AccountAddress as AccountAddress4 } from "@aptos-labs/ts-sdk";
-import { z as z2 } from "zod";
-var BlobNameSchema = z2.string().min(1, "Blob name path parameter cannot be empty.").max(1024, "Blob name cannot exceed 1024 characters.").refine((name2) => !name2.endsWith("/"), {
-  message: "Blob name cannot end with a slash"
-});
-
-// ../../packages/sdk/dist/chunk-I6NG5GNL.mjs
-function sleep(ms) {
-  return new Promise((resolve3) => setTimeout(resolve3, ms));
-}
-
-// ../../packages/sdk/dist/chunk-KLGT3RN5.mjs
-import { AccountAddress as AccountAddress5 } from "@aptos-labs/ts-sdk";
-var MICROPAYMENT_HEADER = "X-Shelby-Micropayment";
-function encodeURIComponentKeepSlashes(str) {
-  return encodeURIComponent(str).replace(/%2F/g, "/");
-}
-var ShelbyRPCClient = class {
-  baseUrl;
-  apiKey;
-  rpcConfig;
-  indexer;
-  /**
-   * Creates a new ShelbyRPCClient for interacting with Shelby RPC nodes.
-   * This client handles blob storage operations including upload and download.
-   *
-   * @param config - The client configuration object.
-   * @param config.network - The Shelby network to use.
-   *
-   * @example
-   * ```typescript
-   * const client = new ShelbyRPCClient({
-   *   network: Network.SHELBYNET,
-   *   apiKey: "AG-***",
-   * });
-   * ```
-   */
-  constructor(config) {
-    this.baseUrl = config.rpc?.baseUrl ?? NetworkToShelbyRPCBaseUrl.shelbynet;
-    this.apiKey = config.apiKey ?? config.rpc?.apiKey;
-    this.rpcConfig = config.rpc ?? {};
-    this.indexer = getShelbyIndexerClient(config);
-  }
-  async #uploadPart(uploadId, partIdx, partData) {
-    const nRetries = 5;
-    for (let i = 0; i < nRetries; ++i) {
-      const partResponse = await fetch(
-        buildRequestUrl(
-          `/v1/multipart-uploads/${uploadId}/parts/${partIdx}`,
-          this.baseUrl
-        ),
-        {
-          method: "PUT",
-          headers: {
-            "Content-Type": "application/octet-stream",
-            ...this.apiKey ? { Authorization: `Bearer ${this.apiKey}` } : {}
-          },
-          body: partData
-        }
-      );
-      if (partResponse.ok) return;
-      if (i < nRetries - 1) {
-        const delay = 2 ** i * 100;
-        await sleep(delay);
-      }
-    }
-    throw new Error(`Failed to upload part ${partIdx}.`);
-  }
-  async #putBlobMultipart(account, blobName, blobData, partSize = 5 * 1024 * 1024, onProgress) {
-    const startResponse = await fetch(
-      buildRequestUrl("/v1/multipart-uploads", this.baseUrl),
-      {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          ...this.apiKey ? { Authorization: `Bearer ${this.apiKey}` } : {}
-        },
-        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) {
-      }
-      throw new Error(
-        `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);
-      await this.#uploadPart(uploadId, partIdx, partData);
-      onProgress?.({
-        partIdx,
-        totalParts,
-        partBytes: partData.length,
-        uploadedBytes: end,
-        totalBytes: blobData.length
-      });
-    }
-    const completeResponse = await fetch(
-      buildRequestUrl(
-        `/v1/multipart-uploads/${uploadId}/complete`,
-        this.baseUrl
-      ),
-      {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          ...this.apiKey ? { Authorization: `Bearer ${this.apiKey}` } : {}
-        }
-      }
-    );
-    if (!completeResponse.ok) {
-      let errorBodyText = "Could not read error body";
-      try {
-        errorBodyText = await completeResponse.text();
-      } catch (_e) {
-      }
-      throw new Error(
-        `Failed to complete multipart upload! status: ${completeResponse.status}, body: ${errorBodyText}`
-      );
-    }
+   *
+   * @example
+   * ```typescript
+   * const { transaction } = await client.addChunksetAcknowledgements({
+   *   account: signer,
+   *   blobOwner: owner,
+   *   blobName: "foo/bar.txt",
+   *   creationMicros, // Taken from the blob metadata at registration time.
+   *   chunksetIdx,
+   *   storageProviderAcks: An array of StorageProviderAck types, each having the slot index and signature from the SP.
+   * });
+   * ```
+   */
+  async addChunksetAcknowledgements(params) {
+    const transaction = await this.aptos.transaction.build.simple({
+      ...params.options?.build,
+      data: _ShelbyBlobClient.createChunksetAcknowledgementsPayload({
+        blobOwner: params.blobOwner,
+        blobName: params.blobName,
+        creationMicros: params.creationMicros,
+        chunksetIdx: params.chunksetIdx,
+        storageProviderAcks: params.storageProviderAcks
+      }),
+      sender: params.account.accountAddress
+    });
+    return {
+      transaction: await this.aptos.signAndSubmitTransaction({
+        signer: params.account,
+        transaction
+      })
+    };
   }
   /**
-   * Uploads blob data to the Shelby RPC node for storage by storage providers.
-   * This method should be called after blob commitments have been registered on the blockchain.
-   * Uses multipart upload for efficient handling of large files.
+   * Registers multiple blobs on the blockchain by writing their merkle roots and metadata.
    *
-   * @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.account - The account that is signing and paying for the transaction.
+   * @param params.expirationMicros - The expiration time of the blobs in microseconds.
+   * @param params.blobs - The blobs to register.
+   * @param params.blobs.blobName - The name/path of the blob (e.g. "foo/bar.txt").
+   * @param params.blobs.blobSize - The size of the blob in bytes.
+   * @param params.blobs.blobMerkleRoot - The merkle root of the blob commitments as a hex string.
+   * @param params.options - Optional transaction building options.
+   * @param params.options.chunksetSizeBytes - Custom chunkset size (defaults to DEFAULT_CHUNKSET_SIZE_BYTES).
+   * @param params.options.build - Additional Aptos transaction building options.
+   *
+   * @returns An object containing the pending transaction.
    *
    * @example
    * ```typescript
-   * const blobData = new TextEncoder().encode("Hello, world!");
+   * const provider = await ClayErasureCodingProvider.create();
+   * const blobCommitments = await generateCommitments(provider, data);
    *
-   * await client.putBlob({
-   *   account: AccountAddress.from("0x1"),
-   *   blobName: "greetings/hello.txt",
-   *   blobData
+   * const { transaction } = await client.batchRegisterBlobs({
+   *   account: signer,
+   *   expirationMicros: Date.now() * 1000 + 3600_000_000, // 1 hour from now in microseconds
+   *   blobs: [
+   *     {
+   *       blobName: "foo/bar.txt",
+   *       blobSize: data.length,
+   *       blobMerkleRoot: blobCommitments.blob_merkle_root,
+   *     },
+   *   ],
    * });
    * ```
    */
-  async putBlob(params) {
-    BlobNameSchema.parse(params.blobName);
-    await this.#putBlobMultipart(
-      params.account,
-      params.blobName,
-      params.blobData,
-      void 0,
-      params.onProgress
-    );
+  async batchRegisterBlobs(params) {
+    const chunksetSize = params.options?.chunksetSizeBytes ?? DEFAULT_CHUNKSET_SIZE_BYTES;
+    const transaction = await this.aptos.transaction.build.simple({
+      ...params.options?.build,
+      sender: params.account.accountAddress,
+      data: _ShelbyBlobClient.createBatchRegisterBlobsPayload({
+        deployer: this.deployer,
+        account: params.account.accountAddress,
+        expirationMicros: params.expirationMicros,
+        blobs: params.blobs.map((blob) => ({
+          blobName: blob.blobName,
+          blobSize: blob.blobSize,
+          blobMerkleRoot: blob.blobMerkleRoot,
+          numChunksets: expectedTotalChunksets(blob.blobSize, chunksetSize)
+        }))
+      })
+    });
+    return {
+      transaction: await this.aptos.signAndSubmitTransaction({
+        signer: params.account,
+        transaction
+      })
+    };
   }
-  // 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.
+   * Creates a transaction payload to register a blob on the blockchain.
+   * This is a static helper method for constructing the Move function call payload.
    *
-   * @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.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.
+   * @param params.deployer - Optional deployer account address. Defaults to SHELBY_DEPLOYER.
+   * @param params.account - The account that will own the blob.
+   * @param params.blobName - The name/path of the blob (e.g. "foo/bar.txt").
+   * @param params.blobSize - The size of the blob in bytes.
+   * @param params.blobMerkleRoot - The merkle root of the blob commitments as a hex string.
+   * @param params.expirationMicros - The expiration time of the blob in microseconds.
+   * @param params.numChunksets - The total number of chunksets in the blob.
    *
-   * @returns A ShelbyBlob object containing the account, name, readable stream, and content length.
+   * @returns An Aptos transaction payload data object for the register_blob Move function.
    *
-   * @throws Error if the download fails or content length doesn't match.
-   * @throws StaleChannelStateError if the micropayment is stale (server has newer state).
+   * @see https://github.com/shelby/shelby/blob/e08e84742cf2b80ad8bb7227deb3013398076d53/move/shelby_contract/sources/global_metadata.move#L357
+   */
+  static createRegisterBlobPayload(params) {
+    return {
+      function: `${(params.deployer ?? SHELBY_DEPLOYER).toString()}::blob_metadata::register_blob`,
+      functionArguments: [
+        params.blobName,
+        params.expirationMicros,
+        MoveVector.U8(params.blobMerkleRoot),
+        params.numChunksets,
+        params.blobSize,
+        // TODO
+        0,
+        // payment tier
+        0
+        // encoding
+      ]
+    };
+  }
+  /**
+   * Creates a transaction payload to register multiple blobs on the blockchain.
+   * This is a static helper method for constructing the Move function call payload.
    *
-   * @example
-   * ```typescript
-   * // Download entire blob
-   * const blob = await client.getBlob({
-   *   account: AccountAddress.from("0x1"),
-   *   blobName: "documents/report.pdf"
-   * });
+   * @param params.deployer - Optional deployer account address. Defaults to SHELBY_DEPLOYER.
+   * @param params.account - The account that will own the blobs.
+   * @param params.expirationMicros - The expiration time of the blobs in microseconds.
+   * @param params.blobs - The blobs to register.
+   * @param params.blobs.blobName - The name/path of the blob (e.g. "foo/bar.txt").
+   * @param params.blobs.blobSize - The size of the blob in bytes.
+   * @param params.blobs.blobMerkleRoot - The merkle root of the blob commitments as a hex string.
+   * @param params.blobs.numChunksets - The total number of chunksets in the blob.
    *
-   * // Download partial content (bytes 100-199)
-   * const partial = await client.getBlob({
-   *   account: AccountAddress.from("0x1"),
-   *   blobName: "large-file.bin",
-   *   range: { start: 100, end: 199 }
-   * });
+   * @returns An Aptos transaction payload data object for the register_multiple_blobs Move function.
    *
-   * // Download with micropayment
-   * const blob = await client.getBlob({
-   *   account: AccountAddress.from("0x1"),
-   *   blobName: "documents/report.pdf",
-   *   micropayment: senderBuiltMicropayment
-   * });
-   * ```
+   * @see https://github.com/shelby/shelby/blob/e08e84742cf2b80ad8bb7227deb3013398076d53/move/shelby_contract/sources/global_metadata.move#L357
+   */
+  static createBatchRegisterBlobsPayload(params) {
+    const blobNames = [];
+    const blobMerkleRoots = [];
+    const blobNumChunksets = [];
+    const blobSizes = [];
+    params.blobs.forEach((blob) => {
+      blobNames.push(blob.blobName);
+      blobMerkleRoots.push(MoveVector.U8(blob.blobMerkleRoot));
+      blobNumChunksets.push(blob.numChunksets);
+      blobSizes.push(blob.blobSize);
+    });
+    return {
+      function: `${(params.deployer ?? SHELBY_DEPLOYER).toString()}::blob_metadata::register_multiple_blobs`,
+      functionArguments: [
+        blobNames,
+        params.expirationMicros,
+        blobMerkleRoots,
+        blobNumChunksets,
+        blobSizes,
+        // TODO
+        0,
+        0
+      ]
+    };
+  }
+  /**
+   * Creates a transaction payload to delete a blob on the blockchain.
+   * This is a static helper method for constructing the Move function call payload.
+   *
+   * @param params.deployer - Optional deployer account address. Defaults to SHELBY_DEPLOYER.
+   * @param params.blobName - The blob name (e.g. "bar.txt", without the account address prefix).
+   *
+   * @returns An Aptos transaction payload data object for the delete_blob Move function.
+   *
+   * @see https://github.com/shelby/shelby/blob/64e9d7b4f0005e586faeb1e4085c79159234b6b6/move/shelby_contract/sources/global_metadata.move#L616
+   */
+  static createDeleteBlobPayload(params) {
+    return {
+      function: `${(params.deployer ?? SHELBY_DEPLOYER).toString()}::blob_metadata::delete_blob`,
+      functionArguments: [params.blobName]
+    };
+  }
+  /**
+   * Creates a transaction payload to delete multiple blobs on the blockchain.
+   * This is a static helper method for constructing the Move function call payload.
+   *
+   * **Note:** This function requires the `delete_multiple_blobs` entry function
+   * which will be deployed to the smart contract on 2026-02-04. Using this
+   * function before that date will result in a transaction failure.
+   *
+   * This operation is atomic: if any blob deletion fails (e.g., blob not found),
+   * the entire transaction fails and no blobs are deleted.
+   *
+   * @param params.deployer - Optional deployer account address. Defaults to SHELBY_DEPLOYER.
+   * @param params.blobNames - Array of blob name suffixes without the account address prefix
+   *   (e.g. ["foo/bar.txt", "baz.txt"], NOT ["0x1/foo/bar.txt"]). The account address
+   *   prefix is automatically derived from the transaction sender.
+   *
+   * @returns An Aptos transaction payload data object for the delete_multiple_blobs Move function.
+   *
+   * @see https://github.com/shelby/shelby/blob/main/move/shelby_contract/sources/blob_metadata.move
+   */
+  static createDeleteMultipleBlobsPayload(params) {
+    return {
+      function: `${(params.deployer ?? SHELBY_DEPLOYER).toString()}::blob_metadata::delete_multiple_blobs`,
+      functionArguments: [params.blobNames]
+    };
+  }
+  static createChunksetAcknowledgementsPayload(params) {
+    const ackBitMask = params.storageProviderAcks.reduce(
+      (acc, ack) => acc | 1 << ack.slot,
+      0
+    );
+    const signatures = new MoveVector(params.storageProviderAcks.map((ack) => MoveVector.U8(ack.signature)));
+    return {
+      function: `${SHELBY_DEPLOYER}::blob_metadata::add_chunkset_acknowledgements`,
+      functionArguments: [
+        createBlobKey({
+          account: params.blobOwner,
+          blobName: params.blobName
+        }),
+        params.chunksetIdx,
+        params.creationMicros,
+        new U32(Number(ackBitMask)),
+        signatures
+      ]
+    };
+  }
+};
+
+// ../../packages/sdk/dist/chunk-UCDAABAS.mjs
+import {
+  createDecoder,
+  createEncoder
+} from "@shelby-protocol/clay-codes";
+function getTotalChunks(config) {
+  return config.erasure_n;
+}
+var ClayErasureCodingProvider = class _ClayErasureCodingProvider {
+  config;
+  encoderCache;
+  decoderCache;
+  lastFunction;
+  constructor(config) {
+    this.config = config;
+    this.lastFunction = "none";
+  }
+  /**
+   * Static factory method to create an initialized ClayErasureCodingProvider
    */
-  async getBlob(params) {
-    BlobNameSchema.parse(params.blobName);
-    const url = buildRequestUrl(
-      `/v1/blobs/${params.account.toString()}/${encodeURIComponentKeepSlashes(
-        params.blobName
-      )}`,
-      this.baseUrl
-    );
-    const headers = new Headers();
-    if (params.range !== void 0) {
-      const { start, end } = params.range;
-      if (end === void 0) {
-        headers.set("Range", `bytes=${start}-`);
-      } else {
-        if (end < start) {
-          throw new Error("Range end cannot be less than start.");
-        }
-        headers.set("Range", `bytes=${start}-${end}`);
-      }
-    }
-    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));
+  static async create(options) {
+    const config = buildClayConfig({
+      erasure_n: options?.erasure_n ?? DEFAULT_ERASURE_N,
+      erasure_k: options?.erasure_k ?? DEFAULT_ERASURE_K,
+      erasure_d: options?.erasure_d ?? DEFAULT_ERASURE_D,
+      chunkSizeBytes: options?.chunkSizeBytes ?? DEFAULT_CHUNK_SIZE_BYTES
+    });
+    const provider = new _ClayErasureCodingProvider(config);
+    [provider.encoderCache, provider.decoderCache] = await Promise.all([
+      createEncoder({
+        n: getTotalChunks(config),
+        k: config.erasure_k,
+        d: config.erasure_d,
+        chunkSizeBytes: config.chunkSizeBytes
+      }),
+      createDecoder({
+        n: getTotalChunks(config),
+        k: config.erasure_k,
+        d: config.erasure_d,
+        chunkSizeBytes: config.chunkSizeBytes,
+        erasedChunksMask: 0
+        // No chunks erased initially; will be reconfigured on decode
+      })
+    ]);
+    return provider;
+  }
+  encode(data) {
+    const { erasure_k, chunkSizeBytes } = this.config;
+    if (!this.encoderCache) {
+      throw new Error("Encoder cache is missing");
     }
-    const response = await fetch(url, { headers });
-    if (response.status === 409) {
-      let errorBody;
-      try {
-        errorBody = await response.json();
-      } catch {
-        throw new Error(
-          `Failed to download blob: ${response.status} ${response.statusText}`
-        );
-      }
-      if (errorBody.storedMicropayment) {
-        throw StaleChannelStateError.fromBase64(
-          errorBody.storedMicropayment,
-          errorBody.error
-        );
-      }
+    const systematicCapacity = erasure_k * chunkSizeBytes;
+    if (data.byteLength > systematicCapacity) {
       throw new Error(
-        errorBody.error ?? `Failed to download blob: ${response.status} ${response.statusText}`
+        `Data size ${data.byteLength} bytes exceeds systematic capacity ${systematicCapacity} bytes (erasure_k=${erasure_k} * chunkSizeBytes=${chunkSizeBytes}).`
       );
     }
-    if (!response.ok) {
+    if (this.requiresPadding(data.length)) {
       throw new Error(
-        `Failed to download blob: ${response.status} ${response.statusText}`
+        `Data size ${data.length} bytes does not match systematic capacity ${systematicCapacity} bytes (erasure_k=${erasure_k} * chunkSizeBytes=${chunkSizeBytes}). Provide pre-padded data before encoding.`
       );
     }
-    if (!response.body) {
-      throw new Error("Response body is null");
-    }
-    const contentLengthHeader = response.headers.get("content-length");
-    if (contentLengthHeader === null) {
-      throw new Error(
-        "Response did not have content-length header, which is required"
-      );
+    this.lastFunction = "encoded";
+    return this.encoderCache.erasureCode(data);
+  }
+  decode(available, config) {
+    if (!this.decoderCache) {
+      throw new Error("Decoder cache is missing");
     }
-    const expectedContentLength = Number.parseInt(contentLengthHeader, 10);
-    if (Number.isNaN(expectedContentLength)) {
+    const { erasure_k, chunkSizeBytes } = this.config;
+    if (available.length < erasure_k) {
       throw new Error(
-        `Invalid content-length header received: ${contentLengthHeader}`
+        `Insufficient available chunks: need at least ${erasure_k}, received ${available.length}.`
       );
     }
-    const validatingStream = new ReadableStream({
-      start(controller) {
-        const maybeReader = response.body?.getReader();
-        if (!maybeReader) {
-          controller.error(new Error("Response body reader is unavailable"));
-          return;
-        }
-        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();
+    for (let i = 0; i < available.length; i++) {
+      const chunk = available[i];
+      if (chunk.length !== chunkSizeBytes) {
+        throw new Error(
+          `Chunk ${i} size ${chunk.length} bytes does not match expected chunkSizeBytes ${chunkSizeBytes}.`
+        );
       }
-    });
-    return {
-      account: AccountAddress5.from(params.account),
-      name: params.blobName,
-      readable: validatingStream,
-      contentLength: expectedContentLength
-    };
+    }
+    this.lastFunction = "decoded";
+    return this.decoderCache.decode(available, config);
+  }
+  getChunkMerkleRoots() {
+    if (this.decoderCache && this.lastFunction === "decoded")
+      return this.decoderCache.getChunkMerkleRoots();
+    if (this.encoderCache && this.lastFunction === "encoded")
+      return this.encoderCache.getChunkMerkleRoots();
+    throw new Error(
+      "You must call encode or decode before calling getChunkMerkleRoots"
+    );
+  }
+  /**
+   * Determines if data can be erasure coded as-is or requires padding.
+   *
+   * Data can be erasure coded without padding if its size exactly matches
+   * the total systematic data capacity (k * chunkSizeBytes).
+   *
+   * @param dataSize - Size of the data in bytes
+   * @returns true if data needs padding, false if it can be coded as-is
+   */
+  requiresPadding(dataSize) {
+    const { erasure_k, chunkSizeBytes } = this.config;
+    const systematicCapacity = erasure_k * chunkSizeBytes;
+    return dataSize !== systematicCapacity;
   }
 };
+function buildClayConfig(input) {
+  const { erasure_n, erasure_k, erasure_d, chunkSizeBytes } = input;
+  if (erasure_n <= 0)
+    throw new Error("erasure_n (total number of chunks) must be > 0");
+  if (erasure_k <= 0)
+    throw new Error("erasure_k (number of data chunks) must be > 0");
+  if (erasure_k >= erasure_n)
+    throw new Error(
+      `erasure_k (${erasure_k}) must be < erasure_n (${erasure_n})`
+    );
+  if (erasure_d <= erasure_k)
+    throw new Error(
+      `erasure_d (${erasure_d}) must be > erasure_k (${erasure_k})`
+    );
+  if (erasure_d >= erasure_n)
+    throw new Error(
+      `erasure_d (${erasure_d}) must be < erasure_n (${erasure_n})`
+    );
+  if (chunkSizeBytes <= 0) throw new Error("chunkSizeBytes must be > 0");
+  return {
+    erasure_n,
+    erasure_k,
+    erasure_d,
+    chunkSizeBytes
+  };
+}
 
-// ../../packages/sdk/dist/chunk-TZOQZTUX.mjs
+// ../../packages/sdk/dist/chunk-H6IYPL3O.mjs
 import {
   AccountAddress as AccountAddress6,
   Aptos as Aptos3,
@@ -5997,7 +6025,7 @@ function validateConcurrency(concurrency) {
   }
 }
 
-// ../../packages/sdk/dist/chunk-TZOQZTUX.mjs
+// ../../packages/sdk/dist/chunk-H6IYPL3O.mjs
 var ShelbyClient = class {
   /**
    * The coordination client is used to interact with the Aptos blockchain which handles the commitments
@@ -6306,7 +6334,7 @@ var ShelbyClient = class {
   }
 };
 
-// ../../packages/sdk/dist/chunk-KDCQQYX2.mjs
+// ../../packages/sdk/dist/chunk-WO2DVEKI.mjs
 var ShelbyNodeClient = class extends ShelbyClient {
 };
 
@@ -6903,7 +6931,7 @@ function getAptosAccountExplorerUrl(network, accountAddress) {
 import chalk2 from "chalk";
 import { filesize } from "filesize";
 import { render } from "ink";
-import { z as z11 } from "zod";
+import { z as z12 } from "zod";
 
 // src/components/AccountWizard.tsx
 import { Box, Text } from "ink";
@@ -6922,37 +6950,37 @@ import {
 } from "@aptos-labs/ts-sdk";
 import fs2 from "fs-extra";
 import YAML2 from "yaml";
-import { z as z7 } from "zod";
+import { z as z8 } from "zod";
 
 // src/schemas/AptosNetworkSchema.ts
-import { z as z4 } from "zod";
+import { z as z5 } from "zod";
 
 // src/schemas/EndpointSchema.ts
-import { z as z3 } from "zod";
-var EndpointSchema = z3.string().url("Must be a valid URL");
+import { z as z4 } from "zod";
+var EndpointSchema = z4.string().url("Must be a valid URL");
 
 // src/schemas/AptosNetworkSchema.ts
-var AptosNetworkNameSchema = z4.enum(shelbyNetworks);
-var AptosNetworkSchema = z4.object({
+var AptosNetworkNameSchema = z5.enum(shelbyNetworks);
+var AptosNetworkSchema = z5.object({
   name: AptosNetworkNameSchema,
   fullnode: EndpointSchema.optional(),
   faucet: EndpointSchema.optional(),
   indexer: EndpointSchema.optional(),
   pepper: EndpointSchema.optional(),
   prover: EndpointSchema.optional(),
-  api_key: z4.string().optional()
+  api_key: z5.string().optional()
 });
 
 // src/schemas/ShelbyNetworkSchema.ts
-import { z as z5 } from "zod";
-var ShelbyNetworkSchema = z5.object({
+import { z as z6 } from "zod";
+var ShelbyNetworkSchema = z6.object({
   rpc_endpoint: EndpointSchema.optional(),
   indexer_endpoint: EndpointSchema.optional(),
-  rpc_api_key: z5.string().optional(),
-  indexer_api_key: z5.string().optional(),
-  deployer_address: z5.string().optional(),
+  rpc_api_key: z6.string().optional(),
+  indexer_api_key: z6.string().optional(),
+  deployer_address: z6.string().optional(),
   // The account address of the RPC server that receives micropayments
-  rpc_receiver_address: z5.string().optional()
+  rpc_receiver_address: z6.string().optional()
 });
 
 // src/utils/global-config.ts
@@ -6960,9 +6988,9 @@ import os from "os";
 import path from "path";
 import fs from "fs-extra";
 import YAML from "yaml";
-import { z as z6 } from "zod";
-var GlobalConfigSchema = z6.object({
-  config_location_behavior: z6.enum(["global", "walk"])
+import { z as z7 } from "zod";
+var GlobalConfigSchema = z7.object({
+  config_location_behavior: z7.enum(["global", "walk"])
 });
 var DEFAULT_GLOBAL_CONFIG = {
   config_location_behavior: "global"
@@ -6998,27 +7026,27 @@ function saveGlobalConfig(config) {
 }
 
 // src/utils/config.ts
-var ContextSchema = z7.object({
-  api_key: z7.string().optional(),
+var ContextSchema = z8.object({
+  api_key: z8.string().optional(),
   aptos_network: AptosNetworkSchema,
   shelby_network: ShelbyNetworkSchema.optional()
 });
-var AccountNameSchema = z7.string().min(1, "Account name cannot be empty").regex(
+var AccountNameSchema = z8.string().min(1, "Account name cannot be empty").regex(
   /^[a-zA-Z0-9_-]+$/,
   "Account name must contain only alphanumeric characters, underscores, and hyphens"
 );
-var ConfigSchema = z7.object({
-  contexts: z7.record(ContextSchema),
-  accounts: z7.record(
+var ConfigSchema = z8.object({
+  contexts: z8.record(ContextSchema),
+  accounts: z8.record(
     AccountNameSchema,
-    z7.object({
-      address: z7.string().optional(),
-      private_key: z7.string({ message: "private_key must be provided" })
+    z8.object({
+      address: z8.string().optional(),
+      private_key: z8.string({ message: "private_key must be provided" })
     })
   ),
-  default_context: z7.string(),
+  default_context: z8.string(),
   // Can be empty string if no account is set up
-  default_account: z7.string()
+  default_account: z8.string()
 });
 function getPathForNewConfig() {
   const globalConfig = loadGlobalConfig();
@@ -7218,7 +7246,7 @@ import {
   Secp256k1PrivateKey,
   SigningSchemeInput
 } from "@aptos-labs/ts-sdk";
-import { z as z8 } from "zod";
+import { z as z9 } from "zod";
 function generateEd25519Account() {
   const account = Account.generate({
     scheme: SigningSchemeInput.Ed25519,
@@ -7238,7 +7266,7 @@ function isValidAddress(address) {
   return AccountAddress8.isValid({ input: address }).valid;
 }
 var ED25519_NAME = "ed25519";
-var SignatureSchemeSchema = z8.enum([ED25519_NAME]);
+var SignatureSchemeSchema = z9.enum([ED25519_NAME]);
 
 // src/components/AccountWizard.tsx
 import { jsx, jsxs } from "react/jsx-runtime";
@@ -7466,7 +7494,7 @@ var SHELBY_CONFIG_FIELDS = [
 import { Box as Box3, Text as Text3 } from "ink";
 import TextInput2 from "ink-text-input";
 import { useState as useState2 } from "react";
-import z9 from "zod";
+import z10 from "zod";
 import { jsx as jsx4, jsxs as jsxs3 } from "react/jsx-runtime";
 function FormTextInput({
   type,
@@ -7496,7 +7524,7 @@ function FormTextInput({
             return;
           }
           if (value2) {
-            if (type === "url" && !z9.string().url().safeParse(value2).success) {
+            if (type === "url" && !z10.string().url().safeParse(value2).success) {
               setError("The field must be a valid URL");
               return;
             }
@@ -7544,7 +7572,8 @@ var ContextReviewWizard = ({
       indexer_endpoint: NetworkToShelbyBlobIndexerBaseUrl[aptosNetwork.name],
       indexer_api_key: void 0,
       deployer_address: void 0,
-      rpc_api_key: void 0
+      rpc_api_key: void 0,
+      rpc_receiver_address: void 0
     }[key];
     return fallbackValue ? { value: fallbackValue, source: "default" } : void 0;
   };
@@ -8193,13 +8222,13 @@ import boxen from "boxen";
 import chalk from "chalk";
 import { getLatestVersion } from "fast-npm-meta";
 import * as semver from "semver";
-import { z as z10 } from "zod";
+import { z as z11 } from "zod";
 var CHECK_INTERVAL = 1e3 * 60 * 60 * 24;
 var NOTIFY_INTERVAL = CHECK_INTERVAL;
-var VersionCacheSchema = z10.object({
-  lastChecked: z10.number(),
-  latestVersion: z10.string(),
-  lastNotified: z10.number().optional()
+var VersionCacheSchema = z11.object({
+  lastChecked: z11.number(),
+  latestVersion: z11.string(),
+  lastNotified: z11.number().optional()
 });
 var versionCache = new Cache("version-check.json", VersionCacheSchema);
 async function fetchLatestVersion() {
@@ -9029,10 +9058,10 @@ var handleError = (error) => {
 
 // src/commands/account.tsx
 import { jsx as jsx10 } from "react/jsx-runtime";
-var CreateAccountOptionsSchema = z11.object({
-  name: z11.string().optional(),
-  privateKey: z11.string().optional(),
-  address: z11.string().optional(),
+var CreateAccountOptionsSchema = z12.object({
+  name: z12.string().optional(),
+  privateKey: z12.string().optional(),
+  address: z12.string().optional(),
   scheme: SignatureSchemeSchema.optional()
 });
 var allSchemes = SignatureSchemeSchema.options.join(", ");
@@ -9059,12 +9088,12 @@ async function promptForAccountName(config) {
     return answer;
   }
 }
-var ListAccountOptionsSchema = z11.object({});
-var UseAccountOptionsSchema = z11.object({
-  accountName: z11.string()
+var ListAccountOptionsSchema = z12.object({});
+var UseAccountOptionsSchema = z12.object({
+  accountName: z12.string()
 });
-var DeleteAccountOptionsSchema = z11.object({
-  accountName: z11.string()
+var DeleteAccountOptionsSchema = z12.object({
+  accountName: z12.string()
 });
 function accountCommand(program) {
   const account = program.command("account").description("Manage signing accounts (addresses & keys)");
@@ -9423,9 +9452,9 @@ function accountCommand(program) {
 import * as fs4 from "fs";
 import * as fsP from "fs/promises";
 import { Readable } from "stream";
-import { z as z12 } from "zod";
-var CommitmentOptionsSchema = z12.object({
-  input: z12.string().nonempty("`--input` is required").refine(
+import { z as z13 } from "zod";
+var CommitmentOptionsSchema = z13.object({
+  input: z13.string().nonempty("`--input` is required").refine(
     async (path11) => {
       const stat4 = await fsP.stat(path11);
       return stat4.isFile();
@@ -9434,7 +9463,7 @@ var CommitmentOptionsSchema = z12.object({
       message: "`--input` must be a file"
     }
   ),
-  output: z12.string().nonempty("`--output` is required")
+  output: z13.string().nonempty("`--output` is required")
 });
 function commitmentCommand(program) {
   program.command("commitment <input> <output>").description(
@@ -9535,30 +9564,30 @@ function configCommand(program) {
 
 // src/commands/context.tsx
 import { render as render2 } from "ink";
-import { z as z14 } from "zod";
+import { z as z15 } from "zod";
 
 // src/utils/commands.ts
-import z13 from "zod";
-var AptosCommandOptionsSchema = z13.object({
-  aptosNetwork: z13.string().optional(),
+import z14 from "zod";
+var AptosCommandOptionsSchema = z14.object({
+  aptosNetwork: z14.string().optional(),
   // predefined network name
-  aptosFullnode: z13.string().url().optional(),
-  aptosFaucet: z13.string().url().optional(),
-  aptosIndexer: z13.string().url().optional(),
-  aptosPepper: z13.string().url().optional(),
-  aptosProver: z13.string().url().optional(),
-  aptosApiKey: z13.string().optional()
+  aptosFullnode: z14.string().url().optional(),
+  aptosFaucet: z14.string().url().optional(),
+  aptosIndexer: z14.string().url().optional(),
+  aptosPepper: z14.string().url().optional(),
+  aptosProver: z14.string().url().optional(),
+  aptosApiKey: z14.string().optional()
 });
 var addAptosCommandOptions = (context) => context.option(
   "--aptos-network <network>",
   `Aptos network (${shelbyNetworks.join(", ")})`
 ).option("--aptos-fullnode <url>", "Aptos fullnode URL").option("--aptos-faucet <url>", "Aptos faucet URL").option("--aptos-indexer <url>", "Aptos indexer URL").option("--aptos-pepper <url>", "Aptos pepper URL").option("--aptos-prover <url>", "Aptos prover URL").option("--aptos-api-key <key>", "Aptos API key");
-var ShelbyCommandOptionsSchema = z13.object({
+var ShelbyCommandOptionsSchema = z14.object({
   shelbyRpcEndpoint: EndpointSchema.optional(),
   shelbyIndexerEndpoint: EndpointSchema.optional(),
-  shelbyRpcApiKey: z13.string().optional(),
-  shelbyIndexerApiKey: z13.string().optional(),
-  shelbyRpcReceiverAddress: z13.string().optional()
+  shelbyRpcApiKey: z14.string().optional(),
+  shelbyIndexerApiKey: z14.string().optional(),
+  shelbyRpcReceiverAddress: z14.string().optional()
 });
 var addShelbyCommandOptions = (context) => context.option("--shelby-rpc-endpoint <url>", "Shelby RPC endpoint").option("--shelby-indexer-endpoint <url>", "Shelby indexer endpoint").option("--shelby-rpc-api-key <key>", "Shelby RPC API key").option("--shelby-indexer-api-key <key>", "Shelby indexer API key").option(
   "--shelby-rpc-receiver-address <address>",
@@ -9599,8 +9628,8 @@ function getShelbyNetworkFromOptions(options) {
     rpc_receiver_address: options.shelbyRpcReceiverAddress
   };
 }
-var CreateContextOptionsSchema = z14.object({ name: z14.string().optional() }).merge(AptosCommandOptionsSchema).merge(ShelbyCommandOptionsSchema);
-var UpdateContextOptionsSchema = z14.object({}).merge(ShelbyCommandOptionsSchema).merge(AptosCommandOptionsSchema);
+var CreateContextOptionsSchema = z15.object({ name: z15.string().optional() }).merge(AptosCommandOptionsSchema).merge(ShelbyCommandOptionsSchema);
+var UpdateContextOptionsSchema = z15.object({}).merge(ShelbyCommandOptionsSchema).merge(AptosCommandOptionsSchema);
 function contextCommand(program) {
   const context = program.command("context").description("Manage network contexts (Shelby RPC & Aptos endpoints)");
   addShelbyCommandOptions(addAptosCommandOptions(context.command("create"))).description("Create a new context").option("--name <context-name>", "Name of the context").action((options) => {
@@ -9865,7 +9894,7 @@ import { Aptos as Aptos6, AptosConfig as AptosConfig5 } from "@aptos-labs/ts-sdk
 import { Box as Box7, render as render3, Text as Text7 } from "ink";
 import SelectInput4 from "ink-select-input";
 import ora from "ora";
-import { z as z15 } from "zod";
+import { z as z16 } from "zod";
 
 // src/utils/commander-helpers.ts
 function createExitOverrideHandler(commandName, requiredArgs, requiredOptions, exampleUsage, warningMessage) {
@@ -9916,17 +9945,17 @@ function createExitOverrideHandler(commandName, requiredArgs, requiredOptions, e
 
 // src/commands/delete.tsx
 import { jsx as jsx12, jsxs as jsxs7 } from "react/jsx-runtime";
-var DeleteOptionsSchema = z15.object({
-  destination: z15.string({
+var DeleteOptionsSchema = z16.object({
+  destination: z16.string({
     required_error: "\n\u274C  Missing Required Argument\n\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n\n\u26A0\uFE0F  Missing destination blob name (argument)\n\n\u{1F4A1}  Usage:\n    shelby delete <destination-blob-name> [options]\n\n\u{1F4DD}  Example:\n    shelby delete files/my-blob.txt\n    shelby delete folder/ -r  (delete all blobs in folder)\n\n\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"
   }).min(1, "Destination blob name is required"),
-  recursive: z15.boolean().optional().default(false),
-  assumeYes: z15.boolean().optional().default(false)
+  recursive: z16.boolean().optional().default(false),
+  assumeYes: z16.boolean().optional().default(false)
 }).superRefine((data, ctx) => {
   if (data.recursive) {
     if (!data.destination.endsWith("/")) {
       ctx.addIssue({
-        code: z15.ZodIssueCode.custom,
+        code: z16.ZodIssueCode.custom,
         message: `
 \u274C  Delete Failed
 \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
@@ -9944,7 +9973,7 @@ var DeleteOptionsSchema = z15.object({
     const blobNameResult = BlobNameSchema.safeParse(data.destination);
     if (!blobNameResult.success) {
       ctx.addIssue({
-        code: z15.ZodIssueCode.custom,
+        code: z16.ZodIssueCode.custom,
         message: `
 \u274C  Delete Failed
 \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
@@ -9981,12 +10010,10 @@ async function createDeleteList(options, nodeClient, account) {
       );
     }
   } else {
-    const activeBlobs = await nodeClient.coordination.getAccountBlobs({
-      account
+    const md = await nodeClient.coordination.getBlobMetadata({
+      account,
+      name: options.destination
     });
-    const md = activeBlobs.find(
-      (blob) => stripAccountPrefix(blob.name) === options.destination
-    );
     if (!md) {
       throw new Error(
         `No active blob named '${options.destination}' was found for account ${account.toString()}. It may have expired or been deleted.`
@@ -10027,7 +10054,7 @@ function deleteCommand(program) {
           destination
         });
       } catch (error) {
-        if (error instanceof z15.ZodError) {
+        if (error instanceof z16.ZodError) {
           const firstIssue = error.issues[0];
           if (firstIssue) {
             console.log(firstIssue.message);
@@ -10198,7 +10225,7 @@ import * as path6 from "path";
 import { Readable as Readable2, Transform } from "stream";
 import { pipeline } from "stream/promises";
 import ora2 from "ora";
-import { z as z16 } from "zod";
+import { z as z17 } from "zod";
 
 // src/utils/micropayment-manager.ts
 import crypto2 from "crypto";
@@ -10560,16 +10587,16 @@ async function releaseDownloadLock() {
   } catch {
   }
 }
-var DownloadOptionsSchema = z16.object({
-  source: z16.string({
+var DownloadOptionsSchema = z17.object({
+  source: z17.string({
     required_error: "\n\u274C  Missing Required Argument\n\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n\n\u26A0\uFE0F  Missing source blob name or prefix (first argument)\n\n\u{1F4A1}  Usage:\n    shelby download <source-blob-name> <destination-path> [options]\n\n\u{1F4DD}  Examples:\n    shelby download my-blob.txt ./myfile.txt\n    shelby download my-folder/ ./my-folder/ -r\n"
   }).min(1, "Source blob name or directory prefix is required").describe("Blob name or directory prefix to download"),
-  destination: z16.string({
+  destination: z17.string({
     required_error: "\n\u274C  Missing Required Argument\n\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n\n\u26A0\uFE0F  Missing destination path (second argument)\n\n\u{1F4A1}  Usage:\n    shelby download <source-blob-name> <destination-path> [options]\n\n\u{1F4DD}  Example:\n    shelby download my-blob.txt ./myfile.txt\n"
   }).min(1, "`destination` must be a valid filepath").describe("Local path where to save the downloaded content"),
-  recursive: z16.boolean().default(false).describe("Download assuming canonical directory layout and recurse"),
-  force: z16.boolean().default(false).describe("Overwrite the destination if it already exists"),
-  allowConcurrent: z16.boolean().default(false).describe(
+  recursive: z17.boolean().default(false).describe("Download assuming canonical directory layout and recurse"),
+  force: z17.boolean().default(false).describe("Overwrite the destination if it already exists"),
+  allowConcurrent: z17.boolean().default(false).describe(
     "Allow concurrent downloads (bypasses lock file, micropayments may not work correctly)"
   )
 }).refine(
@@ -10715,12 +10742,10 @@ async function createFileList(options, nodeClient, account) {
       );
     }
   } else {
-    const activeBlobs = await nodeClient.coordination.getAccountBlobs({
-      account
+    const md = await nodeClient.coordination.getBlobMetadata({
+      account,
+      name: options.source
     });
-    const md = activeBlobs.find(
-      (blob) => stripAccountPrefix(blob.name) === options.source
-    );
     if (!md) {
       throw new Error(
         `No active blob named '${options.source}' was found for account ${account.toString()}. It may have expired or been deleted.
@@ -10796,7 +10821,7 @@ function downloadCommand(program) {
           destination
         });
       } catch (error) {
-        if (error instanceof z16.ZodError) {
+        if (error instanceof z17.ZodError) {
           const firstIssue = error.issues[0];
           if (firstIssue) {
             console.log(firstIssue.message);
@@ -11038,10 +11063,10 @@ function downloadCommand(program) {
 import { Network as Network9 } from "@aptos-labs/ts-sdk";
 import { Option as Option2 } from "@commander-js/extra-typings";
 import { execaSync } from "execa";
-import { z as z17 } from "zod";
-var FaucetOptionsSchema = z17.object({
-  network: z17.enum([Network9.SHELBYNET]).optional(),
-  open: z17.boolean().optional().default(true)
+import { z as z18 } from "zod";
+var FaucetOptionsSchema = z18.object({
+  network: z18.enum([Network9.SHELBYNET]).optional(),
+  open: z18.boolean().optional().default(true)
 });
 function faucetCommand(program) {
   program.command("faucet").description("Open the Shelby faucet web page to request tokens").addOption(
@@ -11265,10 +11290,10 @@ import ignore from "ignore";
 import { Box as Box8, render as render5, Text as Text8 } from "ink";
 import SelectInput5 from "ink-select-input";
 import ora3 from "ora";
-import { z as z18 } from "zod";
+import { z as z19 } from "zod";
 import { jsx as jsx14, jsxs as jsxs8 } from "react/jsx-runtime";
 var normBlobName2 = (i, f, b) => normBlobName(path8, i, f, b);
-var flexibleDateSchema = z18.string().transform((val, ctx) => {
+var flexibleDateSchema = z19.string().transform((val, ctx) => {
   const now = /* @__PURE__ */ new Date();
   let parsedDate = null;
   if (/^\d+$/.test(val)) {
@@ -11291,7 +11316,7 @@ var flexibleDateSchema = z18.string().transform((val, ctx) => {
   }
   if (!parsedDate || Number.isNaN(parsedDate.getTime())) {
     ctx.addIssue({
-      code: z18.ZodIssueCode.custom,
+      code: z19.ZodIssueCode.custom,
       message: `
 \u274C  Upload Failed
 \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
@@ -11305,11 +11330,11 @@ var flexibleDateSchema = z18.string().transform((val, ctx) => {
 
 \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500`
     });
-    return z18.NEVER;
+    return z19.NEVER;
   }
   if (parsedDate.getTime() <= now.getTime()) {
     ctx.addIssue({
-      code: z18.ZodIssueCode.custom,
+      code: z19.ZodIssueCode.custom,
       message: `
 \u274C  Upload Failed
 \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
@@ -11321,26 +11346,26 @@ var flexibleDateSchema = z18.string().transform((val, ctx) => {
 
 \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500`
     });
-    return z18.NEVER;
+    return z19.NEVER;
   }
   return parsedDate;
 });
-var UploadOptionsSchema = z18.object({
-  source: z18.string({
+var UploadOptionsSchema = z19.object({
+  source: z19.string({
     required_error: '\n\u274C  Missing Required Argument\n\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n\n\u26A0\uFE0F  Missing source file or directory path (first argument)\n\n\u{1F4A1}  Usage:\n    shelby upload <source-file-or-directory> <destination-blob-name> [options]\n\n\u{1F4DD}  Examples:\n    shelby upload ./myfile.txt my-blob.txt -e tomorrow\n    shelby upload ./my-folder/ my-folder/ -r -e "next week"\n\n\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500'
   }).min(1, "Source file or directory path is required"),
-  destination: z18.string({
+  destination: z19.string({
     required_error: "\n\u274C  Missing Required Argument\n\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n\n\u26A0\uFE0F  Missing destination blob name (second argument)\n\n\u{1F4A1}  Usage:\n    shelby upload <source-file-or-directory> <destination-blob-name> [options]\n\n\u{1F4DD}  Example:\n    shelby upload ./myfile.txt files/my-blob.txt -e tomorrow\n\n\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"
   }).min(1, "Destination blob name is required"),
   expiration: flexibleDateSchema,
-  recursive: z18.boolean().optional().default(false),
-  assumeYes: z18.boolean().optional().default(false),
-  outputCommitments: z18.string().optional()
+  recursive: z19.boolean().optional().default(false),
+  assumeYes: z19.boolean().optional().default(false),
+  outputCommitments: z19.string().optional()
 }).superRefine(async (data, ctx) => {
   const stats = await fs9.stat(data.source);
   if (!stats.isFile() && !stats.isDirectory()) {
     ctx.addIssue({
-      code: z18.ZodIssueCode.custom,
+      code: z19.ZodIssueCode.custom,
       message: "\n\u274C  Upload Failed\n\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n\n\u26A0\uFE0F  Source path must be a file or directory\n\n\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500",
       path: ["source"]
     });
@@ -11349,7 +11374,7 @@ var UploadOptionsSchema = z18.object({
   if (stats.isDirectory()) {
     if (!data.destination.endsWith("/")) {
       ctx.addIssue({
-        code: z18.ZodIssueCode.custom,
+        code: z19.ZodIssueCode.custom,
         message: `
 \u274C  Upload Failed
 \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
@@ -11367,7 +11392,7 @@ var UploadOptionsSchema = z18.object({
     const blobNameResult = BlobNameSchema.safeParse(data.destination);
     if (!blobNameResult.success) {
       ctx.addIssue({
-        code: z18.ZodIssueCode.custom,
+        code: z19.ZodIssueCode.custom,
         message: `
 \u274C  Upload Failed
 \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
@@ -11539,7 +11564,7 @@ function uploadCommand(program) {
           destination
         });
       } catch (error) {
-        if (error instanceof z18.ZodError) {
+        if (error instanceof z19.ZodError) {
           const firstIssue = error.issues[0];
           if (firstIssue) {
             console.log(firstIssue.message);