@shelby-protocol/sdk 0.0.1-experimental.4 → 0.0.2

package/dist/{chunk-GGYTHP5F.mjs → chunk-FIFKKWXV.mjs}

@@ -1,9 +1,11 @@
 import {
-  ERASURE_K,
-  ERASURE_M,
-  getChunkSizeBytes,
-  getChunksetSizeBytes
-} from "./chunk-D2FERD4A.mjs";
+  DEFAULT_CHUNKSET_SIZE_BYTES,
+  DEFAULT_CHUNK_SIZE_BYTES
+} from "./chunk-APML3CGJ.mjs";
+import {
+  DEFAULT_ERASURE_K,
+  DEFAULT_ERASURE_N
+} from "./chunk-ZPW742E7.mjs";
 
 // src/core/layout.ts
 import { AccountAddress } from "@aptos-labs/ts-sdk";
@@ -17,9 +19,10 @@ var ChunkKey = class _ChunkKey {
     this.blobName = blobName;
     this.chunksetIdx = chunksetIdx;
     this.chunkIdx = chunkIdx;
-    const N = ERASURE_K + ERASURE_M;
-    if (chunkIdx >= N) {
-      throw new Error(`Cannot create a chunk with idx ${chunkIdx}. M+K=${N}`);
+    if (chunkIdx >= DEFAULT_ERASURE_N) {
+      throw new Error(
+        `Cannot create a chunk with idx ${chunkIdx}. M+K=${DEFAULT_ERASURE_N}`
+      );
     }
   }
   key() {
@@ -27,14 +30,14 @@ var ChunkKey = class _ChunkKey {
   }
   // Returns the range in the blob that this key represents, or "partity" if this is parity chunk.
   range() {
-    if (this.chunkIdx >= ERASURE_K) {
+    if (this.chunkIdx >= DEFAULT_ERASURE_K) {
       return "parity";
     }
-    const chunksetStart = this.chunksetIdx * getChunksetSizeBytes();
-    const chunkStart = chunksetStart + this.chunkIdx * getChunkSizeBytes();
+    const chunksetStart = this.chunksetIdx * DEFAULT_CHUNKSET_SIZE_BYTES;
+    const chunkStart = chunksetStart + this.chunkIdx * DEFAULT_CHUNK_SIZE_BYTES;
     return {
       start: chunkStart,
-      end: chunkStart + getChunkSizeBytes()
+      end: chunkStart + DEFAULT_CHUNK_SIZE_BYTES
     };
   }
   static fromJSON(json) {
@@ -58,18 +61,17 @@ function roundSize(size) {
   let ret = 0;
   let remain = size;
   while (remain > 0) {
-    ret += getChunksetSizeBytes();
-    remain -= getChunksetSizeBytes();
+    ret += DEFAULT_CHUNKSET_SIZE_BYTES;
+    remain -= DEFAULT_CHUNKSET_SIZE_BYTES;
   }
   return ret;
 }
 function allChunksForBlob(account, blobName, _size) {
   const ret = [];
   const size = roundSize(_size);
-  const nChunksets = size / getChunksetSizeBytes();
+  const nChunksets = size / DEFAULT_CHUNKSET_SIZE_BYTES;
   for (let chunksetIdx = 0; chunksetIdx < nChunksets; ++chunksetIdx) {
-    const n = ERASURE_K + ERASURE_M;
-    for (let chunkIdx = 0; chunkIdx < n; ++chunkIdx) {
+    for (let chunkIdx = 0; chunkIdx < DEFAULT_ERASURE_N; ++chunkIdx) {
       ret.push(new ChunkKey(account, blobName, chunksetIdx, chunkIdx));
     }
   }

package/dist/chunk-HPVCKAN2.mjs

@@ -0,0 +1,41 @@
+// src/core/constants.ts
+import { Network } from "@aptos-labs/ts-sdk";
+var DEFAULT_PROJECT_NAME = "shelby";
+var DEFAULT_PROJECT_DESCRIPTION = "High performance, decentralized storage";
+var NetworkToShelbyRPCBaseUrl = {
+  [Network.SHELBYNET]: "https://api.shelbynet.shelby.xyz/shelby",
+  [Network.DEVNET]: void 0,
+  [Network.TESTNET]: void 0,
+  [Network.MAINNET]: void 0,
+  [Network.LOCAL]: void 0,
+  [Network.CUSTOM]: void 0
+};
+var NetworkToShelbyBlobIndexerBaseUrl = {
+  [Network.SHELBYNET]: "https://api.shelbynet.aptoslabs.com/nocode/v1/public/cmforrguw0042s601fn71f9l2/v1/graphql",
+  [Network.DEVNET]: void 0,
+  [Network.TESTNET]: void 0,
+  [Network.MAINNET]: void 0,
+  [Network.LOCAL]: void 0,
+  [Network.CUSTOM]: void 0
+};
+var SHELBY_DEPLOYER = "0xc63d6a5efb0080a6029403131715bd4971e1149f7cc099aac69bb0069b3ddbf5";
+var TOKEN_DEPLOYER = "0x33009e852be7f93762dd0bf303383c2cb2c5cab7a30d8238ca5f9f177ae75124";
+var TOKEN_OBJECT_ADDRESS = "0x249f5c642a63885ff88a5113b3ba0079840af5a1357706f8c7f3bfc5dd12511f";
+var SHELBYUSD_TOKEN_ADDRESS = TOKEN_OBJECT_ADDRESS;
+var SHELBYUSD_TOKEN_MODULE = "shelby_usd";
+var SHELBYUSD_TOKEN_NAME = "ShelbyUSD";
+var SHELBYUSD_TOKEN_TYPE = `${TOKEN_OBJECT_ADDRESS}::${SHELBYUSD_TOKEN_MODULE}::${SHELBYUSD_TOKEN_NAME}`;
+
+export {
+  DEFAULT_PROJECT_NAME,
+  DEFAULT_PROJECT_DESCRIPTION,
+  NetworkToShelbyRPCBaseUrl,
+  NetworkToShelbyBlobIndexerBaseUrl,
+  SHELBY_DEPLOYER,
+  TOKEN_DEPLOYER,
+  TOKEN_OBJECT_ADDRESS,
+  SHELBYUSD_TOKEN_ADDRESS,
+  SHELBYUSD_TOKEN_MODULE,
+  SHELBYUSD_TOKEN_NAME,
+  SHELBYUSD_TOKEN_TYPE
+};

package/dist/chunk-KBUWZXFA.mjs

@@ -0,0 +1,92 @@
+// src/core/utils.ts
+import { Hex } from "@aptos-labs/ts-sdk";
+async function* readInChunks(input, chunkSize) {
+  let idx = 0;
+  if (isReadableStream(input)) {
+    const reader = input.getReader();
+    let buffer = new Uint8Array(chunkSize);
+    let bufferWriteOffset = 0;
+    try {
+      while (true) {
+        const { value, done } = await reader.read();
+        if (done) break;
+        if (value === void 0) continue;
+        let srcOffset = 0;
+        while (srcOffset < value.length) {
+          const remainingCapacity = chunkSize - bufferWriteOffset;
+          const bytesToCopy = Math.min(
+            remainingCapacity,
+            value.length - srcOffset
+          );
+          buffer.set(
+            value.subarray(srcOffset, srcOffset + bytesToCopy),
+            bufferWriteOffset
+          );
+          bufferWriteOffset += bytesToCopy;
+          srcOffset += bytesToCopy;
+          if (bufferWriteOffset >= chunkSize) {
+            yield [idx++, buffer];
+            buffer = new Uint8Array(chunkSize);
+            bufferWriteOffset = 0;
+          }
+        }
+      }
+    } finally {
+      reader.releaseLock();
+    }
+    if (bufferWriteOffset > 0) {
+      yield [idx++, buffer.subarray(0, bufferWriteOffset)];
+    }
+    return;
+  }
+  const view = toUint8Array(input);
+  for (let offset = 0; offset < view.byteLength; offset += chunkSize) {
+    yield [
+      idx++,
+      view.subarray(offset, Math.min(offset + chunkSize, view.byteLength))
+    ];
+  }
+}
+function zeroPadBytes(buffer, desiredLength) {
+  if (buffer.byteLength === desiredLength) {
+    return buffer;
+  }
+  if (buffer.byteLength > desiredLength) {
+    return buffer.subarray(0, desiredLength);
+  }
+  const paddedBuffer = new Uint8Array(desiredLength);
+  paddedBuffer.set(buffer);
+  return paddedBuffer;
+}
+async function concatHashes(parts) {
+  const chunks = parts.map((part) => Hex.fromHexInput(part).toUint8Array());
+  const totalLength = chunks.reduce((sum, chunk) => sum + chunk.byteLength, 0);
+  const combined = new Uint8Array(totalLength);
+  let offset = 0;
+  for (const chunk of chunks) {
+    combined.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return Hex.fromHexInput(
+    new Uint8Array(await crypto.subtle.digest("SHA-256", combined))
+  );
+}
+function isReadableStream(value) {
+  return typeof value === "object" && value !== null && "getReader" in value && typeof value.getReader === "function";
+}
+function toUint8Array(view) {
+  return view instanceof Uint8Array ? view : new Uint8Array(view.buffer, view.byteOffset, view.byteLength);
+}
+function buildRequestUrl(path, baseUrl) {
+  const baseHasSlash = baseUrl.endsWith("/");
+  const safeBase = baseHasSlash ? baseUrl : `${baseUrl}/`;
+  const safePath = path.replace(/^\/+/, "");
+  return new URL(safePath, safeBase);
+}
+
+export {
+  readInChunks,
+  zeroPadBytes,
+  concatHashes,
+  buildRequestUrl
+};

package/dist/{chunk-C33H3C3N.mjs → chunk-LSNN4V5F.mjs}

@@ -1,6 +1,6 @@
 import {
   ShelbyClient
-} from "./chunk-QM5BVKLD.mjs";
+} from "./chunk-QP2C6ORP.mjs";
 
 // src/node/clients/ShelbyNodeClient.ts
 var ShelbyNodeClient = class extends ShelbyClient {

package/dist/chunk-LTV26KU4.mjs

@@ -0,0 +1,141 @@
+import {
+  concatHashes,
+  readInChunks,
+  zeroPadBytes
+} from "./chunk-KBUWZXFA.mjs";
+import {
+  DEFAULT_CHUNKSET_SIZE_BYTES
+} from "./chunk-APML3CGJ.mjs";
+import {
+  DEFAULT_ERASURE_K,
+  DEFAULT_ERASURE_M
+} from "./chunk-ZPW742E7.mjs";
+
+// src/core/commitments.ts
+import { z } from "zod";
+var ChunksetCommitmentSchema = z.object({
+  // Chunkset root (vector commitment of child chunks)
+  chunkset_root: z.string().nullable(),
+  // the size is known statically from the current configuration
+  chunk_commitments: z.array(z.string())
+}).refine(
+  (data) => {
+    return data.chunk_commitments.length === 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;
+}
+
+export {
+  ChunksetCommitmentSchema,
+  expectedTotalChunksets,
+  BlobCommitmentsSchema,
+  generateCommitments
+};

package/dist/{chunk-2FF5FICZ.mjs → chunk-NRNVAY72.mjs}

@@ -1,12 +1,18 @@
-import {
-  BlobNameSchema
-} from "./chunk-GGYTHP5F.mjs";
-import {
-  DEFAULT_SHELBY_BASE_URL
-} from "./chunk-D2FERD4A.mjs";
 import {
   sleep
 } from "./chunk-I6NG5GNL.mjs";
+import {
+  getShelbyIndexerClient
+} from "./chunk-75VHXY5P.mjs";
+import {
+  buildRequestUrl
+} from "./chunk-KBUWZXFA.mjs";
+import {
+  NetworkToShelbyRPCBaseUrl
+} from "./chunk-HPVCKAN2.mjs";
+import {
+  BlobNameSchema
+} from "./chunk-FIFKKWXV.mjs";
 
 // src/core/clients/ShelbyRPCClient.ts
 import { AccountAddress } from "@aptos-labs/ts-sdk";
@@ -15,32 +21,43 @@ function encodeURIComponentKeepSlashes(str) {
 }
 var ShelbyRPCClient = class {
   baseUrl;
+  apiKey;
+  rpcConfig;
+  indexer;
   /**
-   * The ShelbyRPCClient is used to interact with the Shelby RPC node. This
-   * includes functions like uploading blobs after they have been committed to the
-   * blockchain and downloading blobs.
+   * Creates a new ShelbyRPCClient for interacting with Shelby RPC nodes.
+   * This client handles blob storage operations including upload and download.
    *
-   * @param config.aptos.config - The Aptos config.
-   * @param config.shelby.baseUrl - The base URL of the Shelby RPC node.
+   * @param config - The client configuration object.
+   * @param config.network - The Shelby network to use.
    *
    * @example
    * ```typescript
-   * const aptos = new Aptos(new AptosConfig({ network: Network.TESTNET }));
-   * const client = new ShelbyRPCClient({ aptos, shelby: { baseUrl: "https://api.shelby.dev" } });
+   * const client = new ShelbyRPCClient({
+   *   network: Network.SHELBYNET,
+   *   apiKey: "AG-***",
+   * });
    * ```
    */
   constructor(config) {
-    this.baseUrl = config.shelby?.baseUrl ?? DEFAULT_SHELBY_BASE_URL;
+    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(
-        `${this.baseUrl}/v1/multipart-uploads/${uploadId}/parts/${partIdx}`,
+        buildRequestUrl(
+          `/v1/multipart-uploads/${uploadId}/parts/${partIdx}`,
+          this.baseUrl
+        ),
         {
           method: "PUT",
           headers: {
-            "Content-Type": "application/octet-stream"
+            "Content-Type": "application/octet-stream",
+            ...this.apiKey ? { Authorization: `Bearer ${this.apiKey}` } : {}
           },
           body: partData
         }
@@ -54,17 +71,21 @@ var ShelbyRPCClient = class {
     throw new Error(`Failed to upload part ${partIdx}.`);
   }
   async #putBlobMultipart(account, blobName, blobData, partSize = 5 * 1024 * 1024) {
-    const startResponse = await fetch(`${this.baseUrl}/v1/multipart-uploads`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify({
-        rawAccount: account.toString(),
-        rawBlobName: blobName,
-        rawPartSize: partSize
-      })
-    });
+    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 {
@@ -84,11 +105,15 @@ var ShelbyRPCClient = class {
       await this.#uploadPart(uploadId, partIdx, partData);
     }
     const completeResponse = await fetch(
-      `${this.baseUrl}/v1/multipart-uploads/${uploadId}/complete`,
+      buildRequestUrl(
+        `/v1/multipart-uploads/${uploadId}/complete`,
+        this.baseUrl
+      ),
       {
         method: "POST",
         headers: {
-          "Content-Type": "application/json"
+          "Content-Type": "application/json",
+          ...this.apiKey ? { Authorization: `Bearer ${this.apiKey}` } : {}
         }
       }
     );
@@ -104,18 +129,23 @@ var ShelbyRPCClient = class {
     }
   }
   /**
-   * Uploads blob data to the Shelby RPC node to be stored and confirmed by storage providers. This should be performed after the blob
-   * commitments have been written to the blockchain.
+   * 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 namespace the blob is stored in (e.g. "0x1")
-   * @param params.blobName - The name of the blob (e.g. "foo/bar")
-   * @param params.blobData - The data to upload.
+   * @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, blobName: "foo/bar.txt", blobData });
+   * await client.putBlob({
+   *   account: AccountAddress.from("0x1"),
+   *   blobName: "greetings/hello.txt",
+   *   blobData
+   * });
    * ```
    */
   async putBlob(params) {
@@ -129,24 +159,42 @@ var ShelbyRPCClient = class {
   // 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).
    *
-   * @param params.account - The account namespace the blob is stored in (e.g. "0x1")
-   * @param params.blobName - The name of the blob (e.g. "foo/bar")
-   * @param params.range - The range of the blob to download.
+   * @returns A ShelbyBlob object containing the account, name, readable stream, and content length.
    *
-   * @returns A `ShelbyBlob` object containing the blob data.
+   * @throws Error if the download fails or content length doesn't match.
    *
    * @example
    * ```typescript
+   * // Download entire blob
    * const blob = await client.getBlob({
-   *   account,
-   *   blobName: "foo/bar.txt",
+   *   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 = `${this.baseUrl}/v1/blobs/${params.account.toString()}/${encodeURIComponentKeepSlashes(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();
@@ -161,7 +209,13 @@ var ShelbyRPCClient = class {
       }
       requestInit.headers = headers;
     }
-    const response = await fetch(url, requestInit);
+    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}`