@shelby-protocol/sdk 0.0.9 → 0.2.0

package/dist/{chunk-67F5YZ25.mjs → chunk-JTXYKO3U.mjs}

@@ -1,6 +1,7 @@
 // src/core/chunk.ts
 var ChunkSizeScheme = /* @__PURE__ */ ((ChunkSizeScheme2) => {
   ChunkSizeScheme2["ChunkSet10MiB_Chunk1MiB"] = "ChunkSet10MiB_Chunk1MiB";
+  ChunkSizeScheme2["ChunkSet2MiB_Chunk1MiB"] = "ChunkSet2MiB_Chunk1MiB";
   return ChunkSizeScheme2;
 })(ChunkSizeScheme || {});
 var CHUNK_SIZE_PARAMS = {
@@ -9,6 +10,12 @@ var CHUNK_SIZE_PARAMS = {
     chunkSizeBytes: 1 * 1024 * 1024,
     // 10MiB
     chunksetSizeBytes: 10 * 1024 * 1024
+  },
+  ["ChunkSet2MiB_Chunk1MiB" /* ChunkSet2MiB_Chunk1MiB */]: {
+    // 1MiB
+    chunkSizeBytes: 1 * 1024 * 1024,
+    // 2MiB
+    chunksetSizeBytes: 2 * 1024 * 1024
   }
 };
 var DEFAULT_CHUNK_SIZE_BYTES = CHUNK_SIZE_PARAMS["ChunkSet10MiB_Chunk1MiB" /* ChunkSet10MiB_Chunk1MiB */].chunkSizeBytes;
@@ -16,6 +23,9 @@ var DEFAULT_CHUNKSET_SIZE_BYTES = CHUNK_SIZE_PARAMS["ChunkSet10MiB_Chunk1MiB" /*
 var ERASURE_CODE_AND_CHUNK_MAPPING = {
   ["ClayCode_16Total_10Data_13Helper" /* ClayCode_16Total_10Data_13Helper */]: {
     ...CHUNK_SIZE_PARAMS.ChunkSet10MiB_Chunk1MiB
+  },
+  ["ClayCode_4Total_2Data_3Helper" /* ClayCode_4Total_2Data_3Helper */]: {
+    ...CHUNK_SIZE_PARAMS.ChunkSet2MiB_Chunk1MiB
   }
 };
 

package/dist/{chunk-WJKSPJSS.mjs → chunk-KJ24NKPH.mjs}

@@ -105,6 +105,40 @@ var GetBlobActivitiesCountDocument = gql`
   }
 }
     `;
+var GetPlacementGroupSlotsDocument = gql`
+    query getPlacementGroupSlots($where: placement_group_slots_bool_exp, $orderBy: [placement_group_slots_order_by!], $limit: Int, $offset: Int) {
+  placement_group_slots(
+    where: $where
+    order_by: $orderBy
+    limit: $limit
+    offset: $offset
+  ) {
+    placement_group
+    slot_index
+    storage_provider
+    status
+    updated_at
+  }
+}
+    `;
+var GetPlacementGroupSlotsCountDocument = gql`
+    query getPlacementGroupSlotsCount($where: placement_group_slots_bool_exp) {
+  placement_group_slots_aggregate(where: $where) {
+    aggregate {
+      count
+    }
+  }
+}
+    `;
+var GetProcessorStatusDocument = gql`
+    query getProcessorStatus {
+  processor_status {
+    last_success_version
+    last_transaction_timestamp
+    last_updated
+  }
+}
+    `;
 var defaultWrapper = (action, _operationName, _operationType, _variables) => action();
 function getSdk(client, withWrapper = defaultWrapper) {
   return {
@@ -119,6 +153,15 @@ function getSdk(client, withWrapper = defaultWrapper) {
     },
     getBlobActivitiesCount(variables, requestHeaders, signal) {
       return withWrapper((wrappedRequestHeaders) => client.request({ document: GetBlobActivitiesCountDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), "getBlobActivitiesCount", "query", variables);
+    },
+    getPlacementGroupSlots(variables, requestHeaders, signal) {
+      return withWrapper((wrappedRequestHeaders) => client.request({ document: GetPlacementGroupSlotsDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), "getPlacementGroupSlots", "query", variables);
+    },
+    getPlacementGroupSlotsCount(variables, requestHeaders, signal) {
+      return withWrapper((wrappedRequestHeaders) => client.request({ document: GetPlacementGroupSlotsCountDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), "getPlacementGroupSlotsCount", "query", variables);
+    },
+    getProcessorStatus(variables, requestHeaders, signal) {
+      return withWrapper((wrappedRequestHeaders) => client.request({ document: GetProcessorStatusDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), "getProcessorStatus", "query", variables);
     }
   };
 }
@@ -134,5 +177,8 @@ export {
   GetBlobActivitiesDocument,
   GetBlobsCountDocument,
   GetBlobActivitiesCountDocument,
+  GetPlacementGroupSlotsDocument,
+  GetPlacementGroupSlotsCountDocument,
+  GetProcessorStatusDocument,
   getSdk
 };

package/dist/{chunk-WBFEX7OM.mjs → chunk-MV6FNYAU.mjs}

@@ -1,16 +1,39 @@
 import {
   getAptosConfig
-} from "./chunk-RBFWGDMY.mjs";
+} from "./chunk-AABBONAF.mjs";
 import {
   SHELBY_DEPLOYER
-} from "./chunk-SEXQTDX6.mjs";
+} from "./chunk-4ZOFT75Q.mjs";
 
-// src/node/clients/ShelbyMetadataClient.ts
+// src/core/clients/ShelbyMetadataClient.ts
 import {
   AccountAddress,
   Aptos,
   Hex
 } from "@aptos-labs/ts-sdk";
+function parseStorageProviderState(raw) {
+  switch (raw.__variant__) {
+    case "Active":
+      return {
+        variant: "Active",
+        quota: raw.quota.value,
+        stakeAtStartOfStakingEpoch: raw.stake_at_start_of_staking_epoch,
+        faulty: raw.faulty,
+        leaving: raw.leaving
+      };
+    case "Waitlisted":
+      return {
+        variant: "Waitlisted"
+      };
+    case "Frozen":
+      return {
+        variant: "Frozen",
+        frozenReason: raw.frozen_reason,
+        frozenFrom: raw.frozen_from,
+        frozenTill: raw.frozen_till
+      };
+  }
+}
 var ShelbyMetadataClient = class {
   aptos;
   deployer;
@@ -45,7 +68,7 @@ var ShelbyMetadataClient = class {
     try {
       const rawMetadata = await this.aptos.view({
         payload: {
-          function: `${this.deployer.toString()}::global_metadata::get_all_storage_providers`,
+          function: `${this.deployer.toString()}::storage_provider_registry::get_all_storage_providers`,
           functionArguments: []
         }
       });
@@ -55,7 +78,8 @@ var ShelbyMetadataClient = class {
         ipAddress: provider.ip_address,
         port: provider.port,
         blsPublicKey: Hex.fromHexInput(provider.bls_public_key).toUint8Array(),
-        failureDomain: provider.failure_domain
+        failureDomain: provider.failure_domain,
+        state: parseStorageProviderState(provider.state)
       }));
     } catch (error) {
       if (error instanceof Error && // Depending on the network, the error message may show up differently.
@@ -79,14 +103,14 @@ var ShelbyMetadataClient = class {
     try {
       const pgSizeMetadata = await this.aptos.view({
         payload: {
-          function: `${this.deployer.toString()}::global_metadata::get_number_of_placement_groups`,
+          function: `${this.deployer.toString()}::placement_group_registry::get_number_of_placement_groups`,
           functionArguments: []
         }
       });
       const finalPlacementGroupIndex = pgSizeMetadata[0] - 1;
       const addressMetadataArray = await this.aptos.view({
         payload: {
-          function: `${this.deployer.toString()}::global_metadata::get_placement_group_addresses`,
+          function: `${this.deployer.toString()}::placement_group_registry::get_placement_group_addresses`,
           functionArguments: [0, finalPlacementGroupIndex]
         }
       });

package/dist/{chunk-PZF2VTGP.mjs → chunk-NHWWORCH.mjs}

@@ -9,6 +9,7 @@ var ReedSolomonErasureCodingProvider = class {
     const erasure_k = options?.erasure_k ?? DEFAULT_ERASURE_K;
     const erasure_n = options?.erasure_n ?? DEFAULT_ERASURE_N;
     const chunkSizeBytes = options?.chunkSizeBytes ?? DEFAULT_CHUNK_SIZE_BYTES;
+    const enumIndex = -1;
     if (erasure_k <= 0)
       throw new Error("erasure_k (number of data chunks) must be > 0");
     if (erasure_n <= erasure_k)
@@ -19,7 +20,8 @@ var ReedSolomonErasureCodingProvider = class {
     this.config = {
       erasure_n,
       erasure_k,
-      chunkSizeBytes
+      chunkSizeBytes,
+      enumIndex
     };
   }
   encode(data) {

package/dist/{chunk-NLPIHQ7K.mjs → chunk-OGKZ575S.mjs}

@@ -1,12 +1,3 @@
-import {
-  DEFAULT_CHUNK_SIZE_BYTES
-} from "./chunk-67F5YZ25.mjs";
-import {
-  DEFAULT_ERASURE_D,
-  DEFAULT_ERASURE_K,
-  DEFAULT_ERASURE_N
-} from "./chunk-ZPW742E7.mjs";
-
 // src/core/erasure/clay-codes.ts
 import {
   createDecoder,
@@ -27,13 +18,7 @@ var ClayErasureCodingProvider = class _ClayErasureCodingProvider {
   /**
    * Static factory method to create an initialized ClayErasureCodingProvider
    */
-  static async create(options) {
-    const config = buildClayConfig({
-      erasure_n: options?.erasure_n ?? DEFAULT_ERASURE_N,
-      erasure_k: options?.erasure_k ?? DEFAULT_ERASURE_K,
-      erasure_d: options?.erasure_d ?? DEFAULT_ERASURE_D,
-      chunkSizeBytes: options?.chunkSizeBytes ?? DEFAULT_CHUNK_SIZE_BYTES
-    });
+  static async create(config) {
     const provider = new _ClayErasureCodingProvider(config);
     [provider.encoderCache, provider.decoderCache] = await Promise.all([
       createEncoder({
@@ -118,7 +103,7 @@ var ClayErasureCodingProvider = class _ClayErasureCodingProvider {
   }
 };
 function buildClayConfig(input) {
-  const { erasure_n, erasure_k, erasure_d, chunkSizeBytes } = input;
+  const { erasure_n, erasure_k, erasure_d, chunkSizeBytes, enumIndex } = input;
   if (erasure_n <= 0)
     throw new Error("erasure_n (total number of chunks) must be > 0");
   if (erasure_k <= 0)
@@ -140,10 +125,12 @@ function buildClayConfig(input) {
     erasure_n,
     erasure_k,
     erasure_d,
-    chunkSizeBytes
+    chunkSizeBytes,
+    enumIndex
   };
 }
 
 export {
-  ClayErasureCodingProvider
+  ClayErasureCodingProvider,
+  buildClayConfig
 };

package/dist/{chunk-5I3MBJGN.mjs → chunk-PJVWGMVI.mjs}

@@ -1,24 +1,48 @@
 import {
-  getShelbyIndexerClient
-} from "./chunk-HFGEQP5N.mjs";
+  StaleChannelStateError
+} from "./chunk-4MG4XGY4.mjs";
 import {
-  BlobNameSchema
-} from "./chunk-GY5DCVVL.mjs";
+  getShelbyIndexerClient
+} from "./chunk-CGYJLKBU.mjs";
 import {
   sleep
 } from "./chunk-I6NG5GNL.mjs";
 import {
-  buildRequestUrl
+  StaleMicropaymentErrorResponseSchema,
+  StartMultipartUploadResponseSchema
+} from "./chunk-IE6LYVIA.mjs";
+import {
+  buildRequestUrl,
+  readInChunks
 } from "./chunk-4JZO2D7T.mjs";
 import {
   NetworkToShelbyRPCBaseUrl
-} from "./chunk-SEXQTDX6.mjs";
+} from "./chunk-4ZOFT75Q.mjs";
+import {
+  BlobNameSchema
+} from "./chunk-Z4FZ7W6L.mjs";
 
 // src/core/clients/ShelbyRPCClient.ts
 import { AccountAddress } from "@aptos-labs/ts-sdk";
+var MICROPAYMENT_HEADER = "X-Shelby-Micropayment";
 function encodeURIComponentKeepSlashes(str) {
   return encodeURIComponent(str).replace(/%2F/g, "/");
 }
+function validateTotalBytes(totalBytes) {
+  if (!Number.isInteger(totalBytes) || totalBytes < 0) {
+    throw new Error("totalBytes must be a non-negative integer");
+  }
+}
+function getErrorCode(error) {
+  if (typeof error === "object" && error !== null && "code" in error && typeof error.code === "string") {
+    return error.code;
+  }
+  if (error instanceof Error) {
+    const match = error.message.match(/\bE[A-Z0-9_]+\b/);
+    return match?.[0];
+  }
+  return void 0;
+}
 var ShelbyRPCClient = class {
   baseUrl;
   apiKey;
@@ -47,30 +71,53 @@ var ShelbyRPCClient = class {
   }
   async #uploadPart(uploadId, partIdx, partData) {
     const nRetries = 5;
+    let lastResponse;
+    let lastError;
+    const partUrl = buildRequestUrl(
+      `/v1/multipart-uploads/${uploadId}/parts/${partIdx}`,
+      this.baseUrl
+    );
     for (let i = 0; i < nRetries; ++i) {
-      const partResponse = await fetch(
-        buildRequestUrl(
-          `/v1/multipart-uploads/${uploadId}/parts/${partIdx}`,
-          this.baseUrl
-        ),
-        {
+      try {
+        lastResponse = await fetch(partUrl, {
           method: "PUT",
           headers: {
             "Content-Type": "application/octet-stream",
             ...this.apiKey ? { Authorization: `Bearer ${this.apiKey}` } : {}
           },
           body: partData
+        });
+        lastError = void 0;
+      } catch (error) {
+        lastError = error;
+        if (i < nRetries - 1) {
+          const delay = 2 ** i * 100;
+          await sleep(delay);
+          continue;
         }
-      );
-      if (partResponse.ok) return;
+        break;
+      }
+      if (lastResponse.ok) return;
       if (i < nRetries - 1) {
         const delay = 2 ** i * 100;
         await sleep(delay);
       }
     }
-    throw new Error(`Failed to upload part ${partIdx}.`);
+    if (lastError !== void 0) {
+      const errorCode = getErrorCode(lastError);
+      const errorMessage = lastError instanceof Error ? lastError.message : String(lastError);
+      throw new Error(
+        `Failed to upload part ${partIdx} for multipart upload ${uploadId} after ${nRetries} attempts. The connection to the Shelby RPC endpoint was interrupted while sending data${errorCode ? ` (${errorCode})` : ""}. Endpoint: ${partUrl.toString()}, partBytes: ${partData.length}. Last error: ${errorMessage}`,
+        { cause: lastError }
+      );
+    }
+    const errorBody = await lastResponse?.text().catch(() => "");
+    throw new Error(
+      `Failed to upload part ${partIdx} for multipart upload ${uploadId} after ${nRetries} attempts. status: ${lastResponse?.status}, body: ${errorBody}`
+    );
   }
-  async #putBlobMultipart(account, blobName, blobData, partSize = 5 * 1024 * 1024) {
+  async #putBlobMultipart(account, blobName, blobData, totalBytes, partSize = 5 * 1024 * 1024, onProgress) {
+    validateTotalBytes(totalBytes);
     const startResponse = await fetch(
       buildRequestUrl("/v1/multipart-uploads", this.baseUrl),
       {
@@ -96,14 +143,38 @@ var ShelbyRPCClient = class {
         `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);
+    const { uploadId } = StartMultipartUploadResponseSchema.parse(
+      await startResponse.json()
+    );
+    const totalParts = Math.ceil(totalBytes / partSize);
+    let uploadedBytes = 0;
+    for await (const [partIdx, partData] of readInChunks(blobData, partSize)) {
       await this.#uploadPart(uploadId, partIdx, partData);
+      uploadedBytes += partData.length;
+      onProgress?.({
+        phase: "uploading",
+        partIdx,
+        totalParts,
+        partBytes: partData.length,
+        uploadedBytes,
+        totalBytes
+      });
     }
+    if (uploadedBytes !== totalBytes) {
+      throw new Error(
+        `Uploaded bytes (${uploadedBytes}) did not match declared totalBytes (${totalBytes})`
+      );
+    }
+    const finalPartIdx = totalParts > 0 ? totalParts - 1 : 0;
+    onProgress?.({
+      phase: "finalizing",
+      partIdx: finalPartIdx,
+      totalParts,
+      // no part uploaded in this phase
+      partBytes: 0,
+      uploadedBytes: totalBytes,
+      totalBytes
+    });
     const completeResponse = await fetch(
       buildRequestUrl(
         `/v1/multipart-uploads/${uploadId}/complete`,
@@ -135,7 +206,8 @@ var ShelbyRPCClient = class {
    *
    * @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.blobData - The raw blob data as a Uint8Array or ReadableStream.
+   * @param params.totalBytes - Total byte length. Required for streams; optional for Uint8Array.
    *
    * @example
    * ```typescript
@@ -144,19 +216,38 @@ var ShelbyRPCClient = class {
    * await client.putBlob({
    *   account: AccountAddress.from("0x1"),
    *   blobName: "greetings/hello.txt",
-   *   blobData
+   *   blobData,
    * });
    * ```
    */
   async putBlob(params) {
     BlobNameSchema.parse(params.blobName);
+    let totalBytes;
+    if (params.blobData instanceof Uint8Array) {
+      totalBytes = params.totalBytes ?? params.blobData.length;
+      if (totalBytes !== params.blobData.length) {
+        throw new Error(
+          "totalBytes must match blobData.length when blobData is a Uint8Array"
+        );
+      }
+    } else {
+      if (params.totalBytes === void 0) {
+        throw new Error(
+          "totalBytes is required when blobData is a ReadableStream"
+        );
+      }
+      totalBytes = params.totalBytes;
+    }
+    validateTotalBytes(totalBytes);
     await this.#putBlobMultipart(
       params.account,
       params.blobName,
-      params.blobData
+      params.blobData,
+      totalBytes,
+      void 0,
+      params.onProgress
     );
   }
-  // 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.
@@ -166,10 +257,12 @@ var ShelbyRPCClient = class {
    * @param params.range - Optional byte range for partial downloads.
    * @param params.range.start - Starting byte position (inclusive).
    * @param params.range.end - Ending byte position (inclusive, optional).
+   * @param params.micropayment - Optional micropayment to attach to the request.
    *
    * @returns A ShelbyBlob object containing the account, name, readable stream, and content length.
    *
    * @throws Error if the download fails or content length doesn't match.
+   * @throws StaleChannelStateError if the micropayment is stale (server has newer state).
    *
    * @example
    * ```typescript
@@ -185,6 +278,13 @@ var ShelbyRPCClient = class {
    *   blobName: "large-file.bin",
    *   range: { start: 100, end: 199 }
    * });
+   *
+   * // Download with micropayment
+   * const blob = await client.getBlob({
+   *   account: AccountAddress.from("0x1"),
+   *   blobName: "documents/report.pdf",
+   *   micropayment: senderBuiltMicropayment
+   * });
    * ```
    */
   async getBlob(params) {
@@ -195,9 +295,8 @@ var ShelbyRPCClient = class {
       )}`,
       this.baseUrl
     );
-    const requestInit = {};
+    const headers = new Headers();
     if (params.range !== void 0) {
-      const headers = new Headers();
       const { start, end } = params.range;
       if (end === void 0) {
         headers.set("Range", `bytes=${start}-`);
@@ -207,15 +306,45 @@ var ShelbyRPCClient = class {
         }
         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 (this.apiKey) {
+      headers.set("Authorization", `Bearer ${this.apiKey}`);
+    }
+    if (params.micropayment) {
+      const bytes = params.micropayment.bcsToBytes();
+      const binaryString = Array.from(
+        bytes,
+        (byte) => String.fromCharCode(byte)
+      ).join("");
+      headers.set(MICROPAYMENT_HEADER, btoa(binaryString));
+    }
+    const response = await fetch(url, { headers });
+    if (response.status === 409) {
+      let json;
+      try {
+        json = await response.json();
+      } catch {
+        throw new Error(
+          `Failed to download blob: ${response.status} ${response.statusText}`
+        );
       }
-    });
+      const parseResult = StaleMicropaymentErrorResponseSchema.safeParse(json);
+      if (!parseResult.success) {
+        throw new Error(
+          `Failed to download blob: ${response.status} ${response.statusText}`
+        );
+      }
+      const errorBody = parseResult.data;
+      if (errorBody.storedMicropayment) {
+        throw StaleChannelStateError.fromBase64(
+          errorBody.storedMicropayment,
+          errorBody.error
+        );
+      }
+      throw new Error(
+        errorBody.error ?? `Failed to download blob: ${response.status} ${response.statusText}`
+      );
+    }
     if (!response.ok) {
       throw new Error(
         `Failed to download blob: ${response.status} ${response.statusText}`