@shelby-protocol/sdk 0.2.4 → 0.3.1

package/dist/core/clients/ShelbyClient.mjs

@@ -1,27 +1,2919 @@
+// src/core/clients/ShelbyClient.ts
 import {
-  ShelbyClient
-} from "../../chunk-3PCG7PNP.mjs";
-import "../../chunk-WJTVYLKW.mjs";
-import "../../chunk-XNEIWM4O.mjs";
-import "../../chunk-NHWWORCH.mjs";
-import "../../chunk-XRLHLAOW.mjs";
-import "../../chunk-OGKZ575S.mjs";
-import "../../chunk-SSE4MFNN.mjs";
-import "../../chunk-BKL7NCUB.mjs";
-import "../../chunk-TVLV7C74.mjs";
-import "../../chunk-KYQRWJ3U.mjs";
-import "../../chunk-TET3DJEO.mjs";
-import "../../chunk-IKRWBDG5.mjs";
-import "../../chunk-I6NG5GNL.mjs";
-import "../../chunk-IE6LYVIA.mjs";
-import "../../chunk-3NRBHSMQ.mjs";
-import "../../chunk-BXEVML7N.mjs";
-import "../../chunk-UEZNZBJO.mjs";
-import "../../chunk-JTXYKO3U.mjs";
-import "../../chunk-AUQDI5BS.mjs";
-import "../../chunk-7OV5ZYW6.mjs";
-import "../../chunk-Z4FZ7W6L.mjs";
-import "../../chunk-7P6ASYW6.mjs";
+  Aptos as Aptos3,
+  DEFAULT_TXN_TIMEOUT_SEC,
+  Network as Network3,
+  TransactionResponseType
+} from "@aptos-labs/ts-sdk";
+import pLimit from "p-limit";
+
+// src/core/utils.ts
+import {
+  AccountAddress,
+  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);
+}
+function getBlobNameSuffix(blobName) {
+  const parts = blobName.split("/");
+  return parts.slice(1).join("/") || "";
+}
+function normalizeAddress(address) {
+  return AccountAddress.from(address, { maxMissingChars: 63 });
+}
+
+// src/core/blobs.ts
+var createBlobKey = (params) => {
+  return `@${normalizeAddress(params.account).toStringLongWithoutPrefix()}/${params.blobName}`;
+};
+
+// src/core/commitments.ts
+import { Hex as Hex2 } from "@aptos-labs/ts-sdk";
+import { z } from "zod";
+
+// src/core/erasure/constants.ts
+var ERASURE_CODE_PARAMS = {
+  ["ClayCode_16Total_10Data_13Helper" /* ClayCode_16Total_10Data_13Helper */]: {
+    // total chunks (data + parity)
+    erasure_n: 16,
+    // data chunks
+    erasure_k: 10,
+    // helper nodes
+    erasure_d: 13,
+    // enum index
+    enumIndex: 0
+  },
+  ["ClayCode_4Total_2Data_3Helper" /* ClayCode_4Total_2Data_3Helper */]: {
+    // total chunks (data + parity)
+    erasure_n: 4,
+    // data chunks
+    erasure_k: 2,
+    // helper nodes
+    erasure_d: 3,
+    // enum index
+    enumIndex: 1
+  }
+};
+var DEFAULT_ERASURE_N = ERASURE_CODE_PARAMS["ClayCode_16Total_10Data_13Helper" /* ClayCode_16Total_10Data_13Helper */].erasure_n;
+var DEFAULT_ERASURE_K = ERASURE_CODE_PARAMS["ClayCode_16Total_10Data_13Helper" /* ClayCode_16Total_10Data_13Helper */].erasure_k;
+var DEFAULT_ERASURE_D = ERASURE_CODE_PARAMS["ClayCode_16Total_10Data_13Helper" /* ClayCode_16Total_10Data_13Helper */].erasure_d;
+var DEFAULT_ERASURE_M = DEFAULT_ERASURE_N - DEFAULT_ERASURE_K;
+
+// src/core/chunk.ts
+var CHUNK_SIZE_PARAMS = {
+  ["ChunkSet10MiB_Chunk1MiB" /* ChunkSet10MiB_Chunk1MiB */]: {
+    // 1MiB
+    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;
+var DEFAULT_CHUNKSET_SIZE_BYTES = CHUNK_SIZE_PARAMS["ChunkSet10MiB_Chunk1MiB" /* ChunkSet10MiB_Chunk1MiB */].chunksetSizeBytes;
+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
+  }
+};
+
+// src/core/commitments.ts
+var COMMITMENT_SCHEMA_VERSION = "1.3";
+var ChunksetCommitmentSchema = z.object({
+  // Chunkset root (vector commitment of child chunks)
+  chunkset_root: z.string(),
+  // 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 generateMerkleRoot(leafHashes) {
+  if (!leafHashes.length) {
+    throw new Error(
+      "An empty array cannot be used to construct a Merkle tree."
+    );
+  }
+  const zeroArray = new Uint8Array(leafHashes[0].toUint8Array().length);
+  const zeroBytes = Hex2.fromHexInput(zeroArray);
+  let currentLeaves = leafHashes;
+  while (currentLeaves.length > 1) {
+    if (currentLeaves.length % 2 !== 0) {
+      currentLeaves.push(zeroBytes);
+    }
+    const nextLeaves = [];
+    for (let i = 0; i < currentLeaves.length; i += 2) {
+      nextLeaves.push(
+        await concatHashes([
+          currentLeaves[i].toUint8Array(),
+          currentLeaves[i + 1].toUint8Array()
+        ])
+      );
+    }
+    currentLeaves = nextLeaves;
+  }
+  return currentLeaves[0];
+}
+async function generateChunksetCommitments(chunksetIdx, chunksetData, expectedChunksetSize, provider, onChunk) {
+  const { erasure_n } = provider.config;
+  const chunksetPayload = zeroPadBytes(chunksetData, expectedChunksetSize);
+  const { chunks } = provider.encode(chunksetPayload);
+  if (chunks.length !== erasure_n) {
+    throw new Error(
+      `Erasure provider produced ${chunks.length} chunks, expected ${erasure_n}.`
+    );
+  }
+  const chunkRoots = provider.getChunkMerkleRoots();
+  let chunkIdx = 0;
+  for (const chunkData of chunks) {
+    if (onChunk !== void 0) {
+      await onChunk(chunksetIdx, chunkIdx, chunkData);
+    }
+    chunkIdx += 1;
+  }
+  const a = await generateMerkleRoot(
+    chunkRoots.map((a2) => Hex2.fromHexInput(a2))
+  );
+  const entry = {
+    chunkset_root: a.toString(),
+    chunk_commitments: chunkRoots.map(
+      (chunk) => Hex2.fromHexInput(chunk).toString()
+    )
+  };
+  return { h: a, entry };
+}
+async function generateCommitments(provider, fullData, onChunk) {
+  const expectedChunksetSize = provider.config.chunkSizeBytes * provider.config.erasure_k;
+  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(
+      chunksetIdx,
+      chunksetData,
+      expectedChunksetSize,
+      provider,
+      onChunk
+    );
+    chunksetCommitments.push(entry);
+    chunksetCommitmentHashes.push(h);
+  }
+  if (rawDataSize === 0) {
+    const zeroChunkset = new Uint8Array(expectedChunksetSize);
+    const { h, entry } = await generateChunksetCommitments(
+      0,
+      zeroChunkset,
+      expectedChunksetSize,
+      provider,
+      onChunk
+    );
+    chunksetCommitments.push(entry);
+    chunksetCommitmentHashes.push(h);
+  }
+  return {
+    schema_version: COMMITMENT_SCHEMA_VERSION,
+    raw_data_size: rawDataSize,
+    blob_merkle_root: (await generateMerkleRoot(chunksetCommitmentHashes)).toString(),
+    chunkset_commitments: chunksetCommitments
+  };
+}
+
+// src/core/erasure/clay-codes.ts
+import {
+  createDecoder,
+  createEncoder
+} from "@shelby-protocol/clay-codes";
+function getTotalChunks(config) {
+  return config.erasure_n;
+}
+var ClayErasureCodingProvider = class _ClayErasureCodingProvider {
+  config;
+  encoderCache;
+  decoderCache;
+  lastFunction;
+  constructor(config) {
+    this.config = config;
+    this.lastFunction = "none" /* NONE */;
+  }
+  /**
+   * Static factory method to create an initialized ClayErasureCodingProvider
+   */
+  static async create(config) {
+    const provider = new _ClayErasureCodingProvider(config);
+    [provider.encoderCache, provider.decoderCache] = await Promise.all([
+      createEncoder({
+        n: getTotalChunks(config),
+        k: config.erasure_k,
+        d: config.erasure_d,
+        chunkSizeBytes: config.chunkSizeBytes
+      }),
+      createDecoder({
+        n: getTotalChunks(config),
+        k: config.erasure_k,
+        d: config.erasure_d,
+        chunkSizeBytes: config.chunkSizeBytes,
+        erasedChunkIndexes: []
+      })
+    ]);
+    return provider;
+  }
+  encode(data) {
+    const { erasure_k, chunkSizeBytes } = this.config;
+    if (!this.encoderCache) {
+      throw new Error("Encoder cache is missing");
+    }
+    const systematicCapacity = erasure_k * chunkSizeBytes;
+    if (data.byteLength > systematicCapacity) {
+      throw new Error(
+        `Data size ${data.byteLength} bytes exceeds systematic capacity ${systematicCapacity} bytes (erasure_k=${erasure_k} * chunkSizeBytes=${chunkSizeBytes}).`
+      );
+    }
+    if (this.requiresPadding(data.length)) {
+      throw new Error(
+        `Data size ${data.length} bytes does not match systematic capacity ${systematicCapacity} bytes (erasure_k=${erasure_k} * chunkSizeBytes=${chunkSizeBytes}). Provide pre-padded data before encoding.`
+      );
+    }
+    this.lastFunction = "encoded" /* ENCODED */;
+    return this.encoderCache.erasureCode(data);
+  }
+  decode(available, config) {
+    if (!this.decoderCache) {
+      throw new Error("Decoder cache is missing");
+    }
+    const { erasure_k, chunkSizeBytes } = this.config;
+    if (available.length < erasure_k) {
+      throw new Error(
+        `Insufficient available chunks: need at least ${erasure_k}, received ${available.length}.`
+      );
+    }
+    for (let i = 0; i < available.length; i++) {
+      const chunk = available[i];
+      if (chunk.length !== chunkSizeBytes) {
+        throw new Error(
+          `Chunk ${i} size ${chunk.length} bytes does not match expected chunkSizeBytes ${chunkSizeBytes}.`
+        );
+      }
+    }
+    this.lastFunction = "decoded" /* DECODED */;
+    return this.decoderCache.decode(available, config);
+  }
+  getChunkMerkleRoots() {
+    if (this.decoderCache && this.lastFunction === "decoded" /* DECODED */)
+      return this.decoderCache.getChunkMerkleRoots();
+    if (this.encoderCache && this.lastFunction === "encoded" /* ENCODED */)
+      return this.encoderCache.getChunkMerkleRoots();
+    throw new Error(
+      "You must call encode or decode before calling getChunkMerkleRoots"
+    );
+  }
+  /**
+   * Determines if data can be erasure coded as-is or requires padding.
+   *
+   * Data can be erasure coded without padding if its size exactly matches
+   * the total systematic data capacity (k * chunkSizeBytes).
+   *
+   * @param dataSize - Size of the data in bytes
+   * @returns true if data needs padding, false if it can be coded as-is
+   */
+  requiresPadding(dataSize) {
+    const { erasure_k, chunkSizeBytes } = this.config;
+    const systematicCapacity = erasure_k * chunkSizeBytes;
+    return dataSize !== systematicCapacity;
+  }
+};
+
+// src/core/erasure/default.ts
+function defaultErasureCodingConfig() {
+  const encoding = Number(process.env.SHELBY_ENCODING) || 0;
+  if (encoding === 0) {
+    return erasureCodingConfig16Total10Data13Helper();
+  }
+  return erasureCodingConfig4Total2Data3Helper();
+}
+function erasureCodingConfig16Total10Data13Helper() {
+  return erasureCodingConfig(
+    "ClayCode_16Total_10Data_13Helper" /* ClayCode_16Total_10Data_13Helper */
+  );
+}
+function erasureCodingConfig4Total2Data3Helper() {
+  return erasureCodingConfig("ClayCode_4Total_2Data_3Helper" /* ClayCode_4Total_2Data_3Helper */);
+}
+function erasureCodingConfig(encodingScheme) {
+  return {
+    erasure_n: ERASURE_CODE_PARAMS[encodingScheme].erasure_n,
+    erasure_k: ERASURE_CODE_PARAMS[encodingScheme].erasure_k,
+    erasure_d: ERASURE_CODE_PARAMS[encodingScheme].erasure_d,
+    chunkSizeBytes: DEFAULT_CHUNK_SIZE_BYTES,
+    enumIndex: ERASURE_CODE_PARAMS[encodingScheme].enumIndex
+  };
+}
+
+// src/core/erasure/reed-solomon.ts
+import { createWasmReedSolomonBinding } from "@shelby-protocol/reed-solomon";
+var DEFAULT_CHUNK_SIZE_BYTES2 = 2 * 1024 * 1024;
+
+// src/core/clients/ShelbyBlobClient.ts
+import {
+  AccountAddress as AccountAddress2,
+  Aptos,
+  Hex as Hex3,
+  U32
+} from "@aptos-labs/ts-sdk";
+
+// src/core/constants.ts
+import { Network } from "@aptos-labs/ts-sdk";
+var NetworkToShelbyRPCBaseUrl = {
+  [Network.SHELBYNET]: "https://api.shelbynet.shelby.xyz/shelby",
+  [Network.NETNA]: void 0,
+  [Network.DEVNET]: void 0,
+  [Network.TESTNET]: "https://api.testnet.shelby.xyz/shelby",
+  [Network.MAINNET]: void 0,
+  [Network.LOCAL]: "http://localhost:9090",
+  [Network.CUSTOM]: void 0
+};
+var NetworkToShelbyBlobIndexerBaseUrl = {
+  [Network.SHELBYNET]: "https://api.shelbynet.aptoslabs.com/nocode/v1/public/alias/shelby/shelbynet/v1/graphql",
+  [Network.NETNA]: void 0,
+  [Network.DEVNET]: void 0,
+  [Network.TESTNET]: "https://api.testnet.aptoslabs.com/nocode/v1/public/alias/shelby/testnet/v1/graphql",
+  [Network.MAINNET]: void 0,
+  [Network.LOCAL]: "http://localhost:8091/v1/graphql",
+  [Network.CUSTOM]: void 0
+};
+var NetworkToGasStationBaseUrl = {
+  [Network.SHELBYNET]: "https://api.shelbynet.shelby.xyz/gs/v1",
+  [Network.NETNA]: void 0,
+  [Network.DEVNET]: void 0,
+  [Network.TESTNET]: "https://api.testnet.shelby.xyz/gs/v1",
+  [Network.MAINNET]: void 0,
+  [Network.LOCAL]: void 0,
+  [Network.CUSTOM]: void 0
+};
+var SHELBY_DEPLOYER = "0x85fdb9a176ab8ef1d9d9c1b60d60b3924f0800ac1de1cc2085fb0b8bb4988e6a";
+var MICROPAYMENTS_DEPLOYER = "0x1ae7275148bf6ef742b658fd9cbcc2e094201606f4a7bc707bab0201da8043ee";
+
+// src/core/operations/index.ts
+import { Network as Network2 } from "@aptos-labs/ts-sdk";
+import { GraphQLClient } from "graphql-request";
+
+// 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;
+};
+
+// src/core/operations/generated/sdk.ts
+import gql from "graphql-tag";
+var GetBlobsDocument = gql`
+    query getBlobs($where: blobs_bool_exp, $orderBy: [blobs_order_by!], $limit: Int, $offset: Int) {
+  blobs(where: $where, order_by: $orderBy, limit: $limit, offset: $offset) {
+    owner
+    blob_commitment
+    blob_name
+    created_at
+    expires_at
+    num_chunksets
+    is_deleted
+    is_written
+    placement_group
+    size
+    updated_at
+    slice_address
+  }
+}
+    `;
+var GetBlobActivitiesDocument = gql`
+    query getBlobActivities($where: blob_activities_bool_exp, $orderBy: [blob_activities_order_by!], $limit: Int, $offset: Int) {
+  blob_activities(
+    where: $where
+    order_by: $orderBy
+    limit: $limit
+    offset: $offset
+  ) {
+    blob_name
+    event_index
+    event_type
+    transaction_hash
+    transaction_version
+    timestamp
+    owner
+  }
+}
+    `;
+var GetBlobsCountDocument = gql`
+    query getBlobsCount($where: blobs_bool_exp) {
+  blobs_aggregate(where: $where) {
+    aggregate {
+      count
+    }
+  }
+}
+    `;
+var GetBlobActivitiesCountDocument = gql`
+    query getBlobActivitiesCount($where: blob_activities_bool_exp) {
+  blob_activities_aggregate(where: $where) {
+    aggregate {
+      count
+    }
+  }
+}
+    `;
+var GetTotalBlobsSizeDocument = gql`
+    query getTotalBlobsSize($where: blobs_bool_exp) {
+  blobs_aggregate(where: $where) {
+    aggregate {
+      sum {
+        size
+      }
+    }
+  }
+}
+    `;
+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 {
+    getBlobs(variables, requestHeaders, signal) {
+      return withWrapper((wrappedRequestHeaders) => client.request({ document: GetBlobsDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), "getBlobs", "query", variables);
+    },
+    getBlobActivities(variables, requestHeaders, signal) {
+      return withWrapper((wrappedRequestHeaders) => client.request({ document: GetBlobActivitiesDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), "getBlobActivities", "query", variables);
+    },
+    getBlobsCount(variables, requestHeaders, signal) {
+      return withWrapper((wrappedRequestHeaders) => client.request({ document: GetBlobsCountDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), "getBlobsCount", "query", variables);
+    },
+    getBlobActivitiesCount(variables, requestHeaders, signal) {
+      return withWrapper((wrappedRequestHeaders) => client.request({ document: GetBlobActivitiesCountDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), "getBlobActivitiesCount", "query", variables);
+    },
+    getTotalBlobsSize(variables, requestHeaders, signal) {
+      return withWrapper((wrappedRequestHeaders) => client.request({ document: GetTotalBlobsSizeDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), "getTotalBlobsSize", "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);
+    }
+  };
+}
+
+// src/core/operations/index.ts
+function createShelbyIndexerClient(baseUrl, options) {
+  const graphqlClient = new GraphQLClient(baseUrl, options);
+  return getSdk(graphqlClient);
+}
+function getShelbyIndexerClient(config) {
+  const aptosConfig = getAptosConfig(config);
+  let { apiKey: indexerApiKey, baseUrl } = config.indexer ?? {};
+  if (!baseUrl) {
+    switch (aptosConfig?.network) {
+      // TODO: Add endpoints for core networks
+      case Network2.MAINNET:
+      case Network2.TESTNET:
+      case Network2.DEVNET:
+      case Network2.SHELBYNET:
+      case Network2.LOCAL:
+        baseUrl = NetworkToShelbyBlobIndexerBaseUrl[aptosConfig.network];
+        break;
+    }
+  }
+  if (baseUrl === void 0) {
+    throw new Error(
+      "The ShelbyClientConfig does not support the Shelby indexer. Please configure the endpoint in the ShelbyClientConfig.indexer.endpoint or provide a supported Aptos network."
+    );
+  }
+  const apiKey = indexerApiKey ?? config.apiKey;
+  return createShelbyIndexerClient(baseUrl, {
+    headers: {
+      ...apiKey ? { Authorization: `Bearer ${apiKey}` } : {},
+      "x-aptos-client": "shelby-ts-sdk"
+    }
+  });
+}
+
+// src/core/clients/ShelbyBlobClient.ts
+var MissingTransactionSubmitterError = class extends Error {
+  constructor() {
+    super(
+      "USD sponsorship (usdSponsor) requires a transaction submitter to be configured. The sponsored transaction is a multi-agent transaction that must be co-signed by the sponsor. Configure a transaction submitter via aptos.pluginSettings.TRANSACTION_SUBMITTER that routes transactions to a service (like a gas station) capable of providing the sponsor's signature."
+    );
+    this.name = "MissingTransactionSubmitterError";
+  }
+};
+var ShelbyBlobClient = class _ShelbyBlobClient {
+  aptos;
+  deployer;
+  indexer;
+  defaultOptions;
+  orderless;
+  /**
+   * 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.
+   * @param defaultOptions - Optional default options for blob operations.
+   *
+   * @example
+   * ```typescript
+   * const blobClient = new ShelbyBlobClient({
+   *   aptos: {
+   *     network: Network.SHELBYNET,
+   *     clientConfig: {
+   *       API_KEY: "AG-***",
+   *     },
+   *   },
+   * });
+   * ```
+   *
+   * @example
+   * ```typescript
+   * // With default options for USD sponsorship
+   * const blobClient = new ShelbyBlobClient(
+   *   {
+   *     network: Network.SHELBYNET,
+   *     aptos: {
+   *       pluginSettings: {
+   *         TRANSACTION_SUBMITTER: myGasStationSubmitter,
+   *       },
+   *     },
+   *   },
+   *   {
+   *     usdSponsor: { feePayerAddress: sponsorAddress },
+   *   }
+   * );
+   * ```
+   */
+  constructor(config, defaultOptions) {
+    this.aptos = new Aptos(getAptosConfig(config));
+    this.deployer = config.deployer ?? AccountAddress2.fromString(SHELBY_DEPLOYER);
+    this.indexer = getShelbyIndexerClient(config);
+    this.defaultOptions = defaultOptions ?? {};
+    this.orderless = config.orderless ?? false;
+  }
+  /**
+   * Merges method-level options with default options, giving precedence to method-level values.
+   */
+  mergeOptions(options) {
+    return {
+      build: options?.build ?? this.defaultOptions.build,
+      submit: options?.submit ?? this.defaultOptions.submit,
+      usdSponsor: options?.usdSponsor ?? this.defaultOptions.usdSponsor,
+      chunksetSizeBytes: options?.chunksetSizeBytes ?? this.defaultOptions.chunksetSizeBytes
+    };
+  }
+  /**
+   * Validates that if USD sponsorship is requested, a transaction submitter is
+   * configured as well. Checks both the client-level and method-level transaction
+   * submitter configurations. Throws MissingTransactionSubmitterError if usdSponsor is
+   * provided without a transaction submitter.
+   */
+  validateUsdSponsorConfig(usdSponsor, submit) {
+    if (!usdSponsor) {
+      return;
+    }
+    const hasClientSubmitter = this.aptos.config.getTransactionSubmitter();
+    const hasMethodSubmitter = submit?.transactionSubmitter !== void 0 && submit?.transactionSubmitter !== null;
+    if (!hasClientSubmitter && !hasMethodSubmitter) {
+      throw new MissingTransactionSubmitterError();
+    }
+  }
+  /**
+   * Merges orderless replay protection into transaction options when
+   * `config.orderless` is enabled. If the caller already supplies options
+   * (e.g. custom gas limits), those are preserved and the nonce is injected
+   * alongside them. When orderless mode is off, user options are returned as-is.
+   */
+  orderlessTxOptions(userOptions) {
+    if (!this.orderless) return userOptions;
+    return {
+      replayProtectionNonce: crypto.getRandomValues(new Uint32Array(1))[0],
+      ...userOptions
+    };
+  }
+  /**
+   * Retrieves the blob metadata from the blockchain. If it does not exist,
+   * returns `undefined`.
+   *
+   * @param params.account - The account namespace the blob is stored in (e.g. "0x1")
+   * @param params.name - The name of the blob (e.g. "foo/bar")
+   * @returns The blob metadata.
+   *
+   * @example
+   * ```typescript
+   * const metadata = await client.getBlobMetadata({
+   *   account: AccountAddress.fromString("0x1"),
+   *   name: "foo/bar.txt",
+   * });
+   * ```
+   */
+  async getBlobMetadata(params) {
+    try {
+      const rawMetadata = await this.aptos.view({
+        payload: {
+          function: `${this.deployer.toString()}::blob_metadata::get_blob_metadata`,
+          functionArguments: [
+            createBlobKey({
+              account: params.account,
+              blobName: params.name
+            })
+          ]
+        }
+      });
+      if (!rawMetadata?.[0]?.vec?.[0]) {
+        return void 0;
+      }
+      const metadata = rawMetadata[0].vec[0];
+      let encoding;
+      if (metadata.encoding.__variant__ === "ClayCode_16Total_10Data_13Helper") {
+        encoding = {
+          variant: "clay",
+          ...ERASURE_CODE_PARAMS[metadata.encoding.__variant__],
+          ...ERASURE_CODE_AND_CHUNK_MAPPING[metadata.encoding.__variant__]
+        };
+      } else if (metadata.encoding.__variant__ === "ClayCode_4Total_2Data_3Helper") {
+        encoding = {
+          variant: "clay",
+          ...ERASURE_CODE_PARAMS[metadata.encoding.__variant__],
+          ...ERASURE_CODE_AND_CHUNK_MAPPING[metadata.encoding.__variant__]
+        };
+      } else {
+        throw new Error(
+          "Could not parse encoding from Shelby Smart Contract, this SDK is out of date."
+        );
+      }
+      return {
+        blobMerkleRoot: Hex3.fromHexInput(
+          metadata.blob_commitment
+        ).toUint8Array(),
+        owner: normalizeAddress(metadata.owner),
+        name: params.name,
+        blobNameSuffix: getBlobNameSuffix(params.name),
+        size: Number(metadata.blob_size),
+        encoding,
+        expirationMicros: Number(metadata.expiration_micros),
+        creationMicros: Number(metadata.creation_micros),
+        sliceAddress: normalizeAddress(metadata.slice.inner),
+        isWritten: metadata.is_written
+      };
+    } catch (error) {
+      if (error instanceof Error && // Depending on the network, the error message may show up differently.
+      (error.message?.includes("sub_status: Some(404)") || error.message?.includes("EBLOB_NOT_FOUND"))) {
+        return void 0;
+      }
+      throw error;
+    }
+  }
+  /**
+   * Retrieves all the blobs and their metadata for an account from the
+   * blockchain.
+   *
+   * @param params.account - The account namespace the blobs are stored in (e.g. "0x1")
+   * @param params.pagination (optional) - The pagination options.
+   * @param params.orderBy (optional) - The order by clause to sort the blobs by.
+   * @returns The blob metadata for all the blobs for the account.
+   *
+   * @example
+   * ```typescript
+   * // BlobMetadata[]
+   * const blobs = await client.getAccountBlobs({
+   *   account: AccountAddress.fromString("0x1"),
+   * });
+   * ```
+   */
+  getAccountBlobs(params) {
+    const { where, ...rest } = params;
+    return this.getBlobs({
+      where: {
+        ...where,
+        owner: { _eq: normalizeAddress(params.account).toString() }
+      },
+      pagination: rest.pagination,
+      orderBy: rest.orderBy
+    });
+  }
+  /**
+   * Retrieves blobs and their metadata from the blockchain.
+   *
+   * @param params.where (optional) - The where clause to filter the blobs by.
+   * @param params.pagination (optional) - The pagination options.
+   * @param params.orderBy (optional) - The order by clause to sort the blobs by.
+   * @returns The blob metadata for all the blobs that match the where clause.
+   *
+   * @example
+   * ```typescript
+   * // BlobMetadata[]
+   * const blobs = await client.getBlobs({
+   *   where: { owner: { _eq: AccountAddress.fromString("0x1").toString() } },
+   * });
+   * ```
+   */
+  async getBlobs(params = {}) {
+    const { limit, offset } = params.pagination ?? {};
+    const { orderBy, where } = params;
+    const currentMicros = String(Date.now() * 1e3);
+    const defaultActiveFilter = {
+      expires_at: { _gte: currentMicros },
+      is_deleted: { _eq: "0" }
+    };
+    const finalWhere = where !== void 0 ? { ...defaultActiveFilter, ...where } : defaultActiveFilter;
+    const { blobs } = await this.indexer.getBlobs({
+      where: finalWhere,
+      limit,
+      offset,
+      orderBy
+    });
+    return blobs.map(
+      (blob) => ({
+        owner: normalizeAddress(blob.owner),
+        name: blob.blob_name,
+        blobNameSuffix: getBlobNameSuffix(blob.blob_name),
+        blobMerkleRoot: Hex3.fromHexInput(blob.blob_commitment).toUint8Array(),
+        size: Number(blob.size),
+        // TODO: Add encoding when supported in NCI
+        encoding: {
+          variant: "clay",
+          ...ERASURE_CODE_PARAMS.ClayCode_16Total_10Data_13Helper,
+          ...ERASURE_CODE_AND_CHUNK_MAPPING.ClayCode_16Total_10Data_13Helper
+        },
+        expirationMicros: Number(blob.expires_at),
+        creationMicros: Number(blob.created_at),
+        sliceAddress: normalizeAddress(blob.slice_address),
+        isWritten: Boolean(Number(blob.is_written)),
+        isDeleted: Boolean(Number(blob.is_deleted))
+      })
+    );
+  }
+  async getBlobActivities(params) {
+    const { limit, offset } = params.pagination ?? {};
+    const { orderBy, where } = params;
+    const { blob_activities } = await this.indexer.getBlobActivities({
+      where,
+      limit,
+      offset,
+      orderBy
+    });
+    const activityTypeMapping = {
+      [`${this.deployer.toStringLong()}::blob_metadata::BlobRegisteredEvent`]: "register_blob",
+      [`${this.deployer.toStringLong()}::blob_metadata::BlobDeletedEvent`]: "delete_blob",
+      [`${this.deployer.toStringLong()}::blob_metadata::BlobExpirationExtendedEvent`]: "extend_blob_expiration",
+      [`${this.deployer.toStringLong()}::blob_metadata::BlobWrittenEvent`]: "write_blob"
+    };
+    return blob_activities.map(
+      (activity) => ({
+        blobName: activity.blob_name,
+        accountAddress: normalizeAddress(activity.blob_name.substring(1, 65)),
+        type: activityTypeMapping[activity.event_type] ?? "unknown",
+        eventType: activity.event_type,
+        eventIndex: Number(activity.event_index),
+        transactionHash: activity.transaction_hash,
+        // Using Number here in JS is technically not okay because txn version can be
+        // as large as u64::MAX, but it should be fine for a long while.
+        transactionVersion: Number(activity.transaction_version),
+        timestamp: `${activity.timestamp}Z`
+      })
+    );
+  }
+  /**
+   * Retrieves the total number of blobs from the blockchain.
+   *
+   * @param params.where (optional) - The where clause to filter the blobs by.
+   * @returns The total number of blobs.
+   *
+   * @example
+   * ```typescript
+   * const count = await client.getBlobsCount();
+   * ```
+   */
+  async getBlobsCount(params) {
+    const { where } = params;
+    const { blobs_aggregate } = await this.indexer.getBlobsCount({ where });
+    return blobs_aggregate?.aggregate?.count ?? 0;
+  }
+  /**
+   * Retrieves the total size of blobs from the blockchain.
+   *
+   * @param params.where (optional) - The where clause to filter the blobs by.
+   * @returns The total size of blobs in bytes.
+   *
+   * @example
+   * ```typescript
+   * const size = await client.getTotalBlobsSize();
+   * ```
+   */
+  async getTotalBlobsSize(params = {}) {
+    const { where } = params;
+    const { blobs_aggregate } = await this.indexer.getTotalBlobsSize({ where });
+    return Number(blobs_aggregate?.aggregate?.sum?.size ?? 0);
+  }
+  /**
+   * Retrieves the total number of blob activities from the blockchain.
+   *
+   * @param params.where (optional) - The where clause to filter the blob activities by.
+   * @returns The total number of blob activities.
+   *
+   * @example
+   * ```typescript
+   * const count = await client.getBlobActivitiesCount();
+   * ```
+   */
+  async getBlobActivitiesCount(params) {
+    const { where } = params;
+    const { blob_activities_aggregate } = await this.indexer.getBlobActivitiesCount({ where });
+    return blob_activities_aggregate?.aggregate?.count ?? 0;
+  }
+  /**
+   * Registers a blob on the blockchain by writing its merkle root and metadata.
+   *
+   * @param params.account - The account that is signing and paying for the transaction.
+   * @param params.blobName - The name/path of the blob (e.g. "foo/bar.txt").
+   * @param params.blobMerkleRoot - The merkle root of the blob commitments.
+   * @param params.size - The size of the blob in bytes.
+   * @param params.expirationMicros - The expiration time of the blob in microseconds.
+   * @param params.options - Optional transaction building options.
+   * @param params.options.chunksetSizeBytes - Custom chunkset size (defaults to DEFAULT_CHUNKSET_SIZE_BYTES).
+   * @param params.options.build - Additional Aptos transaction building options.
+   *
+   * @returns An object containing the pending transaction.
+   *
+   * @example
+   * ```typescript
+   * const provider = await ClayErasureCodingProvider.create();
+   * const blobCommitments = await generateCommitments(provider, data);
+   *
+   * const { transaction } = await client.registerBlob({
+   *   account: signer,
+   *   blobName: "foo/bar.txt",
+   *   blobMerkleRoot: blobCommitments.blob_merkle_root,
+   *   size: data.length,
+   *   expirationMicros: Date.now() * 1000 + 3600_000_000, // 1 hour from now in microseconds
+   * });
+   * ```
+   */
+  async registerBlob(params) {
+    const options = this.mergeOptions(params.options);
+    this.validateUsdSponsorConfig(options.usdSponsor, options.submit);
+    const config = params.config ?? defaultErasureCodingConfig();
+    const chunksetSize = config.chunkSizeBytes * config.erasure_k;
+    const buildArgs = {
+      ...options.build,
+      options: this.orderlessTxOptions(options.build?.options),
+      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,
+        useSponsoredUsdVariant: options.usdSponsor !== void 0,
+        encoding: config.enumIndex
+      }),
+      sender: params.account.accountAddress
+    };
+    const transaction = options.usdSponsor ? await this.aptos.transaction.build.multiAgent({
+      ...buildArgs,
+      secondarySignerAddresses: [options.usdSponsor.feePayerAddress]
+    }) : await this.aptos.transaction.build.simple(buildArgs);
+    return {
+      transaction: await this.aptos.signAndSubmitTransaction({
+        signer: params.account,
+        transaction,
+        ...options.submit
+      })
+    };
+  }
+  /**
+   * Deletes a blob on the blockchain.
+   *
+   * @param params.account - The account that is signing and paying for the transaction.
+   * @param params.blobName - The name/path of the blob (e.g. "foo/bar.txt").
+   * @param params.options - Optional transaction building options.
+   *
+   * @returns An object containing the pending transaction.
+   *
+   * @example
+   * ```typescript
+   *
+   * const { transaction } = await client.deleteBlob({
+   *   account: signer,
+   *   blobName: "foo/bar.txt",
+   * });
+   * ```
+   */
+  async deleteBlob(params) {
+    const transaction = await this.aptos.transaction.build.simple({
+      options: this.orderlessTxOptions(params.options),
+      data: _ShelbyBlobClient.createDeleteBlobPayload({
+        deployer: this.deployer,
+        blobName: params.blobName
+      }),
+      sender: params.account.accountAddress
+    });
+    return {
+      transaction: await this.aptos.signAndSubmitTransaction({
+        signer: params.account,
+        transaction
+      })
+    };
+  }
+  /**
+   * Deletes multiple blobs on the blockchain in a single atomic transaction.
+   *
+   * **Note:** This function requires the `delete_multiple_blobs` entry function
+   * which will be deployed to the smart contract on 2026-02-04. Using this
+   * function before that date will result in a transaction failure.
+   *
+   * This operation is atomic: if any blob deletion fails (e.g., blob not found),
+   * the entire transaction fails and no blobs are deleted.
+   *
+   * @param params.account - The account that is signing and paying for the transaction.
+   * @param params.blobNames - Array of blob name suffixes without the account address prefix
+   *   (e.g. ["foo/bar.txt", "baz.txt"], NOT ["0x1/foo/bar.txt"]). The account address
+   *   prefix is automatically derived from the signer.
+   * @param params.options - Optional transaction building options.
+   *
+   * @returns An object containing the pending transaction.
+   *
+   * @example
+   * ```typescript
+   *
+   * const { transaction } = await client.deleteMultipleBlobs({
+   *   account: signer,
+   *   blobNames: ["foo/bar.txt", "baz.txt"],
+   * });
+   * ```
+   */
+  async deleteMultipleBlobs(params) {
+    const transaction = await this.aptos.transaction.build.simple({
+      options: this.orderlessTxOptions(params.options),
+      data: _ShelbyBlobClient.createDeleteMultipleBlobsPayload({
+        deployer: this.deployer,
+        blobNames: params.blobNames
+      }),
+      sender: params.account.accountAddress
+    });
+    return {
+      transaction: await this.aptos.signAndSubmitTransaction({
+        signer: params.account,
+        transaction
+      })
+    };
+  }
+  /**
+   * Registers multiple blobs on the blockchain by writing their merkle roots and metadata.
+   *
+   * @param params.account - The account that is signing and paying for the transaction.
+   * @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.options - Optional transaction building options.
+   * @param params.options.chunksetSizeBytes - Custom chunkset size (defaults to DEFAULT_CHUNKSET_SIZE_BYTES).
+   * @param params.options.build - Additional Aptos transaction building options.
+   *
+   * @returns An object containing the pending transaction.
+   *
+   * @example
+   * ```typescript
+   * const provider = await ClayErasureCodingProvider.create();
+   * const blobCommitments = await generateCommitments(provider, data);
+   *
+   * const { transaction } = await client.batchRegisterBlobs({
+   *   account: signer,
+   *   expirationMicros: Date.now() * 1000 + 3600_000_000, // 1 hour from now in microseconds
+   *   blobs: [
+   *     {
+   *       blobName: "foo/bar.txt",
+   *       blobSize: data.length,
+   *       blobMerkleRoot: blobCommitments.blob_merkle_root,
+   *     },
+   *   ],
+   * });
+   * ```
+   */
+  async batchRegisterBlobs(params) {
+    const options = this.mergeOptions(params.options);
+    this.validateUsdSponsorConfig(options.usdSponsor, options.submit);
+    const config = params.config ?? defaultErasureCodingConfig();
+    const chunksetSize = config.chunkSizeBytes * config.erasure_k;
+    const buildArgs = {
+      ...options.build,
+      options: this.orderlessTxOptions(options.build?.options),
+      sender: params.account.accountAddress,
+      data: _ShelbyBlobClient.createBatchRegisterBlobsPayload({
+        deployer: this.deployer,
+        account: params.account.accountAddress,
+        expirationMicros: params.expirationMicros,
+        blobs: params.blobs.map((blob) => ({
+          blobName: blob.blobName,
+          blobSize: blob.blobSize,
+          blobMerkleRoot: blob.blobMerkleRoot,
+          numChunksets: expectedTotalChunksets(blob.blobSize, chunksetSize)
+        })),
+        useSponsoredUsdVariant: options.usdSponsor !== void 0,
+        encoding: config.enumIndex
+      })
+    };
+    const transaction = options.usdSponsor ? await this.aptos.transaction.build.multiAgent({
+      ...buildArgs,
+      secondarySignerAddresses: [options.usdSponsor.feePayerAddress]
+    }) : await this.aptos.transaction.build.simple(buildArgs);
+    return {
+      transaction: await this.aptos.signAndSubmitTransaction({
+        signer: params.account,
+        transaction,
+        ...options.submit
+      })
+    };
+  }
+  /**
+   * 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) {
+    const functionName = params.useSponsoredUsdVariant ? "register_blob_with_sponsor" : "register_blob";
+    return {
+      function: `${(params.deployer ?? SHELBY_DEPLOYER).toString()}::blob_metadata::${functionName}`,
+      functionArguments: [
+        params.blobName,
+        params.expirationMicros,
+        Hex3.fromHexString(params.blobMerkleRoot).toUint8Array(),
+        params.numChunksets,
+        params.blobSize,
+        // TODO
+        0,
+        // payment tier
+        params.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 functionName = params.useSponsoredUsdVariant ? "register_multiple_blobs_with_sponsor" : "register_multiple_blobs";
+    const blobNames = [];
+    const blobMerkleRoots = [];
+    const blobNumChunksets = [];
+    const blobSizes = [];
+    params.blobs.forEach((blob) => {
+      blobNames.push(blob.blobName);
+      blobMerkleRoots.push(
+        Hex3.fromHexString(blob.blobMerkleRoot).toUint8Array()
+      );
+      blobNumChunksets.push(blob.numChunksets);
+      blobSizes.push(blob.blobSize);
+    });
+    return {
+      function: `${(params.deployer ?? SHELBY_DEPLOYER).toString()}::blob_metadata::${functionName}`,
+      functionArguments: [
+        blobNames,
+        params.expirationMicros,
+        blobMerkleRoots,
+        blobNumChunksets,
+        blobSizes,
+        // TODO
+        0,
+        // payment tier
+        params.encoding
+      ]
+    };
+  }
+  /**
+   * Creates a transaction payload to delete 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.blobName - The blob name (e.g. "bar.txt", without the account address prefix).
+   *
+   * @returns An Aptos transaction payload data object for the delete_blob Move function.
+   *
+   * @see https://github.com/shelby/shelby/blob/64e9d7b4f0005e586faeb1e4085c79159234b6b6/move/shelby_contract/sources/global_metadata.move#L616
+   */
+  static createDeleteBlobPayload(params) {
+    return {
+      function: `${(params.deployer ?? SHELBY_DEPLOYER).toString()}::blob_metadata::delete_blob`,
+      functionArguments: [params.blobName]
+    };
+  }
+  /**
+   * Creates a transaction payload to delete multiple blobs on the blockchain.
+   * This is a static helper method for constructing the Move function call payload.
+   *
+   * **Note:** This function requires the `delete_multiple_blobs` entry function
+   * which will be deployed to the smart contract on 2026-02-04. Using this
+   * function before that date will result in a transaction failure.
+   *
+   * This operation is atomic: if any blob deletion fails (e.g., blob not found),
+   * the entire transaction fails and no blobs are deleted.
+   *
+   * @param params.deployer - Optional deployer account address. Defaults to SHELBY_DEPLOYER.
+   * @param params.blobNames - Array of blob name suffixes without the account address prefix
+   *   (e.g. ["foo/bar.txt", "baz.txt"], NOT ["0x1/foo/bar.txt"]). The account address
+   *   prefix is automatically derived from the transaction sender.
+   *
+   * @returns An Aptos transaction payload data object for the delete_multiple_blobs Move function.
+   *
+   * @see https://github.com/shelby/shelby/blob/main/move/shelby_contract/sources/blob_metadata.move
+   */
+  static createDeleteMultipleBlobsPayload(params) {
+    return {
+      function: `${(params.deployer ?? SHELBY_DEPLOYER).toString()}::blob_metadata::delete_multiple_blobs`,
+      functionArguments: [params.blobNames]
+    };
+  }
+  static createBlobAcknowledgementsPayload(params) {
+    const ackBitMask = params.storageProviderAcks.reduce(
+      (acc, ack) => acc | 1 << ack.slot,
+      0
+    );
+    return {
+      function: `${SHELBY_DEPLOYER}::blob_metadata::add_blob_acknowledgements`,
+      functionArguments: [
+        createBlobKey({
+          account: params.blobOwner,
+          blobName: params.blobName
+        }),
+        params.creationMicros,
+        new U32(Number(ackBitMask)),
+        params.storageProviderAcks.map((ack) => ack.signature)
+      ]
+    };
+  }
+  async addBlobAcknowledgements(params) {
+    const transaction = await this.aptos.transaction.build.simple({
+      ...params.options?.build,
+      options: this.orderlessTxOptions(params.options?.build?.options),
+      data: _ShelbyBlobClient.createBlobAcknowledgementsPayload({
+        blobOwner: params.blobOwner,
+        blobName: params.blobName,
+        creationMicros: params.creationMicros,
+        storageProviderAcks: params.storageProviderAcks
+      }),
+      sender: params.account.accountAddress
+    });
+    return {
+      transaction: await this.aptos.signAndSubmitTransaction({
+        signer: params.account,
+        transaction
+      })
+    };
+  }
+};
+
+// src/core/clients/ShelbyMetadataClient.ts
+import {
+  AccountAddress as AccountAddress3,
+  Aptos as Aptos2,
+  Hex as Hex4
+} 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;
+  /**
+   * The ShelbyMetadataClient is used to interact with the Shelby contract on the Aptos blockchain. This
+   * includes functions like gathering basic details about the Shelby system, including storage provider information.
+   *
+   * @param config.aptos.config - The Aptos config.
+   * @param config.shelbyDeployer - The deployer account address of the Shelby contract. If not provided, the default deployer address will be used.
+   *
+   * @example
+   * ```typescript
+   * const aptos = new Aptos(new AptosConfig({ network: Network.TESTNET }));
+   * const metadataClient = new ShelbyMetadataClient({ aptos });
+   * ```
+   */
+  constructor(config) {
+    this.aptos = new Aptos2(getAptosConfig(config));
+    this.deployer = config.deployer ?? AccountAddress3.fromString(SHELBY_DEPLOYER);
+  }
+  /**
+   * Retrieves storage provider list from the blockchain.
+   *
+   * @returns A list of storage providers, or empty array if none exist.
+   *
+   * @example
+   * ```typescript
+   * const spList = await client.getStorageProviders();
+   * ```
+   */
+  async getStorageProviders() {
+    try {
+      const rawMetadata = await this.aptos.view({
+        payload: {
+          function: `${this.deployer.toString()}::storage_provider_registry::get_all_storage_providers`,
+          functionArguments: []
+        }
+      });
+      const metadata = rawMetadata[0];
+      return metadata.map((provider) => ({
+        address: normalizeAddress(provider.address),
+        ipAddress: provider.ip_address,
+        port: provider.port,
+        blsPublicKey: Hex4.fromHexInput(provider.bls_public_key).toUint8Array(),
+        availabilityZone: provider.availability_zone,
+        state: parseStorageProviderState(provider.state)
+      }));
+    } catch (error) {
+      if (error instanceof Error && // Depending on the network, the error message may show up differently.
+      error.message?.includes("sub_status: Some(404)")) {
+        return [];
+      }
+      throw error;
+    }
+  }
+  /**
+   * Retrieves the list of placement group addresses.
+   *
+   * @returns The placement group address list, or an empty array if none exist.
+   *
+   * @example
+   * ```typescript
+   * const pgList = await client.getPlacementGroupAddresses();
+   * ```
+   */
+  async getPlacementGroupAddresses() {
+    try {
+      const pgSizeMetadata = await this.aptos.view({
+        payload: {
+          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()}::placement_group_registry::get_placement_group_addresses`,
+          functionArguments: [0, finalPlacementGroupIndex]
+        }
+      });
+      const metadata = addressMetadataArray[0];
+      return metadata.map((pg) => normalizeAddress(pg));
+    } catch (error) {
+      if (error instanceof Error && // Depending on the network, the error message may show up differently.
+      (error.message?.includes("sub_status: Some(404)") || error.message?.includes("E_PLACEMENT_GROUP_NOT_FOUND"))) {
+        return [];
+      }
+      throw error;
+    }
+  }
+  /**
+   * Retrieves the list of slice addresses.
+   *
+   * @returns The slice group list, or an empty array if none exist.
+   *
+   * @example
+   * ```typescript
+   * const pgList = await client.getSliceAddresses();
+   * ```
+   */
+  async getSliceAddresses() {
+    try {
+      const sliceSizeMetadata = await this.aptos.view({
+        payload: {
+          function: `${this.deployer.toString()}::slice_registry::get_number_of_slices`,
+          functionArguments: []
+        }
+      });
+      const finalSliceIndex = sliceSizeMetadata[0] - 1;
+      const addressMetadataArray = await this.aptos.view({
+        payload: {
+          function: `${this.deployer.toString()}::slice_registry::get_slice_addresses`,
+          functionArguments: [0, finalSliceIndex]
+        }
+      });
+      const metadata = addressMetadataArray[0];
+      return metadata.map((slice) => normalizeAddress(slice));
+    } catch (error) {
+      if (error instanceof Error && // Depending on the network, the error message may show up differently.
+      (error.message?.includes("sub_status: Some(404)") || error.message?.includes("E_SLICE_NOT_FOUND"))) {
+        return [];
+      }
+      throw error;
+    }
+  }
+  /**
+   * Gets the placement group address for a slice.
+   *
+   * @param sliceAddress - The address of the slice account.
+   * @returns The placement group address as a string.
+   */
+  async getPlacementGroupAddressForSlice(sliceAddress) {
+    const sliceMetadata = await this.aptos.view({
+      payload: {
+        function: `${this.deployer.toString()}::slice::get_slice_info`,
+        functionArguments: [sliceAddress.toString()]
+      }
+    });
+    return sliceMetadata[0].placement_group_assignments[0].placement_group_address;
+  }
+  /**
+   * Retrieves the designated storage providers for a slice.
+   *
+   * Designated SPs are those appointed to store data for their slots:
+   * - Active: Currently serving data
+   * - Receiving: Receiving data during slot transfer
+   * - Repairing: Repairing data after crash or failed transfer
+   * - Reconstructing: Reconstructing data if the repair fails
+   *
+   * @param params.account - The address of the slice account.
+   * @returns An array where result[i] is the designated SP for slot i, or null if no SP is designated.
+   *
+   * @example
+   * ```typescript
+   * const providers = await client.getDesignatedStorageProvidersForSlice({ account: sliceAddress });
+   * ```
+   */
+  async getDesignatedStorageProvidersForSlice(params) {
+    const placementGroupAddress = await this.getPlacementGroupAddressForSlice(
+      params.account
+    );
+    const rawMetadata = await this.aptos.view({
+      payload: {
+        function: `${this.deployer.toString()}::placement_group::get_designated_storage_providers`,
+        functionArguments: [placementGroupAddress]
+      }
+    });
+    const providers = rawMetadata[0];
+    return providers.map(
+      (opt) => opt.vec.length > 0 ? normalizeAddress(opt.vec[0]) : null
+    );
+  }
+  /**
+   * Retrieves the serving storage providers for a slice.
+   *
+   * Serving SPs are those that can respond to read requests. The serving logic is:
+   * - If an Active SP exists for a slot: Only the Active SP is serving
+   * - If no Active SP (transition in progress): Both Designated and Vacating SPs serve
+   *
+   * Each slot may have multiple serving SPs during transitions.
+   *
+   * @param params.account - The address of the slice account.
+   * @returns An array where result[i] contains the serving SPs for slot i.
+   *
+   * @example
+   * ```typescript
+   * const providers = await client.getServingStorageProvidersForSlice({ account: sliceAddress });
+   * ```
+   */
+  async getServingStorageProvidersForSlice(params) {
+    const placementGroupAddress = await this.getPlacementGroupAddressForSlice(
+      params.account
+    );
+    const rawMetadata = await this.aptos.view({
+      payload: {
+        function: `${this.deployer.toString()}::placement_group::get_serving_storage_providers`,
+        functionArguments: [placementGroupAddress]
+      }
+    });
+    const providers = rawMetadata[0];
+    return providers.map(
+      (slotProviders) => slotProviders.map((addr) => normalizeAddress(addr))
+    );
+  }
+};
+
+// src/core/clients/ShelbyRPCClient.ts
+import {
+  Hex as Hex6
+} from "@aptos-labs/ts-sdk";
+
+// src/core/layout.ts
+import { z as z2 } from "zod";
+var BlobNameSchema = z2.string().min(1, "Blob name path parameter cannot be empty.").max(
+  190,
+  "Blob name suffix cannot exceed 190 characters (on-chain full key limit is 256 bytes)."
+).refine((name) => !name.endsWith("/"), {
+  message: "Blob name cannot end with a slash"
+});
+
+// src/core/promises.ts
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/core/rpc-responses.ts
+import { z as z3 } from "zod";
+var ChallengeResponseSchema = z3.object({
+  challenge: z3.string(),
+  expiresAt: z3.number()
+});
+var MultipartUploadStatusResponseSchema = z3.object({
+  uploadId: z3.string(),
+  completedParts: z3.array(z3.number()),
+  partSize: z3.number(),
+  nParts: z3.number(),
+  uploadedBytes: z3.number()
+});
+var StartMultipartUploadResponseSchema = z3.object({
+  uploadId: z3.string()
+});
+var UploadPartResponseSchema = z3.object({
+  success: z3.literal(true)
+});
+var CompleteMultipartUploadResponseSchema = z3.object({
+  success: z3.literal(true)
+});
+var RPCErrorResponseSchema = z3.object({
+  error: z3.string()
+});
+var StaleMicropaymentErrorResponseSchema = z3.object({
+  error: z3.string().optional(),
+  storedMicropayment: z3.string().optional()
+});
+
+// src/core/types/payments.ts
+import {
+  AccountAddress as AccountAddress4,
+  Deserializer,
+  Hex as Hex5,
+  Serializer
+} from "@aptos-labs/ts-sdk";
+var MICROPAYMENTS_MODULE_NAME = "micropayments";
+var WITHDRAW_APPROVAL_STRUCT_NAME = "WithdrawApproval";
+function serializeTypeInfo(serializer, moduleAddress, moduleName, structName) {
+  moduleAddress.serialize(serializer);
+  const moduleNameBytes = new TextEncoder().encode(moduleName);
+  serializer.serializeBytes(moduleNameBytes);
+  const structNameBytes = new TextEncoder().encode(structName);
+  serializer.serializeBytes(structNameBytes);
+}
+var StaleChannelStateError = class _StaleChannelStateError extends Error {
+  /**
+   * The last valid micropayment stored by the server.
+   * Clients can use this to reset their local channel state.
+   */
+  storedMicropayment;
+  constructor(storedMicropayment, message) {
+    super(
+      message ?? "Client has stale channel state. Use the returned micropayment to reset local state."
+    );
+    this.name = "StaleChannelStateError";
+    this.storedMicropayment = storedMicropayment;
+  }
+  /**
+   * Returns the stored micropayment as a base64-encoded string.
+   */
+  toBase64() {
+    const bytes = this.storedMicropayment.bcsToBytes();
+    const binaryString = Array.from(
+      bytes,
+      (byte) => String.fromCharCode(byte)
+    ).join("");
+    return btoa(binaryString);
+  }
+  /**
+   * Creates a StaleChannelStateError from a base64-encoded micropayment string.
+   */
+  static fromBase64(base64, message) {
+    const binaryString = atob(base64);
+    const bytes = Uint8Array.from(binaryString, (char) => char.charCodeAt(0));
+    const micropayment = SenderBuiltMicropayment.deserialize(bytes);
+    return new _StaleChannelStateError(micropayment, message);
+  }
+};
+var SenderBuiltMicropayment = class _SenderBuiltMicropayment {
+  /**
+   * The sender's address (owner of the payment channel).
+   */
+  sender;
+  /**
+   * The receiver's address (beneficiary of the withdrawal).
+   */
+  receiver;
+  /**
+   * The unique ID of the payment channel.
+   */
+  paymentChannelId;
+  /**
+   * The cumulative amount the receiver is authorized to withdraw.
+   */
+  amount;
+  /**
+   * The fungible asset metadata address.
+   */
+  fungibleAssetAddress;
+  /**
+   * Monotonically increasing sequence number for replay protection.
+   */
+  sequenceNumber;
+  /**
+   * The sender's Ed25519 public key (32 bytes).
+   * Used by the receiver to verify the signature before submitting.
+   */
+  publicKey;
+  /**
+   * The Ed25519 signature of the SignedMessage<WithdrawApproval> struct.
+   * The SignedMessage includes TypeInfo for domain separation.
+   */
+  signature;
+  /**
+   * The deployer address of the micropayments module.
+   * This is needed to reconstruct the TypeInfo for signature verification.
+   */
+  deployer;
+  constructor(sender, receiver, paymentChannelId, amount, fungibleAssetAddress, sequenceNumber, publicKey, signature, deployer) {
+    this.sender = sender;
+    this.receiver = receiver;
+    this.paymentChannelId = paymentChannelId;
+    this.amount = amount;
+    this.fungibleAssetAddress = fungibleAssetAddress;
+    this.sequenceNumber = sequenceNumber;
+    this.publicKey = publicKey;
+    this.signature = signature;
+    this.deployer = deployer ?? AccountAddress4.fromString(MICROPAYMENTS_DEPLOYER);
+  }
+  /**
+   * Creates the BCS-serialized message that was signed.
+   * This is a SignedMessage<WithdrawApproval> which includes:
+   * 1. TypeInfo (module_address, module_name, struct_name)
+   * 2. WithdrawApproval struct fields
+   *
+   * This format is used with signature_verify_strict_t for domain separation.
+   */
+  getSignedMessage() {
+    return _SenderBuiltMicropayment.buildSignedMessage({
+      deployer: this.deployer,
+      sender: this.sender,
+      receiver: this.receiver,
+      fungibleAssetAddress: this.fungibleAssetAddress,
+      amount: this.amount,
+      paymentChannelId: this.paymentChannelId,
+      sequenceNumber: this.sequenceNumber
+    });
+  }
+  /**
+   * Static helper to build the SignedMessage<WithdrawApproval> bytes from raw parameters.
+   * This can be used to create the message for signing without constructing the full object.
+   *
+   * @param params - The withdrawal approval parameters.
+   * @returns The BCS-serialized SignedMessage<WithdrawApproval> bytes.
+   */
+  static buildSignedMessage(params) {
+    const serializer = new Serializer();
+    serializeTypeInfo(
+      serializer,
+      params.deployer,
+      MICROPAYMENTS_MODULE_NAME,
+      WITHDRAW_APPROVAL_STRUCT_NAME
+    );
+    params.sender.serialize(serializer);
+    params.receiver.serialize(serializer);
+    params.fungibleAssetAddress.serialize(serializer);
+    serializer.serializeU64(params.amount);
+    serializer.serializeU64(params.paymentChannelId);
+    serializer.serializeU64(params.sequenceNumber);
+    return serializer.toUint8Array();
+  }
+  serialize(serializer) {
+    this.sender.serialize(serializer);
+    this.receiver.serialize(serializer);
+    this.fungibleAssetAddress.serialize(serializer);
+    serializer.serializeU64(this.amount);
+    serializer.serializeU64(this.paymentChannelId);
+    serializer.serializeU64(this.sequenceNumber);
+    serializer.serializeBytes(this.publicKey);
+    serializer.serializeBytes(this.signature);
+    this.deployer.serialize(serializer);
+  }
+  bcsToBytes() {
+    const serializer = new Serializer();
+    this.serialize(serializer);
+    return serializer.toUint8Array();
+  }
+  bcsToHex() {
+    return Hex5.fromHexInput(this.bcsToBytes());
+  }
+  toStringWithoutPrefix() {
+    return this.bcsToHex().toStringWithoutPrefix();
+  }
+  toString() {
+    return this.bcsToHex().toString();
+  }
+  /**
+   * Deserializes a SenderBuiltMicropayment from BCS bytes.
+   * @param bytes - The bytes to deserialize from (Uint8Array or hex string).
+   * @returns A new SenderBuiltMicropayment instance.
+   */
+  static deserialize(bytes) {
+    const bytesArray = typeof bytes === "string" ? Hex5.fromHexInput(bytes).toUint8Array() : bytes;
+    const deserializer = new Deserializer(bytesArray);
+    const sender = AccountAddress4.deserialize(deserializer);
+    const receiver = AccountAddress4.deserialize(deserializer);
+    const fungibleAssetAddress = AccountAddress4.deserialize(deserializer);
+    const amount = deserializer.deserializeU64();
+    const paymentChannelId = deserializer.deserializeU64();
+    const sequenceNumber = deserializer.deserializeU64();
+    const publicKey = deserializer.deserializeBytes();
+    const signature = deserializer.deserializeBytes();
+    const deployer = AccountAddress4.deserialize(deserializer);
+    return new _SenderBuiltMicropayment(
+      sender,
+      receiver,
+      paymentChannelId,
+      amount,
+      fungibleAssetAddress,
+      sequenceNumber,
+      publicKey,
+      signature,
+      deployer
+    );
+  }
+};
+
+// src/core/clients/ShelbyRPCClient.ts
+var MICROPAYMENT_HEADER = "X-Shelby-Micropayment";
+var BLOB_OWNER_CHALLENGE_HEADER = "X-Shelby-Challenge";
+var BLOB_OWNER_SIGNATURE_HEADER = "X-Shelby-Signature";
+var BLOB_OWNER_PUBLIC_KEY_HEADER = "X-Shelby-Public-Key";
+var BLOB_OWNER_AUTH_SCHEME_HEADER = "X-Shelby-Auth-Scheme";
+var BLOB_OWNER_IDENTITY_HEADER = "X-Shelby-Identity";
+var BLOB_OWNER_DOMAIN_HEADER = "X-Shelby-Domain";
+var BLOB_OWNER_AUTH_FUNCTION_HEADER = "X-Shelby-Auth-Function";
+function buildAuthHeaders(auth) {
+  const signatureBase64 = btoa(
+    Array.from(auth.signature, (byte) => String.fromCharCode(byte)).join("")
+  );
+  const publicKeyHex = Hex6.fromHexInput(auth.publicKey).toString();
+  const headers = {
+    [BLOB_OWNER_CHALLENGE_HEADER]: auth.challenge,
+    [BLOB_OWNER_SIGNATURE_HEADER]: signatureBase64,
+    [BLOB_OWNER_PUBLIC_KEY_HEADER]: publicKeyHex
+  };
+  if (auth.authScheme === "derivable") {
+    headers[BLOB_OWNER_AUTH_SCHEME_HEADER] = auth.authScheme;
+    headers[BLOB_OWNER_IDENTITY_HEADER] = auth.identity;
+    headers[BLOB_OWNER_DOMAIN_HEADER] = auth.domain;
+    headers[BLOB_OWNER_AUTH_FUNCTION_HEADER] = auth.authFunction;
+  } else if (auth.authScheme) {
+    headers[BLOB_OWNER_AUTH_SCHEME_HEADER] = auth.authScheme;
+  }
+  return headers;
+}
+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 isRetryableStatus(status) {
+  return status === 408 || status === 429 || status >= 500;
+}
+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;
+  #signChallengeOverride;
+  /**
+   * 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.
+   * @param options.signChallengeHandler - Optional override for challenge
+   *   signing. When set, `putBlobResumable` uses this instead of the built-in
+   *   `signChallenge`. Intended for kit-level overrides (e.g. Solana DAA).
+   *
+   * @example
+   * ```typescript
+   * const client = new ShelbyRPCClient({
+   *   network: Network.SHELBYNET,
+   *   apiKey: "AG-***",
+   * });
+   * ```
+   */
+  constructor(config, options) {
+    this.baseUrl = getShelbyRPCBaseUrl(config);
+    this.apiKey = config.apiKey ?? config.rpc?.apiKey;
+    this.rpcConfig = config.rpc ?? {};
+    this.indexer = getShelbyIndexerClient(config);
+    this.#signChallengeOverride = options?.signChallengeHandler;
+  }
+  /**
+   * Request an authentication challenge for the given account.
+   * The challenge must be signed and included in subsequent authenticated requests.
+   *
+   * @param account - The Aptos account address to authenticate as.
+   * @returns The challenge string and expiration timestamp.
+   *
+   * @example
+   * ```typescript
+   * const { challenge, expiresAt } = await client.getChallenge(account.accountAddress);
+   * const auth = client.signChallenge(account, challenge);
+   * ```
+   */
+  async getChallenge(account) {
+    const response = await fetch(
+      buildRequestUrl("/v1/auth/challenge", this.baseUrl),
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          ...this.apiKey ? { Authorization: `Bearer ${this.apiKey}` } : {}
+        },
+        body: JSON.stringify({ account: account.toString() })
+      }
+    );
+    if (!response.ok) {
+      const errorBody = await response.text().catch(() => "");
+      throw new Error(
+        `Failed to get challenge: status ${response.status}, body: ${errorBody}`
+      );
+    }
+    return ChallengeResponseSchema.parse(await response.json());
+  }
+  /**
+   * Check if there's an existing multipart upload for a blob.
+   * Returns the upload status including which parts have been uploaded.
+   *
+   * @param account - The account that owns the blob.
+   * @param blobName - The name of the blob.
+   * @returns The upload status, or undefined if no pending upload exists.
+   *
+   * @example
+   * ```typescript
+   * const status = await client.getMultipartUploadStatus(account, "myblob.txt");
+   * if (status) {
+   *   console.log(`Resuming upload ${status.uploadId}, ${status.completedParts.length} parts done`);
+   * }
+   * ```
+   */
+  async getMultipartUploadStatus(account, blobName) {
+    const url = new URL(buildRequestUrl("/v1/multipart-uploads", this.baseUrl));
+    url.searchParams.set("account", account.toString());
+    url.searchParams.set("blobName", blobName);
+    const response = await fetch(url.toString(), {
+      method: "GET",
+      headers: {
+        ...this.apiKey ? { Authorization: `Bearer ${this.apiKey}` } : {}
+      }
+    });
+    if (response.status === 404) {
+      return void 0;
+    }
+    if (!response.ok) {
+      const errorBody = await response.text().catch(() => "");
+      throw new Error(
+        `Failed to get multipart upload status: status ${response.status}, body: ${errorBody}`
+      );
+    }
+    return MultipartUploadStatusResponseSchema.parse(await response.json());
+  }
+  /**
+   * Sign a challenge using the given account and return auth credentials.
+   *
+   * @param account - The Aptos account to sign with.
+   * @param challenge - The hex-encoded challenge string from getChallenge().
+   * @returns BlobOwnerAuth credentials for authenticated requests.
+   */
+  signChallenge(account, challenge) {
+    const challengeBytes = Hex6.fromHexInput(challenge).toUint8Array();
+    const signature = account.sign(challengeBytes);
+    return {
+      challenge,
+      signature: signature.toUint8Array(),
+      publicKey: account.publicKey.toUint8Array()
+    };
+  }
+  async #uploadPart(uploadId, partIdx, partData) {
+    const nRetries = 5;
+    let lastResponse;
+    let lastError;
+    let attempts = 0;
+    const partUrl = buildRequestUrl(
+      `/v1/multipart-uploads/${uploadId}/parts/${partIdx}`,
+      this.baseUrl
+    );
+    for (let i = 0; i < nRetries; ++i) {
+      attempts++;
+      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 (!isRetryableStatus(lastResponse.status)) {
+        break;
+      }
+      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 ${attempts} attempt${attempts === 1 ? "" : "s"}. 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 ${attempts} attempt${attempts === 1 ? "" : "s"}. 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
+    );
+  }
+  /**
+   * Upload a part with authentication headers.
+   */
+  async #uploadPartWithAuth(uploadId, partIdx, partData, auth) {
+    const nRetries = 5;
+    let lastResponse;
+    let lastError;
+    let attempts = 0;
+    const partUrl = buildRequestUrl(
+      `/v1/multipart-uploads/${uploadId}/parts/${partIdx}`,
+      this.baseUrl
+    );
+    const authHeaders = buildAuthHeaders(auth);
+    for (let i = 0; i < nRetries; ++i) {
+      attempts++;
+      try {
+        lastResponse = await fetch(partUrl, {
+          method: "PUT",
+          headers: {
+            "Content-Type": "application/octet-stream",
+            ...this.apiKey ? { Authorization: `Bearer ${this.apiKey}` } : {},
+            ...authHeaders
+          },
+          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 (!isRetryableStatus(lastResponse.status)) {
+        break;
+      }
+      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 ${attempts} attempt${attempts === 1 ? "" : "s"}. ${errorCode ? `(${errorCode}) ` : ""}Last error: ${errorMessage}`,
+        { cause: lastError }
+      );
+    }
+    const errorBody = await lastResponse?.text().catch(() => "");
+    throw new Error(
+      `Failed to upload part ${partIdx} for multipart upload ${uploadId} after ${attempts} attempt${attempts === 1 ? "" : "s"}. status: ${lastResponse?.status}, body: ${errorBody}`
+    );
+  }
+  /**
+   * Uploads blob data to the Shelby RPC node with authentication and resume support.
+   * This method authenticates using challenge-response and can resume interrupted uploads.
+   *
+   * @param params.account - The Aptos Account (with signing capability) 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.
+   * @param params.onProgress - Optional callback for upload progress.
+   *
+   * @example
+   * ```typescript
+   * await client.putBlobResumable({
+   *   account: myAccount, // Aptos Account with signing capability
+   *   blobName: "documents/report.pdf",
+   *   blobData: fileData,
+   *   totalBytes: fileData.length,
+   * });
+   * ```
+   */
+  async putBlobResumable(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);
+    const partSize = params.partSize ?? 5 * 1024 * 1024;
+    const { challenge } = await this.getChallenge(
+      params.account.accountAddress
+    );
+    const signFn = this.#signChallengeOverride ?? this.signChallenge.bind(this);
+    const auth = signFn(params.account, challenge);
+    const authHeaders = buildAuthHeaders(auth);
+    const existingUpload = await this.getMultipartUploadStatus(
+      params.account.accountAddress,
+      params.blobName
+    );
+    let uploadId;
+    let completedPartsSet;
+    let totalParts;
+    if (existingUpload) {
+      uploadId = existingUpload.uploadId;
+      completedPartsSet = new Set(existingUpload.completedParts);
+      totalParts = existingUpload.nParts;
+      if (existingUpload.partSize !== partSize) {
+        throw new Error(
+          `Cannot resume upload: part size mismatch. Existing upload uses ${existingUpload.partSize} bytes, but ${partSize} was requested.`
+        );
+      }
+    } else {
+      const startResponse = await fetch(
+        buildRequestUrl("/v1/multipart-uploads", this.baseUrl),
+        {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            ...this.apiKey ? { Authorization: `Bearer ${this.apiKey}` } : {},
+            ...authHeaders
+          },
+          body: JSON.stringify({
+            rawAccount: params.account.accountAddress.toString(),
+            rawBlobName: params.blobName,
+            rawPartSize: partSize
+          })
+        }
+      );
+      if (!startResponse.ok) {
+        const errorBodyText = await startResponse.text().catch(() => "");
+        throw new Error(
+          `Failed to start multipart upload! status: ${startResponse.status}, body: ${errorBodyText}`
+        );
+      }
+      const parsed = StartMultipartUploadResponseSchema.parse(
+        await startResponse.json()
+      );
+      uploadId = parsed.uploadId;
+      completedPartsSet = /* @__PURE__ */ new Set();
+      totalParts = Math.ceil(totalBytes / partSize);
+    }
+    let uploadedBytes = 0;
+    let partIdx = 0;
+    for await (const [idx, partData] of readInChunks(
+      params.blobData,
+      partSize
+    )) {
+      partIdx = idx;
+      if (completedPartsSet.has(partIdx)) {
+        uploadedBytes += partData.length;
+        continue;
+      }
+      await this.#uploadPartWithAuth(uploadId, partIdx, partData, auth);
+      uploadedBytes += partData.length;
+      params.onProgress?.({
+        phase: "uploading",
+        partIdx,
+        totalParts,
+        partBytes: partData.length,
+        uploadedBytes,
+        totalBytes
+      });
+    }
+    const finalPartIdx = totalParts > 0 ? totalParts - 1 : 0;
+    params.onProgress?.({
+      phase: "finalizing",
+      partIdx: finalPartIdx,
+      totalParts,
+      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}` } : {},
+          ...authHeaders
+        }
+      }
+    );
+    if (!completeResponse.ok) {
+      const errorBodyText = await completeResponse.text().catch(() => "");
+      throw new Error(
+        `Failed to complete multipart upload! status: ${completeResponse.status}, body: ${errorBodyText}`
+      );
+    }
+  }
+  /**
+   * 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
+    };
+  }
+};
+
+// src/core/clients/ShelbyClient.ts
+var ShelbyClient = class {
+  /**
+   * The coordination client is used to interact with the Aptos blockchain which handles the commitments
+   * and metadata for blobs.
+   */
+  coordination;
+  /**
+   * The metadata client is used for protocol-level metadata queries.
+   */
+  metadata;
+  /**
+   * The RPC client is used to interact with the Shelby RPC node which can be responsible for storing,
+   * confirming, and retrieving blobs from the storage layer.
+   *
+   * If not provided, the default RPC client will be created.
+   */
+  rpc;
+  /**
+   * The configuration for the Shelby client.
+   */
+  config;
+  /**
+   * The Aptos client.
+   *
+   * If not provided, a default Aptos client will be created.
+   */
+  aptos;
+  /**
+   * The erasure coding provider used for encoding/decoding operations.
+   * Lazily initialized on first use if not provided.
+   */
+  _provider;
+  /**
+   * Creates a new ShelbyClient instance for interacting with the Shelby Protocol.
+   * This client combines blockchain operations (via coordination) and storage operations (via RPC).
+   *
+   * @param config - The client configuration object.
+   * @param config.aptos.config - The Aptos network configuration.
+   * @param config.shelby.rpc.baseUrl - The base URL of the Shelby RPC node (optional, defaults to devnet).
+   * @param config.shelby.indexer - The indexer configuration for GraphQL queries.
+   * @param provider - Optional erasure coding provider for encoding/decoding operations.
+   *                   If not provided, a ClayErasureCodingProvider will be created on first use.
+   *                   Pass a shared provider to reuse across multiple clients.
+   *
+   * @example
+   * ```typescript
+   * // Basic usage (provider created automatically)
+   * const client = new ShelbyClient({
+   *   network: Network.SHELBYNET,
+   * });
+   *
+   * // Advanced: Share provider across multiple clients
+   * const provider = await ClayErasureCodingProvider.create();
+   * const mainnetClient = new ShelbyClient(mainnetConfig, provider);
+   * const devnetClient = new ShelbyClient(devnetConfig, provider);
+   * ```
+   */
+  constructor(config, provider) {
+    this.config = config;
+    this.aptos = new Aptos3(getAptosConfig(config));
+    this.coordination = new ShelbyBlobClient(config);
+    this.metadata = new ShelbyMetadataClient(config);
+    this.rpc = new ShelbyRPCClient(config, {
+      signChallengeHandler: (account, challenge) => this.signChallenge(account, challenge)
+    });
+    this._provider = provider;
+  }
+  /**
+   * Sign an authentication challenge for blob owner verification.
+   *
+   * The default implementation delegates to `ShelbyRPCClient.signChallenge`
+   * which works for standard Ed25519 accounts. Kits that use derived /
+   * abstracted accounts (Solana, Ethereum) should override this method to
+   * provide the correct public key bytes and derivation metadata.
+   */
+  signChallenge(account, challenge) {
+    return this.rpc.signChallenge(account, challenge);
+  }
+  /**
+   * Get the erasure coding provider, creating it if necessary.
+   * This allows lazy initialization for users who don't provide a provider.
+   */
+  async getProvider() {
+    if (!this._provider) {
+      this._provider = await ClayErasureCodingProvider.create(
+        defaultErasureCodingConfig()
+      );
+    }
+    return this._provider;
+  }
+  /**
+   * The base URL for the Shelby RPC node.
+   */
+  get baseUrl() {
+    return getShelbyRPCBaseUrl(this.config);
+  }
+  /**
+   * Uploads a blob to the Shelby network.
+   * This method handles the complete upload flow including commitment generation,
+   * blockchain registration, and storage upload.
+   *
+   * Note: This method accepts only `Uint8Array` and buffers the entire blob in memory.
+   * For streaming uploads of large files (e.g. >2 GiB), orchestrate the steps manually
+   * using `generateCommitments()`, `coordination.registerBlob()`, and `rpc.putBlob()`
+   * with a `ReadableStream`.
+   *
+   * @param params.blobData - The raw data to upload as a Uint8Array.
+   * @param params.signer - The account that signs and pays for the transaction.
+   * @param params.blobName - The name/path of the blob (e.g. "folder/file.txt").
+   * @param params.expirationMicros - The expiration time in microseconds since Unix epoch.
+   * @param params.options - Optional upload configuration.
+   * @param params.options.chunksetSizeBytes - Custom chunkset size.
+   * @param params.options.build - Additional Aptos transaction options.
+   *
+   * @returns The transaction and generated blob commitments (when implemented).
+   *
+   * @example
+   * ```typescript
+   * await client.upload({
+   *   blobData: Buffer.from("Hello, World!"),
+   *   signer: account,
+   *   blobName: "hello.txt",
+   *   expirationMicros: Date.now() * 1000 + 86400_000_000 // 24 hours from now
+   * });
+   * ```
+   */
+  async upload(params) {
+    const existingBlobMetadata = await this.coordination.getBlobMetadata({
+      account: params.signer.accountAddress,
+      name: params.blobName
+    });
+    if (!existingBlobMetadata) {
+      const provider = await this.getProvider();
+      const blobCommitments = await generateCommitments(
+        provider,
+        params.blobData
+      );
+      const { transaction: pendingRegisterBlobTransaction } = await this.coordination.registerBlob({
+        account: params.signer,
+        blobName: params.blobName,
+        blobMerkleRoot: blobCommitments.blob_merkle_root,
+        size: params.blobData.length,
+        expirationMicros: params.expirationMicros,
+        config: provider.config,
+        options: params.options
+      });
+      await this.coordination.aptos.waitForTransaction({
+        transactionHash: pendingRegisterBlobTransaction.hash
+      });
+    }
+    await this.rpc.putBlobResumable({
+      account: params.signer,
+      blobName: params.blobName,
+      blobData: params.blobData
+    });
+  }
+  /**
+   * Uploads a batch of blobs to the Shelby network.
+   * This method handles the complete upload flow including commitment generation,
+   * blockchain registration, and storage upload.
+   *
+   * Note: This method accepts only `Uint8Array` and buffers each blob in memory.
+   * For streaming uploads of large files, orchestrate the steps manually using
+   * `generateCommitments()`, `coordination.registerBlob()`, and `rpc.putBlob()`
+   * with a `ReadableStream`.
+   *
+   * @param params.blobs - The blobs to upload.
+   * @param params.blobs.blobData - The raw data to upload as a Uint8Array.
+   * @param params.blobs.blobName - The name/path of the blob (e.g. "folder/file.txt").
+   * @param params.expirationMicros - The expiration time in microseconds since Unix epoch.
+   * @param params.signer - The account that signs and pays for the transaction.
+   * @param params.options - Optional upload configuration.
+   * @param params.options.chunksetSizeBytes - Custom chunkset size.
+   * @param params.options.build - Additional Aptos transaction options.
+   *
+   * @returns The transaction and generated blob commitments (when implemented).
+   *
+   * @example
+   * ```typescript
+   * await client.batchUpload({
+   *   blobs: [
+   *     { blobData: Buffer.from("Hello, World!"), blobName: "hello.txt" },
+   *     { blobData: Buffer.from("Hello, World 2!"), blobName: "hello2.txt" },
+   *   ],
+   *   expirationMicros: Date.now() * 1000 + 86400_000_000 // 24 hours from now
+   * });
+   * ```
+   */
+  async batchUpload(params) {
+    const existingBlobs = await this.coordination.getBlobs({
+      where: {
+        blob_name: {
+          _in: params.blobs.map(
+            (blob) => createBlobKey({
+              account: params.signer.accountAddress,
+              blobName: blob.blobName
+            })
+          )
+        }
+      }
+    });
+    const blobsToRegister = params.blobs.filter(
+      (blob) => !existingBlobs.some(
+        (existingBlob) => existingBlob.name === createBlobKey({
+          account: params.signer.accountAddress,
+          blobName: blob.blobName
+        })
+      )
+    );
+    if (blobsToRegister.length > 0) {
+      const provider = await this.getProvider();
+      const blobCommitments = await Promise.all(
+        blobsToRegister.map(
+          async (blob) => generateCommitments(provider, blob.blobData)
+        )
+      );
+      const { transaction: pendingRegisterBlobTransaction } = await this.coordination.batchRegisterBlobs({
+        account: params.signer,
+        expirationMicros: params.expirationMicros,
+        blobs: blobsToRegister.map((blob, index) => ({
+          blobName: blob.blobName,
+          blobSize: blob.blobData.length,
+          blobMerkleRoot: blobCommitments[index].blob_merkle_root
+        })),
+        config: provider.config,
+        options: params.options
+      });
+      await this.coordination.aptos.waitForTransaction({
+        transactionHash: pendingRegisterBlobTransaction.hash,
+        options: { waitForIndexer: true }
+      });
+    }
+    const limit = pLimit(3);
+    await Promise.all(
+      params.blobs.map(
+        (blob) => limit(
+          () => this.rpc.putBlobResumable({
+            account: params.signer,
+            blobName: blob.blobName,
+            blobData: blob.blobData
+          })
+        )
+      )
+    );
+  }
+  /**
+   * Downloads a blob from the Shelby RPC node.
+   *
+   * @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 blob data.
+   *
+   * @example
+   * ```typescript
+   * const blob = await client.download({
+   *   account,
+   *   blobName: "foo/bar.txt",
+   * });
+   * ```
+   */
+  async download(params) {
+    return await this.rpc.getBlob(params);
+  }
+  /**
+   *
+   * Funds an account with ShelbyUSD tokens.
+   *
+   * @param params.address - The address to fund.
+   * @param params.amount - The amount to fund.
+   * @returns The transaction hash of the funded account.
+   *
+   * @example
+   * ```typescript
+   * const hash = await client.fundAccountWithShelbyUSD({
+   *   address: "0x1",
+   *   amount: 100000000,
+   * });
+   * ```
+   */
+  async fundAccountWithShelbyUSD(params) {
+    if (this.config.network === Network3.TESTNET) {
+      throw new Error(
+        `ShelbyUSD cannot be minted programmatically on ${Network3.TESTNET}. Please use the faucet at https://docs.shelby.xyz/apis/faucet/shelbyusd instead.`
+      );
+    }
+    const { address, amount } = params;
+    try {
+      const faucet = this.config.faucet?.baseUrl ?? "https://faucet.shelbynet.shelby.xyz/fund?asset=shelbyusd";
+      const authToken = this.config.faucet?.authToken;
+      const response = await fetch(`${faucet}`, {
+        method: "POST",
+        body: JSON.stringify({
+          address: normalizeAddress(address).toString(),
+          amount
+        }),
+        headers: {
+          "Content-Type": "application/json",
+          ...authToken ? { Authorization: `Bearer ${authToken}` } : {}
+        }
+      });
+      if (!response.ok) {
+        const errorBody = await response.text();
+        throw new Error(`Failed to fund account: ${errorBody}`);
+      }
+      const json = await response.json();
+      const res = await this.aptos.waitForTransaction({
+        transactionHash: json.txn_hashes[0],
+        options: {
+          timeoutSecs: DEFAULT_TXN_TIMEOUT_SEC,
+          checkSuccess: true
+        }
+      });
+      if (res.type === TransactionResponseType.User) {
+        return res.hash;
+      }
+      throw new Error(
+        `Unexpected transaction received for fund account: ${res.type}`
+      );
+    } catch (error) {
+      throw new Error(`Failed to fund account: ${error}`);
+    }
+  }
+  /**
+   * Fund an account with APT tokens
+   *
+   * @param params.address - The address to fund
+   * @param params.amount - The amount to fund
+   * @returns The transaction hash of the funded account
+   *
+   * @example
+   * ```typescript
+   * const hash = await client.fundAccountWithAPT({
+   *   address: "0x1",
+   *   amount: 100000000,
+   * });
+   * ```
+   */
+  async fundAccountWithAPT(params) {
+    const transaction = await this.aptos.fundAccount({
+      accountAddress: params.address,
+      amount: params.amount
+    });
+    return transaction.hash;
+  }
+};
 export {
   ShelbyClient
 };