@shelby-protocol/sdk 0.3.0 → 0.3.1

package/dist/chunk-V4B3GAMQ.mjs

@@ -1,42 +0,0 @@
-import {
-  NetworkToShelbyRPCBaseUrl
-} from "./chunk-MNCQBEMS.mjs";
-
-// src/core/clients/utils.ts
-import { AptosConfig } from "@aptos-labs/ts-sdk";
-var getAptosConfig = (config) => {
-  const baseFaucetConfig = config.faucet?.authToken ? { AUTH_TOKEN: config.faucet.authToken } : void 0;
-  if (config.aptos) {
-    return new AptosConfig({
-      // Spread user's aptos config first
-      ...config.aptos,
-      // Network from top-level is authoritative - cannot be overridden
-      network: config.network,
-      // Merge clientConfig with API_KEY default
-      clientConfig: {
-        API_KEY: config.apiKey,
-        ...config.aptos.clientConfig
-      },
-      // Merge faucetConfig: aptos config first, then base authToken (authoritative)
-      faucetConfig: {
-        ...config.aptos.faucetConfig,
-        ...baseFaucetConfig
-      }
-    });
-  }
-  return new AptosConfig({
-    network: config.network,
-    clientConfig: {
-      API_KEY: config.apiKey
-    },
-    faucetConfig: baseFaucetConfig
-  });
-};
-var getShelbyRPCBaseUrl = (config) => {
-  return config.rpc?.baseUrl ?? NetworkToShelbyRPCBaseUrl[config.network] ?? NetworkToShelbyRPCBaseUrl.testnet;
-};
-
-export {
-  getAptosConfig,
-  getShelbyRPCBaseUrl
-};

package/dist/chunk-WFWRBNTW.mjs

@@ -1,412 +0,0 @@
-import {
-  StaleChannelStateError
-} from "./chunk-KG2TMLEV.mjs";
-import {
-  getShelbyIndexerClient
-} from "./chunk-NEO7Z3ZQ.mjs";
-import {
-  getShelbyRPCBaseUrl
-} from "./chunk-V4B3GAMQ.mjs";
-import {
-  BlobNameSchema
-} from "./chunk-Z4FZ7W6L.mjs";
-import {
-  sleep
-} from "./chunk-I6NG5GNL.mjs";
-import {
-  StaleMicropaymentErrorResponseSchema,
-  StartMultipartUploadResponseSchema
-} from "./chunk-M3CP5TFP.mjs";
-import {
-  buildRequestUrl,
-  normalizeAddress,
-  readInChunks
-} from "./chunk-UEZNZBJO.mjs";
-
-// src/core/clients/ShelbyRPCClient.ts
-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;
-  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 = getShelbyRPCBaseUrl(config);
-    this.apiKey = config.apiKey ?? config.rpc?.apiKey;
-    this.rpcConfig = config.rpc ?? {};
-    this.indexer = getShelbyIndexerClient(config);
-  }
-  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) {
-      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;
-        }
-        break;
-      }
-      if (lastResponse.ok) return;
-      if (i < nRetries - 1) {
-        const delay = 2 ** i * 100;
-        await sleep(delay);
-      }
-    }
-    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, totalBytes, partSize = 5 * 1024 * 1024, onProgress) {
-    validateTotalBytes(totalBytes);
-    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 } = 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`,
-        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 or ReadableStream.
-   * @param params.totalBytes - Total byte length. Required for streams; optional for 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);
-    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,
-      totalBytes,
-      void 0,
-      params.onProgress
-    );
-  }
-  /**
-   * 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.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
-   * // Download entire blob
-   * const blob = await client.getBlob({
-   *   account: AccountAddress.from("0x1"),
-   *   blobName: "documents/report.pdf"
-   * });
-   *
-   * // Download partial content (bytes 100-199)
-   * const partial = await client.getBlob({
-   *   account: AccountAddress.from("0x1"),
-   *   blobName: "large-file.bin",
-   *   range: { start: 100, end: 199 }
-   * });
-   *
-   * // Download with micropayment
-   * const blob = await client.getBlob({
-   *   account: AccountAddress.from("0x1"),
-   *   blobName: "documents/report.pdf",
-   *   micropayment: senderBuiltMicropayment
-   * });
-   * ```
-   */
-  async getBlob(params) {
-    BlobNameSchema.parse(params.blobName);
-    const url = buildRequestUrl(
-      `/v1/blobs/${params.account.toString()}/${encodeURIComponentKeepSlashes(
-        params.blobName
-      )}`,
-      this.baseUrl
-    );
-    const headers = new Headers();
-    if (params.range !== void 0) {
-      const { start, end } = params.range;
-      if (end === void 0) {
-        headers.set("Range", `bytes=${start}-`);
-      } else {
-        if (end < start) {
-          throw new Error("Range end cannot be less than start.");
-        }
-        headers.set("Range", `bytes=${start}-${end}`);
-      }
-    }
-    if (this.apiKey) {
-      headers.set("Authorization", `Bearer ${this.apiKey}`);
-    }
-    if (params.micropayment) {
-      const bytes = params.micropayment.bcsToBytes();
-      const binaryString = Array.from(
-        bytes,
-        (byte) => String.fromCharCode(byte)
-      ).join("");
-      headers.set(MICROPAYMENT_HEADER, btoa(binaryString));
-    }
-    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}`
-      );
-    }
-    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: normalizeAddress(params.account),
-      name: params.blobName,
-      readable: validatingStream,
-      contentLength: expectedContentLength
-    };
-  }
-};
-
-export {
-  ShelbyRPCClient
-};

package/dist/chunk-Z4FZ7W6L.mjs

@@ -1,39 +0,0 @@
-// src/core/layout.ts
-import { z } from "zod";
-var BlobNameSchema = z.string().min(1, "Blob name path parameter cannot be empty.").max(1024, "Blob name cannot exceed 1024 characters.").refine((name) => !name.endsWith("/"), {
-  message: "Blob name cannot end with a slash"
-});
-var ChunkKey = class {
-  constructor(account, blobName, chunksetIdx, chunkIdx, config) {
-    this.account = account;
-    this.blobName = blobName;
-    this.chunksetIdx = chunksetIdx;
-    this.chunkIdx = chunkIdx;
-    this.config = config;
-    if (chunkIdx >= config.erasure_n) {
-      throw new Error(
-        `Cannot create a chunk with idx ${chunkIdx}. M+K=${config.erasure_n}`
-      );
-    }
-  }
-  key() {
-    return `${this.account.toString()}.${this.blobName}.${this.chunksetIdx}.${this.chunkIdx}`;
-  }
-  // Returns the range in the blob that this key represents, or "parity" if this is parity chunk.
-  range() {
-    if (this.chunkIdx >= this.config.erasure_k) {
-      return "parity";
-    }
-    const chunksetStart = this.chunksetIdx * this.config.chunkSizeBytes * this.config.erasure_k;
-    const chunkStart = chunksetStart + this.chunkIdx * this.config.chunkSizeBytes;
-    return {
-      start: chunkStart,
-      end: chunkStart + this.config.chunkSizeBytes
-    };
-  }
-};
-
-export {
-  BlobNameSchema,
-  ChunkKey
-};