@shelby-protocol/cli 0.0.4 → 0.0.6

package/README.md

@@ -33,18 +33,5 @@ shelby <command> [options]
 
 ## Binary Release
 
-### Install `Bun`
-
-On homebrew, you can do:
-
-```bash
-brew tap oven-sh/bun
-
-brew install bun
-```
-
-If you don't have homebrew, see https://bun.sh/get
-
-### Run `scripts/bun-release.sh`
-
-From `apps/cli` run `bash scripts/bun-release.sh`
+1. Bump version
+2. Run `npm publish`

package/bin/entry.js

@@ -4,7 +4,7 @@
 import { Command } from "commander";
 
 // package.json
-var version = "0.0.4";
+var version = "0.0.6";
 
 // src/commands/init.tsx
 import { render } from "ink";
@@ -444,6 +444,135 @@ var ContextWizard = ({ onComplete }) => {
   return null;
 };
 
+// src/components/UpdateContextWizard.tsx
+import { Box as Box4, Text as Text4 } from "ink";
+import TextInput4 from "ink-text-input";
+import { useEffect as useEffect4, useState as useState4 } from "react";
+
+// src/schemas/AptosNetworkSchema.ts
+import { z } from "zod";
+var AptosNetworkSchema = z.enum([
+  "mainnet",
+  "testnet",
+  "devnet",
+  "local"
+]);
+
+// src/schemas/EndpointSchema.ts
+import { z as z2 } from "zod";
+var EndpointSchema = z2.string().url("Must be a valid URL");
+
+// src/components/UpdateContextWizard.tsx
+import { jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
+var UpdateContextWizard = ({
+  contextName,
+  currentShelbyRpc,
+  currentAptosNetwork,
+  onComplete
+}) => {
+  const [step, setStep] = useState4("shelbyRpc");
+  const [shelbyRpcEndpoint, setShelbyRpcEndpoint] = useState4(currentShelbyRpc);
+  const [aptosNetwork, setAptosNetwork] = useState4(currentAptosNetwork);
+  const [error, setError] = useState4("");
+  useEffect4(() => {
+    if (step === "done") {
+      const updates = {};
+      if (shelbyRpcEndpoint !== currentShelbyRpc) {
+        updates.shelbyRpcEndpoint = shelbyRpcEndpoint;
+      }
+      if (aptosNetwork !== currentAptosNetwork) {
+        updates.aptosNetwork = aptosNetwork;
+      }
+      onComplete(updates);
+    }
+  }, [
+    step,
+    shelbyRpcEndpoint,
+    aptosNetwork,
+    currentShelbyRpc,
+    currentAptosNetwork,
+    onComplete
+  ]);
+  if (step === "shelbyRpc") {
+    return /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsxs4(Text4, { children: [
+        "Updating context: ",
+        contextName
+      ] }),
+      /* @__PURE__ */ jsxs4(Text4, { children: [
+        "Shelby RPC endpoint? (current: ",
+        currentShelbyRpc,
+        ")"
+      ] }),
+      error && /* @__PURE__ */ jsxs4(Text4, { color: "red", children: [
+        "Error: ",
+        error
+      ] }),
+      /* @__PURE__ */ jsx4(
+        TextInput4,
+        {
+          value: shelbyRpcEndpoint,
+          placeholder: currentShelbyRpc,
+          onChange: (value) => {
+            setShelbyRpcEndpoint(value);
+            setError("");
+          },
+          onSubmit: () => {
+            if (shelbyRpcEndpoint && shelbyRpcEndpoint !== currentShelbyRpc) {
+              const result = EndpointSchema.safeParse(shelbyRpcEndpoint);
+              if (!result.success) {
+                setError(result.error.errors[0].message);
+                return;
+              }
+            }
+            setError("");
+            setStep("aptosApi");
+          }
+        }
+      ),
+      /* @__PURE__ */ jsx4(Text4, { color: "gray", children: "Press Enter to continue" })
+    ] });
+  }
+  if (step === "aptosApi") {
+    return /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsxs4(Text4, { children: [
+        "Aptos network? (current: ",
+        currentAptosNetwork,
+        ")"
+      ] }),
+      error && /* @__PURE__ */ jsxs4(Text4, { color: "red", children: [
+        "Error: ",
+        error
+      ] }),
+      /* @__PURE__ */ jsx4(
+        TextInput4,
+        {
+          value: aptosNetwork,
+          placeholder: currentAptosNetwork,
+          onChange: (value) => {
+            setAptosNetwork(value);
+            setError("");
+          },
+          onSubmit: () => {
+            if (aptosNetwork && aptosNetwork !== currentAptosNetwork) {
+              const result = AptosNetworkSchema.safeParse(aptosNetwork);
+              if (!result.success) {
+                setError("Must be one of: mainnet, testnet, devnet, local");
+                return;
+              }
+            }
+            setError("");
+            setStep("done");
+          }
+        }
+      ),
+      /* @__PURE__ */ jsx4(Text4, { color: "gray", children: "Valid options: mainnet, testnet, devnet, local" }),
+      /* @__PURE__ */ jsx4(Text4, { color: "gray", children: "Press Enter to save changes" })
+    ] });
+  }
+  return null;
+};
+
 // src/utils/config.ts
 import os from "os";
 import path from "path";
@@ -455,7 +584,7 @@ import {
 } from "@aptos-labs/ts-sdk";
 import fs from "fs-extra";
 import YAML from "yaml";
-import { z } from "zod";
+import { z as z3 } from "zod";
 
 // tests/utils/mockConfig.ts
 var mockAccountAlice = generateEd25519Account();
@@ -493,20 +622,20 @@ var mockConfig = {
 var DEFAULT_CONFIG_PATH = "~/.shelby/config.yaml";
 
 // src/utils/config.ts
-var ContextSchema = z.object({
-  aptos_network: z.enum(["mainnet", "testnet", "devnet", "local"]),
-  shelby_rpc_endpoint: z.string().url()
+var ContextSchema = z3.object({
+  aptos_network: AptosNetworkSchema,
+  shelby_rpc_endpoint: EndpointSchema
 });
-var ConfigSchema = z.object({
-  contexts: z.record(ContextSchema),
-  accounts: z.record(
-    z.object({
-      address: z.string().optional(),
-      private_key: z.string({ message: "private_key must be provided" })
+var ConfigSchema = z3.object({
+  contexts: z3.record(ContextSchema),
+  accounts: z3.record(
+    z3.object({
+      address: z3.string().optional(),
+      private_key: z3.string({ message: "private_key must be provided" })
     })
   ),
-  default_context: z.string(),
-  default_account: z.string()
+  default_context: z3.string(),
+  default_account: z3.string()
 });
 function resolveConfigPath(configPath) {
   if (configPath.startsWith("~")) {
@@ -618,7 +747,7 @@ function denormBlobName(pathModule, blobPrefix, blobName, outputPrefix) {
 }
 
 // src/commands/init.tsx
-import { jsx as jsx4 } from "react/jsx-runtime";
+import { jsx as jsx5 } from "react/jsx-runtime";
 function initCommand(program) {
   program.command("init").description(
     "Bootstrap your Shelby config via an interactive wizard or flags"
@@ -690,7 +819,7 @@ function initCommand(program) {
       );
     } else {
       const { unmount } = render(
-        /* @__PURE__ */ jsx4(
+        /* @__PURE__ */ jsx5(
           InitWizard,
           {
             onComplete: (config) => {
@@ -753,8 +882,8 @@ function getChunksetSizeBytes() {
 
 // ../../packages/sdk/dist/chunk-LATCKOZE.mjs
 import { AccountAddress as AccountAddress2 } 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("/"), {
+import { z as z4 } from "zod";
+var BlobNameSchema = z4.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"
 });
 function roundSize(size) {
@@ -1335,12 +1464,12 @@ var ShelbyBlobClient = class _ShelbyBlobClient {
 };
 
 // ../../packages/sdk/dist/chunk-OG3JQI44.mjs
-import { z as z3 } from "zod";
-var ChunksetCommitmentSchema = z3.object({
+import { z as z5 } from "zod";
+var ChunksetCommitmentSchema = z5.object({
   // Chunkset root (vector commitment of child chunks)
-  chunkset_root: z3.string().nullable(),
+  chunkset_root: z5.string().nullable(),
   // the size is known statically from the current configuration
-  chunk_commitments: z3.array(z3.string())
+  chunk_commitments: z5.array(z5.string())
 }).refine(
   (data) => {
     return data.chunk_commitments.length === ERASURE_K + ERASURE_M;
@@ -1353,13 +1482,13 @@ var ChunksetCommitmentSchema = z3.object({
 function expectedTotalChunksets(rawSize) {
   return roundSize(rawSize) / getChunksetSizeBytes();
 }
-var BlobCommitmentsSchema = z3.object({
-  schema_version: z3.string(),
-  raw_data_size: z3.number(),
+var BlobCommitmentsSchema = z5.object({
+  schema_version: z5.string(),
+  raw_data_size: z5.number(),
   // FIXME I am not sure about this being here, or if it should be somewhere else
   // I deleted the blob_commitment. What's the difference?
-  blob_merkle_root: z3.string(),
-  chunkset_commitments: z3.array(ChunksetCommitmentSchema)
+  blob_merkle_root: z5.string(),
+  chunkset_commitments: z5.array(ChunksetCommitmentSchema)
 }).refine(
   (data) => {
     return expectedTotalChunksets(data.raw_data_size) === data.chunkset_commitments.length;
@@ -1377,20 +1506,20 @@ import { hashValues } from "@aptos-labs/ts-sdk";
 // src/commands/account.tsx
 import Table from "cli-table3";
 import { render as render2 } from "ink";
-import { z as z4 } from "zod";
-import { jsx as jsx5 } from "react/jsx-runtime";
-var CreateAccountOptionsSchema = z4.object({
-  name: z4.string().optional(),
-  privateKey: z4.string().optional(),
-  address: z4.string().optional(),
-  scheme: z4.union([z4.literal(ED25519_NAME), z4.literal(SECP256K1_NAME)]).optional()
+import { z as z6 } from "zod";
+import { jsx as jsx6 } from "react/jsx-runtime";
+var CreateAccountOptionsSchema = z6.object({
+  name: z6.string().optional(),
+  privateKey: z6.string().optional(),
+  address: z6.string().optional(),
+  scheme: z6.union([z6.literal(ED25519_NAME), z6.literal(SECP256K1_NAME)]).optional()
 });
-var ListAccountOptionsSchema = z4.object({});
-var UseAccountOptionsSchema = z4.object({
-  accountName: z4.string()
+var ListAccountOptionsSchema = z6.object({});
+var UseAccountOptionsSchema = z6.object({
+  accountName: z6.string()
 });
-var DeleteAccountOptionsSchema = z4.object({
-  accountName: z4.string()
+var DeleteAccountOptionsSchema = z6.object({
+  accountName: z6.string()
 });
 function accountCommand(program) {
   const account = program.command("account").description("Manage signing accounts (addresses & keys)");
@@ -1428,7 +1557,7 @@ function accountCommand(program) {
     } else {
       try {
         const { unmount } = render2(
-          /* @__PURE__ */ jsx5(
+          /* @__PURE__ */ jsx6(
             AccountWizard,
             {
               onComplete: ({
@@ -1533,23 +1662,21 @@ function accountCommand(program) {
     const configPath = program.opts().configFile;
     try {
       const config = loadConfig(configPath);
+      const accountName = program.opts().account || config.default_account;
       const shelbyConfig = getCurrentShelbyConfig(config, {
         context: program.opts().context
       });
-      const activeAccount = getCurrentAccount(
-        config,
-        program.opts().account
-      ).account;
+      const activeAccount = getCurrentAccount(config, accountName).account;
       const aptos = new Aptos3(shelbyConfig.aptos.config);
       const blobClient = new ShelbyBlobClient({ aptos });
       console.log(
-        `\u{1F50D} Retrieving blobs for ${activeAccount.toString()} (${activeAccount.accountAddress.toString()})`
+        `\u{1F50D} Retrieving blobs for ${accountName} (${activeAccount.accountAddress.toString()})`
       );
       const blobs = await blobClient.getAccountBlobs({
         account: activeAccount.accountAddress
       });
       console.log(
-        `\u2705 Retrieved ${blobs.length} blobs for ${activeAccount.toString()}`
+        `\u2705 Retrieved ${blobs.length} blobs for ${accountName} (${activeAccount.accountAddress.toString()})`
       );
       const table = new Table({
         head: [
@@ -1594,13 +1721,18 @@ function accountCommand(program) {
 // src/commands/context.tsx
 import Table2 from "cli-table3";
 import { render as render3 } from "ink";
-import { z as z5 } from "zod";
-import { jsx as jsx6 } from "react/jsx-runtime";
-var CreateContextOptionsSchema = z5.object({
-  name: z5.string().optional(),
-  shelbyRpcEndpoint: z5.string().optional(),
-  aptosNetwork: z5.enum(["mainnet", "testnet", "devnet", "local"]).optional()
-  // TODO maybe also indexer endpoints...
+import { z as z7 } from "zod";
+import { jsx as jsx7 } from "react/jsx-runtime";
+var CreateContextOptionsSchema = z7.object({
+  name: z7.string().optional(),
+  shelbyRpcEndpoint: EndpointSchema.optional(),
+  aptosNetwork: AptosNetworkSchema.optional()
+  // TODO: Add support for custom endpoints objects
+});
+var UpdateContextOptionsSchema = z7.object({
+  shelbyRpcEndpoint: EndpointSchema.optional(),
+  aptosNetwork: AptosNetworkSchema.optional()
+  // TODO: Add support for custom endpoints objects
 });
 function contextCommand(program) {
   const context = program.command("context").description("Manage network contexts (Shelby RPC & Aptos endpoints)");
@@ -1629,7 +1761,7 @@ function contextCommand(program) {
       return;
     }
     const { unmount } = render3(
-      /* @__PURE__ */ jsx6(
+      /* @__PURE__ */ jsx7(
         ContextWizard,
         {
           onComplete: ({
@@ -1650,6 +1782,59 @@ function contextCommand(program) {
       )
     );
   });
+  context.command("update").description("Update an existing context").argument("<context-name>", "Name of the context to update").option("--shelby-rpc-endpoint <url>", "URL of the Shelby RPC service").option("--aptos-network <network>", "Aptos network").action((contextName, options) => {
+    UpdateContextOptionsSchema.parse(options);
+    const { shelbyRpcEndpoint, aptosNetwork } = options;
+    const configPath = program.opts().configFile;
+    let config;
+    try {
+      config = loadConfig(configPath);
+    } catch (error) {
+      console.error(`Error loading config: ${error.message}`);
+      process.exit(1);
+    }
+    if (!config.contexts[contextName]) {
+      console.error(`Error: Context '${contextName}' not found`);
+      process.exit(1);
+    }
+    const currentContext = config.contexts[contextName];
+    if (shelbyRpcEndpoint || aptosNetwork) {
+      if (shelbyRpcEndpoint) {
+        config.contexts[contextName].shelby_rpc_endpoint = shelbyRpcEndpoint;
+      }
+      if (aptosNetwork) {
+        config.contexts[contextName].aptos_network = aptosNetwork;
+      }
+      saveConfig(config, configPath);
+      console.log(`\u2705 Context '${contextName}' updated successfully`);
+      return;
+    }
+    const { unmount } = render3(
+      /* @__PURE__ */ jsx7(
+        UpdateContextWizard,
+        {
+          contextName,
+          currentShelbyRpc: currentContext.shelby_rpc_endpoint,
+          currentAptosNetwork: currentContext.aptos_network,
+          onComplete: ({
+            shelbyRpcEndpoint: shelbyRpcEndpoint2,
+            aptosNetwork: aptosNetwork2
+          }) => {
+            if (shelbyRpcEndpoint2) {
+              config.contexts[contextName].shelby_rpc_endpoint = shelbyRpcEndpoint2;
+            }
+            if (aptosNetwork2) {
+              config.contexts[contextName].aptos_network = aptosNetwork2;
+            }
+            saveConfig(config, configPath);
+            console.log(`\u2705 Context '${contextName}' updated successfully`);
+            unmount();
+            process.exit(0);
+          }
+        }
+      )
+    );
+  });
   context.command("list").description("List all contexts in a table").action(() => {
     const configPath = program.opts().configFile;
     let config;
@@ -1729,16 +1914,16 @@ import { Transform as Transform2 } from "stream";
 import { pipeline } from "stream/promises";
 import { Aptos as Aptos4 } from "@aptos-labs/ts-sdk";
 import ora from "ora";
-import { z as z6 } from "zod";
+import { z as z8 } from "zod";
 var denormBlobName2 = (a, b, c) => denormBlobName(path3, a, b, c);
 var endsWithDirectorySeparator = (filePath) => {
   return filePath.endsWith("/") || filePath.endsWith("\\") || filePath.endsWith(path3.sep);
 };
-var DownloadOptionsSchema = z6.object({
-  input: z6.string().min(1, "Input must be a valid blob name or directory prefix").describe("Blob name or directory prefix to download"),
-  output: z6.string().min(1, "Output must be a valid filepath").describe("Local path where to save the downloaded content"),
-  recursive: z6.boolean().default(false).describe("Download assuming canonical directory layout and recurse"),
-  force: z6.boolean().default(false).describe("Overwrite the output if it already exists")
+var DownloadOptionsSchema = z8.object({
+  input: z8.string().min(1, "Input must be a valid blob name or directory prefix").describe("Blob name or directory prefix to download"),
+  output: z8.string().min(1, "Output must be a valid filepath").describe("Local path where to save the downloaded content"),
+  recursive: z8.boolean().default(false).describe("Download assuming canonical directory layout and recurse"),
+  force: z8.boolean().default(false).describe("Overwrite the output if it already exists")
 }).refine(
   (data) => {
     if (data.recursive) {
@@ -1982,15 +2167,86 @@ function downloadCommand(program) {
 // src/commands/upload.tsx
 import * as fs3 from "fs/promises";
 import * as path4 from "path";
+import { Readable as Readable4 } from "stream";
 import { Aptos as Aptos5 } from "@aptos-labs/ts-sdk";
 import { glob } from "glob";
-import { Box as Box4, Text as Text4, render as render4 } from "ink";
+import { Box as Box5, Text as Text5, render as render4 } from "ink";
 import SelectInput2 from "ink-select-input";
 import ora2 from "ora";
-import { z as z7 } from "zod";
-import { jsx as jsx7, jsxs as jsxs4 } from "react/jsx-runtime";
+import { z as z9 } from "zod";
+
+// src/utils/errors.ts
+var ERROR_CODES = {
+  UNKNOWN_ERROR: "UNKNOWN_ERROR",
+  EBLOB_WRITE_INSUFFICIENT_FUNDS: "EBLOB_WRITE_INSUFFICIENT_FUNDS",
+  EBLOB_WRITE_CHUNKSET_ALREADY_EXISTS: "EBLOB_WRITE_CHUNKSET_ALREADY_EXISTS",
+  ECONNREFUSED: "ECONNREFUSED",
+  ENOTFOUND: "ENOTFOUND"
+};
+var DEFAULT_ERROR_RESPONSE = {
+  displayMessage: "An unknown error occurred",
+  code: ERROR_CODES.UNKNOWN_ERROR
+};
+var formatHostInfo = (error) => {
+  if (error instanceof Error) {
+    if ("hostname" in error) {
+      return `(${error.hostname})`;
+    }
+    if ("address" in error && "port" in error) {
+      return `(${error.address}:${error.port})`;
+    }
+  }
+  return void 0;
+};
+var handleError = (error) => {
+  if (error instanceof Error) {
+    if (error.message.includes(ERROR_CODES.EBLOB_WRITE_INSUFFICIENT_FUNDS)) {
+      return {
+        displayMessage: "Insufficient Shelby tokens. Please fund your account with Shelby tokens to continue.",
+        code: ERROR_CODES.EBLOB_WRITE_INSUFFICIENT_FUNDS
+      };
+    }
+    if (error.message.includes(ERROR_CODES.EBLOB_WRITE_CHUNKSET_ALREADY_EXISTS)) {
+      return {
+        displayMessage: "The blob already exists on L1.",
+        code: ERROR_CODES.EBLOB_WRITE_CHUNKSET_ALREADY_EXISTS
+      };
+    }
+    if ("code" in error) {
+      if (error.code === ERROR_CODES.ECONNREFUSED) {
+        return {
+          displayMessage: `Could not connect to the Shelby RPC endpoint. Please check that the endpoint you are using is correct ${formatHostInfo(error) ?? ""}.`,
+          code: ERROR_CODES.ECONNREFUSED
+        };
+      }
+      if (error.code === ERROR_CODES.ENOTFOUND) {
+        return {
+          displayMessage: `Could not connect to the Shelby RPC endpoint. Please check that the endpoint you are using is correct ${formatHostInfo(error) ?? ""}.`,
+          code: ERROR_CODES.ENOTFOUND
+        };
+      }
+    }
+    if (error.cause instanceof AggregateError) {
+      const firstKnownError = error.cause.errors.find((error2) => {
+        const handledError = handleError(error2);
+        return handledError.code !== ERROR_CODES.UNKNOWN_ERROR;
+      });
+      if (firstKnownError) return handleError(firstKnownError);
+    }
+    if (error.cause instanceof Error) {
+      return handleError(error.cause);
+    }
+  }
+  return {
+    displayMessage: `An unknown error occurred ${error instanceof Error ? `: ${error.message}` : ""}`,
+    code: ERROR_CODES.UNKNOWN_ERROR
+  };
+};
+
+// src/commands/upload.tsx
+import { jsx as jsx8, jsxs as jsxs5 } from "react/jsx-runtime";
 var normBlobName2 = (i, f, b) => normBlobName(path4, i, f, b);
-var flexibleDateSchema = z7.string().transform((val) => {
+var flexibleDateSchema = z9.string().transform((val) => {
   if (/^\d+$/.test(val)) {
     const timestamp = Number.parseInt(val, 10);
     if (timestamp > 0 && timestamp < 4102444800) {
@@ -2003,18 +2259,18 @@ var flexibleDateSchema = z7.string().transform((val) => {
   }
   return ret;
 });
-var UploadOptionsSchema = z7.object({
-  input: z7.string().nonempty("`--input` is required"),
-  output: z7.string().nonempty("`output` is required"),
+var UploadOptionsSchema = z9.object({
+  input: z9.string().nonempty("`--input` is required"),
+  output: z9.string().nonempty("`output` is required"),
   expiration: flexibleDateSchema,
-  recursive: z7.boolean().optional().default(false),
-  assumeYes: z7.boolean().optional().default(false),
-  outputCommitments: z7.string().optional()
+  recursive: z9.boolean().optional().default(false),
+  assumeYes: z9.boolean().optional().default(false),
+  outputCommitments: z9.string().optional()
 }).superRefine(async (data, ctx) => {
   const stats = await fs3.stat(data.input);
   if (!stats.isFile() && !stats.isDirectory()) {
     ctx.addIssue({
-      code: z7.ZodIssueCode.custom,
+      code: z9.ZodIssueCode.custom,
       message: "`--input` must be a file or a directory",
       path: ["input"]
     });
@@ -2023,7 +2279,7 @@ var UploadOptionsSchema = z7.object({
   if (stats.isDirectory()) {
     if (!data.output.endsWith("/")) {
       ctx.addIssue({
-        code: z7.ZodIssueCode.custom,
+        code: z9.ZodIssueCode.custom,
         message: "When input is a directory, output must end with '/'",
         path: ["output"]
       });
@@ -2032,7 +2288,7 @@ var UploadOptionsSchema = z7.object({
     const blobNameResult = BlobNameSchema.safeParse(data.output);
     if (!blobNameResult.success) {
       ctx.addIssue({
-        code: z7.ZodIssueCode.custom,
+        code: z9.ZodIssueCode.custom,
         message: "When input is a file, output must be a valid blob name (cannot end with '/')",
         path: ["output"]
       });
@@ -2081,9 +2337,9 @@ function computeCost(filelist) {
   return 1e8 * filelist.length;
 }
 function uploadCommand(program) {
-  program.command("upload <input> <output>").description("Upload a file or directory to the shelby RPC in the config.").option(
+  program.command("upload <input> <output>").description("Upload a file or directory to the shelby RPC in the config.").requiredOption(
     "-e, --expiration <datetime>",
-    "Time at which this blob will expire"
+    "UNIX Timestamp at which this blob will expire"
   ).option("-r, --recursive", "If uploading a directory, recurse").option(
     "--assume-yes",
     "Do not prompt interactively, assume yes for any questions"
@@ -2117,13 +2373,13 @@ function uploadCommand(program) {
     if (!validatedOptions.assumeYes) {
       const shouldContinue = await new Promise((resolve2) => {
         const { unmount } = render4(
-          /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", children: [
-            /* @__PURE__ */ jsxs4(Text4, { children: [
+          /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", children: [
+            /* @__PURE__ */ jsxs5(Text5, { children: [
               "Upload will cost ",
               cost,
               ". Continue?"
             ] }),
-            /* @__PURE__ */ jsx7(
+            /* @__PURE__ */ jsx8(
               SelectInput2,
               {
                 items: [
@@ -2185,37 +2441,69 @@ function uploadCommand(program) {
     for (const entry of filelist) {
       totalSize += entry.sizeBytes;
     }
+    let hasUploadedBlob = false;
     for (const entry of filelist) {
       spinner.text = `Reading ${entry.filename}.. (Overall: ${formatProgressPercent()}%, ${formatProgressRate()} MiB/s)`;
-      const blobData = await fs3.readFile(entry.filename);
-      if (blobData.length !== entry.sizeBytes) {
-        throw new Error(
-          `Size of file ${entry.filename} changed after initial scan. Original size was ${entry.sizeBytes} but it is now ${blobData.length}`
+      try {
+        const blobData = await fs3.readFile(entry.filename);
+        if (blobData.length !== entry.sizeBytes) {
+          throw new Error(
+            `Size of file ${entry.filename} changed after initial scan. Original size was ${entry.sizeBytes} but it is now ${blobData.length}`
+          );
+        }
+        spinner.text = `Committing ${entry.filename} to L1.. (Overall: ${formatProgressPercent()}%, ${formatProgressRate()} MiB/s)`;
+        const existingBlobMetadata = await shelbyBlobClient.getBlobMetadata({
+          account: activeAccount.accountAddress,
+          name: entry.blobname
+        });
+        const blobCommitments = await generateCommitments(
+          Readable4.from(blobData)
         );
+        if (!existingBlobMetadata) {
+          const { transaction: pendingWriteBlobCommitmentsTransaction } = await shelbyBlobClient.writeBlobCommitments({
+            account: activeAccount,
+            blobName: entry.blobname,
+            lifetime: validatedOptions.expiration.getTime() * 1e3,
+            blobCommitments
+          });
+          await aptos.waitForTransaction({
+            transactionHash: pendingWriteBlobCommitmentsTransaction.hash
+          });
+        } else {
+          spinner.text = `Blob ${entry.blobname} already exists on L1, skipping commitments and uploading to Shelby RPC...`;
+        }
+        if (validatedOptions.outputCommitments) {
+          outputCommitments[entry.filename] = blobCommitments;
+        }
+        const existingBlobChunks = await shelbyBlobClient.getBlobChunks({
+          account: activeAccount.accountAddress,
+          name: entry.blobname
+        });
+        if (existingBlobChunks.length === 0) {
+          console.error(
+            `Blob ${entry.blobname} does not exist on L1, an error occurred when uploading commitments...`
+          );
+          process.exit(1);
+        }
+        if (!existingBlobChunks.every(
+          (chunk) => chunk.location.variant === "stored"
+        )) {
+          spinner.text = `Uploading ${entry.filename} to Shelby RPC.. (Overall: ${formatProgressPercent()}%, ${formatProgressRate()} MiB/s)`;
+          await shelbyNodeClient.putBlob(
+            activeAccount.accountAddress,
+            entry.blobname,
+            blobData
+          );
+          hasUploadedBlob = true;
+        } else {
+          spinner.text = "All blob chunks have been stored on L1, skipping upload to Shelby RPC...";
+        }
+        amountUploaded += blobData.length;
+      } catch (error) {
+        const { displayMessage } = handleError(error);
+        spinner.fail(displayMessage);
+        process.exit(1);
       }
-      spinner.text = `Committing ${entry.filename} to L1.. (Overall: ${formatProgressPercent()}%, ${formatProgressRate()} MiB/s)`;
-      const {
-        blobCommitments,
-        transaction: pendingWriteBlobCommitmentsTransaction
-      } = await shelbyBlobClient.writeBlobCommitments({
-        account: activeAccount,
-        blobName: entry.blobname,
-        lifetime: validatedOptions.expiration.getTime() * 1e3,
-        data: blobData
-      });
-      if (validatedOptions.outputCommitments) {
-        outputCommitments[entry.filename] = blobCommitments;
-      }
-      await aptos.waitForTransaction({
-        transactionHash: pendingWriteBlobCommitmentsTransaction.hash
-      });
-      spinner.text = `Uploading ${entry.filename} to Shelby RPC.. (Overall: ${formatProgressPercent()}%, ${formatProgressRate()} MiB/s)`;
-      await shelbyNodeClient.putBlob(
-        activeAccount.accountAddress,
-        entry.blobname,
-        blobData
-      );
-      amountUploaded += blobData.length;
     }
     if (validatedOptions.outputCommitments) {
       await fs3.writeFile(
@@ -2223,18 +2511,22 @@ function uploadCommand(program) {
         JSON.stringify(outputCommitments)
       );
     }
-    spinner.succeed(
-      `Uploaded complete, ran at ${formatProgressRate()} MiB/s`
-    );
+    if (hasUploadedBlob) {
+      spinner.succeed(
+        `Uploaded complete, ran at ${formatProgressRate()} MiB/s`
+      );
+    } else {
+      spinner.succeed("Skipped upload, blob has already been uploaded.");
+    }
   });
 }
 
 // src/commands/commitment.ts
 import * as fs4 from "fs";
 import * as fsP from "fs/promises";
-import { z as z8 } from "zod";
-var CommitmentOptionsSchema = z8.object({
-  input: z8.string().nonempty("`--input` is required").refine(
+import { z as z10 } from "zod";
+var CommitmentOptionsSchema = z10.object({
+  input: z10.string().nonempty("`--input` is required").refine(
     async (path5) => {
       const stat4 = await fsP.stat(path5);
       return stat4.isFile();
@@ -2243,7 +2535,7 @@ var CommitmentOptionsSchema = z8.object({
       message: "`--input` must be a file"
     }
   ),
-  output: z8.string().nonempty("`--output` is required")
+  output: z10.string().nonempty("`--output` is required")
 });
 function commitmentCommand(program) {
   program.command("commitment").description(

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@shelby-protocol/cli",
   "type": "module",
-  "version": "0.0.4",
+  "version": "0.0.6",
   "private": false,
   "bin": {
     "shelby": "bin/entry.js"
@@ -9,9 +9,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "files": [
-    "bin/entry.js"
-  ],
+  "files": ["bin/entry.js"],
   "scripts": {
     "prepublishOnly": "pnpm run build",
     "lint": "biome check .",