@shelby-protocol/cli 0.0.12 → 0.0.13

package/bin/entry.js

@@ -4,12 +4,73 @@
 import { Command } from "commander";
 
 // package.json
-var version = "0.0.12";
+var version = "0.0.13";
 
 // src/commands/account.tsx
 import readline from "readline";
 import { Account as Account3, AptosApiError as AptosApiError2, Ed25519PrivateKey as Ed25519PrivateKey4 } from "@aptos-labs/ts-sdk";
 
+// ../../packages/sdk/dist/chunk-RBFWGDMY.mjs
+import { AptosConfig, Network } from "@aptos-labs/ts-sdk";
+var getAptosConfig = (config) => {
+  if (config.aptos) {
+    return new AptosConfig(config.aptos);
+  }
+  let aptosConfig;
+  switch (config.network) {
+    case "local":
+      aptosConfig = new AptosConfig({
+        network: Network.LOCAL
+      });
+      break;
+    case "shelbynet":
+      aptosConfig = new AptosConfig({
+        network: Network.SHELBYNET,
+        clientConfig: {
+          API_KEY: config.apiKey
+        }
+      });
+      break;
+    default:
+      throw new Error(`Unsupported network: ${config.network}`);
+  }
+  return aptosConfig;
+};
+
+// ../../packages/sdk/dist/chunk-SEXQTDX6.mjs
+import { Network as Network2 } from "@aptos-labs/ts-sdk";
+var NetworkToShelbyRPCBaseUrl = {
+  [Network2.SHELBYNET]: "https://api.shelbynet.shelby.xyz/shelby",
+  [Network2.DEVNET]: void 0,
+  [Network2.TESTNET]: void 0,
+  [Network2.MAINNET]: void 0,
+  [Network2.LOCAL]: void 0,
+  [Network2.CUSTOM]: void 0
+};
+var NetworkToShelbyBlobIndexerBaseUrl = {
+  [Network2.SHELBYNET]: "https://api.shelbynet.aptoslabs.com/nocode/v1/public/cmforrguw0042s601fn71f9l2/v1/graphql",
+  [Network2.DEVNET]: void 0,
+  [Network2.TESTNET]: void 0,
+  [Network2.MAINNET]: void 0,
+  [Network2.LOCAL]: void 0,
+  [Network2.CUSTOM]: void 0
+};
+var SHELBY_DEPLOYER = "0xc63d6a5efb0080a6029403131715bd4971e1149f7cc099aac69bb0069b3ddbf5";
+var SHELBYUSD_TOKEN_NAME = "ShelbyUSD";
+var SHELBYUSD_FA_METADATA_ADDRESS = "0x1b18363a9f1fe5e6ebf247daba5cc1c18052bb232efdc4c50f556053922d98e1";
+
+// ../../packages/sdk/dist/chunk-CTGCK3H2.mjs
+import {
+  AccountAddress,
+  Aptos,
+  Hex
+} from "@aptos-labs/ts-sdk";
+
+// ../../packages/sdk/dist/chunk-I6NG5GNL.mjs
+function sleep(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
+}
+
 // ../../node_modules/.pnpm/tslib@2.8.1/node_modules/tslib/tslib.es6.mjs
 var __assign = function() {
   __assign = Object.assign || function __assign2(t) {
@@ -3257,55 +3318,6 @@ function getSdk(client, withWrapper = defaultWrapper) {
   };
 }
 
-// ../../packages/sdk/dist/chunk-RBFWGDMY.mjs
-import { AptosConfig, Network } from "@aptos-labs/ts-sdk";
-var getAptosConfig = (config) => {
-  if (config.aptos) {
-    return new AptosConfig(config.aptos);
-  }
-  let aptosConfig;
-  switch (config.network) {
-    case "local":
-      aptosConfig = new AptosConfig({
-        network: Network.LOCAL
-      });
-      break;
-    case "shelbynet":
-      aptosConfig = new AptosConfig({
-        network: Network.SHELBYNET,
-        clientConfig: {
-          API_KEY: config.apiKey
-        }
-      });
-      break;
-    default:
-      throw new Error(`Unsupported network: ${config.network}`);
-  }
-  return aptosConfig;
-};
-
-// ../../packages/sdk/dist/chunk-SEXQTDX6.mjs
-import { Network as Network2 } from "@aptos-labs/ts-sdk";
-var NetworkToShelbyRPCBaseUrl = {
-  [Network2.SHELBYNET]: "https://api.shelbynet.shelby.xyz/shelby",
-  [Network2.DEVNET]: void 0,
-  [Network2.TESTNET]: void 0,
-  [Network2.MAINNET]: void 0,
-  [Network2.LOCAL]: void 0,
-  [Network2.CUSTOM]: void 0
-};
-var NetworkToShelbyBlobIndexerBaseUrl = {
-  [Network2.SHELBYNET]: "https://api.shelbynet.aptoslabs.com/nocode/v1/public/cmforrguw0042s601fn71f9l2/v1/graphql",
-  [Network2.DEVNET]: void 0,
-  [Network2.TESTNET]: void 0,
-  [Network2.MAINNET]: void 0,
-  [Network2.LOCAL]: void 0,
-  [Network2.CUSTOM]: void 0
-};
-var SHELBY_DEPLOYER = "0xc63d6a5efb0080a6029403131715bd4971e1149f7cc099aac69bb0069b3ddbf5";
-var SHELBYUSD_TOKEN_NAME = "ShelbyUSD";
-var SHELBYUSD_FA_METADATA_ADDRESS = "0x1b18363a9f1fe5e6ebf247daba5cc1c18052bb232efdc4c50f556053922d98e1";
-
 // ../../packages/sdk/dist/chunk-VPT45MTZ.mjs
 import { Network as Network3 } from "@aptos-labs/ts-sdk";
 
@@ -3854,14 +3866,8 @@ function getShelbyIndexerClient(config) {
   });
 }
 
-// ../../packages/sdk/dist/chunk-OTBLZL2S.mjs
-import { AccountAddress } from "@aptos-labs/ts-sdk";
-var createBlobKey = (params) => {
-  return `@${AccountAddress.from(params.account).toStringLongWithoutPrefix()}/${params.blobName}`;
-};
-
 // ../../packages/sdk/dist/chunk-KBUWZXFA.mjs
-import { Hex } from "@aptos-labs/ts-sdk";
+import { Hex as Hex2 } from "@aptos-labs/ts-sdk";
 async function* readInChunks(input, chunkSize) {
   let idx = 0;
   if (isReadableStream(input)) {
@@ -3921,7 +3927,7 @@ function zeroPadBytes(buffer, desiredLength) {
   return paddedBuffer;
 }
 async function concatHashes(parts) {
-  const chunks = parts.map((part) => Hex.fromHexInput(part).toUint8Array());
+  const chunks = parts.map((part) => Hex2.fromHexInput(part).toUint8Array());
   const totalLength = chunks.reduce((sum, chunk) => sum + chunk.byteLength, 0);
   const combined = new Uint8Array(totalLength);
   let offset = 0;
@@ -3929,7 +3935,7 @@ async function concatHashes(parts) {
     combined.set(chunk, offset);
     offset += chunk.byteLength;
   }
-  return Hex.fromHexInput(
+  return Hex2.fromHexInput(
     new Uint8Array(await crypto.subtle.digest("SHA-256", combined))
   );
 }
@@ -4125,158 +4131,435 @@ function buildClayConfig(input) {
   };
 }
 
-// ../../packages/sdk/dist/chunk-LTV26KU4.mjs
+// ../../packages/sdk/dist/chunk-FIFKKWXV.mjs
+import { AccountAddress as AccountAddress2 } from "@aptos-labs/ts-sdk";
 import { z } from "zod";
-var ChunksetCommitmentSchema = z.object({
-  // Chunkset root (vector commitment of child chunks)
-  chunkset_root: z.string().nullable(),
-  // the size is known statically from the current configuration
-  chunk_commitments: z.array(z.string())
-}).refine(
-  (data) => {
-    return data.chunk_commitments.length === 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 generateChunksetCommitments(shouldPad, chunksetIdx, chunksetData, expectedChunksetSize, provider, onChunk) {
-  const { erasure_n } = provider.config;
-  const chunkCommitments = [];
-  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}.`
-    );
-  }
-  let chunkIdx = 0;
-  for (const chunkData of chunks) {
-    if (onChunk !== void 0) {
-      await onChunk(chunksetIdx, chunkIdx, chunkData);
-    }
-    const chunkHash = await concatHashes([chunkData]);
-    chunkCommitments.push(chunkHash);
-    chunkIdx += 1;
-  }
-  const h = await concatHashes(
-    chunkCommitments.map((chunk) => chunk.toUint8Array())
-  );
-  const entry = {
-    chunkset_root: h.toString(),
-    chunk_commitments: chunkCommitments.map((chunk) => chunk.toString())
-  };
-  return { h, 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: "1.3",
-    raw_data_size: rawDataSize,
-    blob_merkle_root: (await concatHashes(
-      chunksetCommitmentHashes.map((chunk) => chunk.toUint8Array())
-    )).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;
-}
+var BlobNameSchema = z.string().min(1, "Blob name path parameter cannot be empty.").max(1024, "Blob name cannot exceed 1024 characters.").refine((name) => !name.endsWith("/"), {
+  message: "Blob name cannot end with a slash"
+});
 
-// ../../packages/sdk/dist/chunk-3QINXXV6.mjs
-import {
-  AccountAddress as AccountAddress2,
-  Aptos,
-  AptosConfig as AptosConfig2,
-  Hex as Hex2,
-  MoveVector
-} from "@aptos-labs/ts-sdk";
-var ShelbyBlobClient = class _ShelbyBlobClient {
-  aptos;
-  deployer;
+// ../../packages/sdk/dist/chunk-TEDFWEY6.mjs
+import { AccountAddress as AccountAddress3 } from "@aptos-labs/ts-sdk";
+function encodeURIComponentKeepSlashes(str) {
+  return encodeURIComponent(str).replace(/%2F/g, "/");
+}
+var ShelbyRPCClient = class {
+  baseUrl;
+  apiKey;
+  rpcConfig;
   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.
+   * 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 blobClient = new ShelbyBlobClient({
-   *   aptos: {
-   *     network: Network.SHELBYNET,
-   *     clientConfig: {
-   *       API_KEY: "AG-***",
-   *     },
-   *   },
-   * });
-   * ```
+   * 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) {
+    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);
+    }
+    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}`
+      );
+    }
+  }
+  /**
+   * 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 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 blobData = new TextEncoder().encode("Hello, world!");
+   *
+   * await client.putBlob({
+   *   account: AccountAddress.from("0x1"),
+   *   blobName: "greetings/hello.txt",
+   *   blobData
+   * });
+   * ```
+   */
+  async putBlob(params) {
+    BlobNameSchema.parse(params.blobName);
+    await this.#putBlobMultipart(
+      params.account,
+      params.blobName,
+      params.blobData
+    );
+  }
+  // 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.
+   *
+   * @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).
+   *
+   * @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.
+   *
+   * @example
+   * ```typescript
+   * // 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 }
+   * });
+   * ```
+   */
+  async getBlob(params) {
+    BlobNameSchema.parse(params.blobName);
+    const url = buildRequestUrl(
+      `/v1/blobs/${params.account.toString()}/${encodeURIComponentKeepSlashes(
+        params.blobName
+      )}`,
+      this.baseUrl
+    );
+    const requestInit = {};
+    if (params.range !== void 0) {
+      const headers = new Headers();
+      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}`);
+      }
+      requestInit.headers = headers;
+    }
+    const response = await fetch(url, {
+      ...requestInit,
+      headers: {
+        ...requestInit.headers,
+        ...this.apiKey ? { Authorization: `Bearer ${this.apiKey}` } : {}
+      }
+    });
+    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();
+      }
+    });
+    return {
+      account: AccountAddress3.from(params.account),
+      name: params.blobName,
+      readable: validatingStream,
+      contentLength: expectedContentLength
+    };
+  }
+};
+
+// ../../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-LTV26KU4.mjs
+import { z as z2 } from "zod";
+var ChunksetCommitmentSchema = z2.object({
+  // Chunkset root (vector commitment of child chunks)
+  chunkset_root: z2.string().nullable(),
+  // the size is known statically from the current configuration
+  chunk_commitments: z2.array(z2.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 = z2.object({
+  schema_version: z2.string(),
+  raw_data_size: z2.number(),
+  // FIXME I am not sure about this being here, or if it should be somewhere else
+  blob_merkle_root: z2.string(),
+  chunkset_commitments: z2.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 generateChunksetCommitments(shouldPad, chunksetIdx, chunksetData, expectedChunksetSize, provider, onChunk) {
+  const { erasure_n } = provider.config;
+  const chunkCommitments = [];
+  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}.`
+    );
+  }
+  let chunkIdx = 0;
+  for (const chunkData of chunks) {
+    if (onChunk !== void 0) {
+      await onChunk(chunksetIdx, chunkIdx, chunkData);
+    }
+    const chunkHash = await concatHashes([chunkData]);
+    chunkCommitments.push(chunkHash);
+    chunkIdx += 1;
+  }
+  const h = await concatHashes(
+    chunkCommitments.map((chunk) => chunk.toUint8Array())
+  );
+  const entry = {
+    chunkset_root: h.toString(),
+    chunk_commitments: chunkCommitments.map((chunk) => chunk.toString())
+  };
+  return { h, 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: "1.3",
+    raw_data_size: rawDataSize,
+    blob_merkle_root: (await concatHashes(
+      chunksetCommitmentHashes.map((chunk) => chunk.toUint8Array())
+    )).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-MEINKPI3.mjs
+import {
+  AccountAddress as AccountAddress5,
+  Aptos as Aptos2,
+  AptosConfig as AptosConfig2,
+  Hex as Hex3,
+  MoveVector
+} 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.
+   *
+   * @param config - The client configuration object.
+   * @param config.network - The Shelby network to use.
+   *
+   * @example
+   * ```typescript
+   * const blobClient = new ShelbyBlobClient({
+   *   aptos: {
+   *     network: Network.SHELBYNET,
+   *     clientConfig: {
+   *       API_KEY: "AG-***",
+   *     },
+   *   },
+   * });
+   * ```
    */
   constructor(config) {
     const baseAptosConfig = getAptosConfig(config);
@@ -4288,8 +4571,8 @@ var ShelbyBlobClient = class _ShelbyBlobClient {
         API_KEY: baseAptosConfig.clientConfig?.API_KEY ?? config.apiKey
       }
     });
-    this.aptos = new Aptos(aptosConfig);
-    this.deployer = config.deployer ?? AccountAddress2.fromString(SHELBY_DEPLOYER);
+    this.aptos = new Aptos2(aptosConfig);
+    this.deployer = config.deployer ?? AccountAddress5.fromString(SHELBY_DEPLOYER);
     this.indexer = getShelbyIndexerClient(config);
   }
   /**
@@ -4338,15 +4621,15 @@ var ShelbyBlobClient = class _ShelbyBlobClient {
         );
       }
       return {
-        blobMerkleRoot: Hex2.fromHexInput(
+        blobMerkleRoot: Hex3.fromHexInput(
           metadata.blob_commitment
         ).toUint8Array(),
-        owner: AccountAddress2.fromString(metadata.owner),
+        owner: AccountAddress5.fromString(metadata.owner),
         name: params.name,
         size: Number(metadata.blob_size),
         encoding,
         expirationMicros: metadata.expiration_micros,
-        sliceAddress: AccountAddress2.fromString(metadata.slice.inner),
+        sliceAddress: AccountAddress5.fromString(metadata.slice.inner),
         isWritten: metadata.is_written
       };
     } catch (error) {
@@ -4378,7 +4661,7 @@ var ShelbyBlobClient = class _ShelbyBlobClient {
     return this.getBlobs({
       where: {
         ...params.where,
-        owner: { _eq: AccountAddress2.from(params.account).toString() }
+        owner: { _eq: AccountAddress5.from(params.account).toString() }
       },
       pagination: params.pagination,
       orderBy: params.orderBy
@@ -4411,9 +4694,9 @@ var ShelbyBlobClient = class _ShelbyBlobClient {
     });
     return blobs.map(
       (blob) => ({
-        owner: AccountAddress2.from(blob.owner),
+        owner: AccountAddress5.from(blob.owner),
         name: blob.blob_name,
-        blobMerkleRoot: Hex2.fromHexInput(blob.blob_commitment).toUint8Array(),
+        blobMerkleRoot: Hex3.fromHexInput(blob.blob_commitment).toUint8Array(),
         size: Number(blob.size),
         // TODO: Add encoding when supported in NCI
         encoding: {
@@ -4422,7 +4705,7 @@ var ShelbyBlobClient = class _ShelbyBlobClient {
           ...ERASURE_CODE_AND_CHUNK_MAPPING.ClayCode_16Total_10Data_13Helper
         },
         expirationMicros: Number(blob.expires_at),
-        sliceAddress: AccountAddress2.from(blob.slice_address),
+        sliceAddress: AccountAddress5.from(blob.slice_address),
         isWritten: Boolean(Number(blob.is_written))
       })
     );
@@ -4445,7 +4728,7 @@ var ShelbyBlobClient = class _ShelbyBlobClient {
     return blob_activities.map(
       (activity) => ({
         blobName: activity.blob_name,
-        accountAddress: AccountAddress2.from(
+        accountAddress: AccountAddress5.from(
           activity.blob_name.substring(1, 65)
         ),
         type: activityTypeMapping[activity.event_type] ?? "unknown",
@@ -4513,380 +4796,104 @@ var ShelbyBlobClient = class _ShelbyBlobClient {
     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,
-        account: params.account.accountAddress,
-        blobName: params.blobName,
-        blobSize: params.size,
-        blobMerkleRoot: params.blobMerkleRoot,
-        numChunksets: expectedTotalChunksets(params.size, chunksetSize),
-        expirationMicros: params.expirationMicros
-      }),
-      sender: params.account.accountAddress
-    });
-    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()}::global_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()}::global_metadata::register_multiple_blobs`,
-      functionArguments: [
-        blobNames,
-        params.expirationMicros,
-        blobMerkleRoots,
-        blobNumChunksets,
-        blobSizes,
-        // TODO
-        0,
-        0
-      ]
-    };
-  }
-};
-
-// ../../packages/sdk/dist/chunk-FIFKKWXV.mjs
-import { AccountAddress as AccountAddress3 } 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((name) => !name.endsWith("/"), {
-  message: "Blob name cannot end with a slash"
-});
-
-// ../../packages/sdk/dist/chunk-I6NG5GNL.mjs
-function sleep(ms) {
-  return new Promise((resolve2) => setTimeout(resolve2, ms));
-}
-
-// ../../packages/sdk/dist/chunk-GKRHKR3J.mjs
-import { AccountAddress as AccountAddress4 } from "@aptos-labs/ts-sdk";
-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) {
-    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);
-    }
-    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}`
-      );
-    }
+      data: _ShelbyBlobClient.createRegisterBlobPayload({
+        deployer: this.deployer,
+        account: params.account.accountAddress,
+        blobName: params.blobName,
+        blobSize: params.size,
+        blobMerkleRoot: params.blobMerkleRoot,
+        numChunksets: expectedTotalChunksets(params.size, chunksetSize),
+        expirationMicros: params.expirationMicros
+      }),
+      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.
+   * 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.blobData - The raw blob data as a Uint8Array.
+   * @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.
    *
-   * @example
-   * ```typescript
-   * const blobData = new TextEncoder().encode("Hello, world!");
+   * @returns An Aptos transaction payload data object for the register_blob Move function.
    *
-   * await client.putBlob({
-   *   account: AccountAddress.from("0x1"),
-   *   blobName: "greetings/hello.txt",
-   *   blobData
-   * });
-   * ```
+   * @see https://github.com/shelby/shelby/blob/e08e84742cf2b80ad8bb7227deb3013398076d53/move/shelby_contract/sources/global_metadata.move#L357
    */
-  async putBlob(params) {
-    BlobNameSchema.parse(params.blobName);
-    await this.#putBlobMultipart(
-      params.account,
-      params.blobName,
-      params.blobData
-    );
+  static createRegisterBlobPayload(params) {
+    return {
+      function: `${(params.deployer ?? SHELBY_DEPLOYER).toString()}::global_metadata::register_blob`,
+      functionArguments: [
+        params.blobName,
+        params.expirationMicros,
+        MoveVector.U8(params.blobMerkleRoot),
+        params.numChunksets,
+        params.blobSize,
+        // TODO
+        0,
+        // payment tier
+        0
+        // encoding
+      ]
+    };
   }
-  // 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.
-   *
-   * @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).
-   *
-   * @returns A ShelbyBlob object containing the account, name, readable stream, and content length.
+   * Creates a transaction payload to register multiple blobs on the blockchain.
+   * This is a static helper method for constructing the Move function call payload.
    *
-   * @throws Error if the download fails or content length doesn't match.
+   * @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.
    *
-   * @example
-   * ```typescript
-   * // Download entire blob
-   * const blob = await client.getBlob({
-   *   account: AccountAddress.from("0x1"),
-   *   blobName: "documents/report.pdf"
-   * });
+   * @returns An Aptos transaction payload data object for the register_multiple_blobs Move function.
    *
-   * // Download partial content (bytes 100-199)
-   * const partial = await client.getBlob({
-   *   account: AccountAddress.from("0x1"),
-   *   blobName: "large-file.bin",
-   *   range: { start: 100, end: 199 }
-   * });
-   * ```
+   * @see https://github.com/shelby/shelby/blob/e08e84742cf2b80ad8bb7227deb3013398076d53/move/shelby_contract/sources/global_metadata.move#L357
    */
-  async getBlob(params) {
-    BlobNameSchema.parse(params.blobName);
-    const url = buildRequestUrl(
-      `/v1/blobs/${params.account.toString()}/${encodeURIComponentKeepSlashes(
-        params.blobName
-      )}`,
-      this.baseUrl
-    );
-    const requestInit = {};
-    if (params.range !== void 0) {
-      const headers = new Headers();
-      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}`);
-      }
-      requestInit.headers = headers;
-    }
-    const response = await fetch(url, {
-      ...requestInit,
-      headers: {
-        ...requestInit.headers,
-        ...this.apiKey ? { Authorization: `Bearer ${this.apiKey}` } : {}
-      }
-    });
-    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();
-      }
+  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 {
-      account: AccountAddress4.from(params.account),
-      name: params.blobName,
-      readable: validatingStream,
-      contentLength: expectedContentLength
+      function: `${(params.deployer ?? SHELBY_DEPLOYER).toString()}::global_metadata::register_multiple_blobs`,
+      functionArguments: [
+        blobNames,
+        params.expirationMicros,
+        blobMerkleRoots,
+        blobNumChunksets,
+        blobSizes,
+        // TODO
+        0,
+        0
+      ]
     };
   }
 };
 
-// ../../packages/sdk/dist/chunk-4W3FFVXZ.mjs
+// ../../packages/sdk/dist/chunk-2Y3ZLUYT.mjs
 import {
-  Aptos as Aptos2
+  Aptos as Aptos3
 } from "@aptos-labs/ts-sdk";
 var ShelbyClient = class {
   /**
@@ -4943,7 +4950,7 @@ var ShelbyClient = class {
    */
   constructor(config, provider) {
     this.config = config;
-    this.aptos = new Aptos2(getAptosConfig(config));
+    this.aptos = new Aptos3(getAptosConfig(config));
     this.coordination = new ShelbyBlobClient(config);
     this.rpc = new ShelbyRPCClient(config);
     this._provider = provider;
@@ -5039,16 +5046,29 @@ var ShelbyClient = class {
   }
 };
 
-// ../../packages/sdk/dist/chunk-MYN7KW2X.mjs
+// ../../packages/sdk/dist/chunk-X56YUBBI.mjs
 var ShelbyNodeClient = class extends ShelbyClient {
 };
 
-// ../../packages/sdk/dist/chunk-CTGCK3H2.mjs
-import {
-  AccountAddress as AccountAddress5,
-  Aptos as Aptos3,
-  Hex as Hex3
-} from "@aptos-labs/ts-sdk";
+// ../../packages/sdk/dist/chunk-7P6ASYW6.mjs
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// ../../packages/sdk/dist/chunk-A4IG6GSE.mjs
+var testUtil_exports = {};
+__export(testUtil_exports, {
+  makeChunk: () => makeChunk
+});
+function makeChunk(n) {
+  const c = Buffer.alloc(n);
+  for (let i = 0; i < n; ++i) {
+    c[i] = i % 256;
+  }
+  return c;
+}
 
 // ../../packages/sdk/dist/chunk-VRLIOKWG.mjs
 import { Network as Network4 } from "@aptos-labs/ts-sdk";
@@ -5078,26 +5098,6 @@ function getShelbyAccountExplorerUrl(network, accountAddress) {
   return `${baseUrl}/account/${accountAddress}`;
 }
 
-// ../../packages/sdk/dist/chunk-7P6ASYW6.mjs
-var __defProp = Object.defineProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-
-// ../../packages/sdk/dist/chunk-A4IG6GSE.mjs
-var testUtil_exports = {};
-__export(testUtil_exports, {
-  makeChunk: () => makeChunk
-});
-function makeChunk(n) {
-  const c = Buffer.alloc(n);
-  for (let i = 0; i < n; ++i) {
-    c[i] = i % 256;
-  }
-  return c;
-}
-
 // ../../packages/sdk/dist/chunk-C6RQ3AEU.mjs
 import { Network as Network6 } from "@aptos-labs/ts-sdk";
 function getAptosExplorerBaseUrl(network) {
@@ -7888,15 +7888,15 @@ async function createFileList(options, nodeClient, account) {
   }
   const ret = [];
   for (const blobMd of matchingBlobList) {
-    const blobNameWithoutAccount = blobMd.name.slice(1 + 64 + 1);
+    let blobname;
+    if (options.recursive) {
+      blobname = blobMd.name.slice(1 + 64 + 1);
+    } else {
+      blobname = blobMd.name;
+    }
     const entry = {
-      filename: denormBlobName2(
-        options.src,
-        blobNameWithoutAccount,
-        options.dst
-      ),
-      blobname: blobNameWithoutAccount,
-      // FIXME this is nasty
+      filename: denormBlobName2(options.src, blobname, options.dst),
+      blobname,
       sizeBytes: blobMd.size
     };
     ret.push(entry);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@shelby-protocol/cli",
   "type": "module",
-  "version": "0.0.12",
+  "version": "0.0.13",
   "private": false,
   "bin": {
     "shelby": "bin/entry.js"
@@ -39,8 +39,8 @@
     "wrap-ansi": "^9.0.2",
     "yaml": "^2.7.1",
     "zod": "^3.22.4",
-    "@shelby-protocol/sdk": "0.0.4",
-    "@shelby-protocol/clay-codes": "0.0.1"
+    "@shelby-protocol/clay-codes": "0.0.1",
+    "@shelby-protocol/sdk": "0.0.4"
   },
   "devDependencies": {
     "@types/fs-extra": "^11.0.4",