@shelby-protocol/sdk 0.3.0 → 0.4.0

package/dist/chunk-OEK24ON7.mjs

@@ -1,135 +0,0 @@
-// 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;
-  }
-};
-function buildClayConfig(input) {
-  const { erasure_n, erasure_k, erasure_d, chunkSizeBytes, enumIndex } = input;
-  if (erasure_n <= 0)
-    throw new Error("erasure_n (total number of chunks) must be > 0");
-  if (erasure_k <= 0)
-    throw new Error("erasure_k (number of data chunks) must be > 0");
-  if (erasure_k >= erasure_n)
-    throw new Error(
-      `erasure_k (${erasure_k}) must be < erasure_n (${erasure_n})`
-    );
-  if (erasure_d <= erasure_k)
-    throw new Error(
-      `erasure_d (${erasure_d}) must be > erasure_k (${erasure_k})`
-    );
-  if (erasure_d >= erasure_n)
-    throw new Error(
-      `erasure_d (${erasure_d}) must be < erasure_n (${erasure_n})`
-    );
-  if (chunkSizeBytes <= 0) throw new Error("chunkSizeBytes must be > 0");
-  return {
-    erasure_n,
-    erasure_k,
-    erasure_d,
-    chunkSizeBytes,
-    enumIndex
-  };
-}
-
-export {
-  ClayErasureCodingProvider,
-  buildClayConfig
-};

package/dist/chunk-RNNJXTX2.mjs

@@ -1,154 +0,0 @@
-import {
-  concatHashes,
-  readInChunks,
-  zeroPadBytes
-} from "./chunk-UEZNZBJO.mjs";
-import {
-  DEFAULT_CHUNKSET_SIZE_BYTES
-} from "./chunk-JTXYKO3U.mjs";
-import {
-  DEFAULT_ERASURE_K,
-  DEFAULT_ERASURE_M
-} from "./chunk-AUQDI5BS.mjs";
-
-// src/core/commitments.ts
-import { Hex } from "@aptos-labs/ts-sdk";
-import { z } from "zod";
-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 = Hex.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) => Hex.fromHexInput(a2))
-  );
-  const entry = {
-    chunkset_root: a.toString(),
-    chunk_commitments: chunkRoots.map(
-      (chunk) => Hex.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
-  };
-}
-
-export {
-  COMMITMENT_SCHEMA_VERSION,
-  ChunksetCommitmentSchema,
-  expectedTotalChunksets,
-  BlobCommitmentsSchema,
-  generateMerkleRoot,
-  generateCommitments
-};

package/dist/chunk-S6Q4OG7H.mjs

@@ -1,83 +0,0 @@
-import {
-  getShelbyIndexerClient
-} from "./chunk-NEO7Z3ZQ.mjs";
-
-// src/core/clients/ShelbyPlacementGroupClient.ts
-var ShelbyPlacementGroupClient = class {
-  indexer;
-  /**
-   * Creates a new ShelbyPlacementGroupClient.
-   *
-   * @param config - The client configuration object.
-   *
-   * @example
-   * ```typescript
-   * const pgClient = new ShelbyPlacementGroupClient({
-   *   network: Network.SHELBYNET,
-   * });
-   * ```
-   */
-  constructor(config) {
-    this.indexer = getShelbyIndexerClient(config);
-  }
-  /**
-   * Retrieves placement group slots from the indexer.
-   *
-   * @param params.where (optional) - The where clause to filter slots by.
-   * @param params.pagination (optional) - The pagination options.
-   * @param params.orderBy (optional) - The order by clause to sort slots by.
-   * @returns The placement group slots that match the filter.
-   *
-   * @example
-   * ```typescript
-   * // Get all active slots
-   * const slots = await client.getPlacementGroupSlots({
-   *   where: { status: { _eq: "active" } },
-   * });
-   * ```
-   */
-  async getPlacementGroupSlots(params) {
-    const { limit, offset } = params.pagination ?? {};
-    const { orderBy, where } = params;
-    const { placement_group_slots } = await this.indexer.getPlacementGroupSlots(
-      {
-        where,
-        limit,
-        offset,
-        orderBy
-      }
-    );
-    return placement_group_slots.map(
-      (slot) => ({
-        placementGroup: slot.placement_group,
-        slotIndex: Number(slot.slot_index),
-        storageProvider: slot.storage_provider,
-        status: slot.status,
-        updatedAt: Number(slot.updated_at)
-      })
-    );
-  }
-  /**
-   * Retrieves the total count of placement group slots from the indexer.
-   *
-   * @param params.where (optional) - The where clause to filter slots by.
-   * @returns The count of placement group slots that match the filter.
-   *
-   * @example
-   * ```typescript
-   * // Get count of active slots
-   * const count = await client.getPlacementGroupSlotsCount({
-   *   where: { status: { _eq: "active" } },
-   * });
-   * ```
-   */
-  async getPlacementGroupSlotsCount(params) {
-    const { where } = params;
-    const { placement_group_slots_aggregate } = await this.indexer.getPlacementGroupSlotsCount({ where });
-    return placement_group_slots_aggregate?.aggregate?.count ?? 0;
-  }
-};
-
-export {
-  ShelbyPlacementGroupClient
-};

package/dist/chunk-TET3DJEO.mjs

@@ -1,199 +0,0 @@
-// src/core/operations/generated/sdk.ts
-import gql from "graphql-tag";
-var Blob_Activities_Select_Column = /* @__PURE__ */ ((Blob_Activities_Select_Column2) => {
-  Blob_Activities_Select_Column2["BlobName"] = "blob_name";
-  Blob_Activities_Select_Column2["EventIndex"] = "event_index";
-  Blob_Activities_Select_Column2["EventType"] = "event_type";
-  Blob_Activities_Select_Column2["Timestamp"] = "timestamp";
-  Blob_Activities_Select_Column2["TransactionHash"] = "transaction_hash";
-  Blob_Activities_Select_Column2["TransactionVersion"] = "transaction_version";
-  return Blob_Activities_Select_Column2;
-})(Blob_Activities_Select_Column || {});
-var Blobs_Select_Column = /* @__PURE__ */ ((Blobs_Select_Column2) => {
-  Blobs_Select_Column2["BlobCommitment"] = "blob_commitment";
-  Blobs_Select_Column2["BlobName"] = "blob_name";
-  Blobs_Select_Column2["CreatedAt"] = "created_at";
-  Blobs_Select_Column2["ExpiresAt"] = "expires_at";
-  Blobs_Select_Column2["IsDeleted"] = "is_deleted";
-  Blobs_Select_Column2["IsWritten"] = "is_written";
-  Blobs_Select_Column2["NumChunksets"] = "num_chunksets";
-  Blobs_Select_Column2["Owner"] = "owner";
-  Blobs_Select_Column2["PlacementGroup"] = "placement_group";
-  Blobs_Select_Column2["Size"] = "size";
-  Blobs_Select_Column2["SliceAddress"] = "slice_address";
-  Blobs_Select_Column2["UpdatedAt"] = "updated_at";
-  return Blobs_Select_Column2;
-})(Blobs_Select_Column || {});
-var Cursor_Ordering = /* @__PURE__ */ ((Cursor_Ordering2) => {
-  Cursor_Ordering2["Asc"] = "ASC";
-  Cursor_Ordering2["Desc"] = "DESC";
-  return Cursor_Ordering2;
-})(Cursor_Ordering || {});
-var Order_By = /* @__PURE__ */ ((Order_By2) => {
-  Order_By2["Asc"] = "asc";
-  Order_By2["AscNullsFirst"] = "asc_nulls_first";
-  Order_By2["AscNullsLast"] = "asc_nulls_last";
-  Order_By2["Desc"] = "desc";
-  Order_By2["DescNullsFirst"] = "desc_nulls_first";
-  Order_By2["DescNullsLast"] = "desc_nulls_last";
-  return Order_By2;
-})(Order_By || {});
-var Placement_Group_Slots_Select_Column = /* @__PURE__ */ ((Placement_Group_Slots_Select_Column2) => {
-  Placement_Group_Slots_Select_Column2["PlacementGroup"] = "placement_group";
-  Placement_Group_Slots_Select_Column2["SlotIndex"] = "slot_index";
-  Placement_Group_Slots_Select_Column2["Status"] = "status";
-  Placement_Group_Slots_Select_Column2["StorageProvider"] = "storage_provider";
-  Placement_Group_Slots_Select_Column2["UpdatedAt"] = "updated_at";
-  return Placement_Group_Slots_Select_Column2;
-})(Placement_Group_Slots_Select_Column || {});
-var Processor_Status_Select_Column = /* @__PURE__ */ ((Processor_Status_Select_Column2) => {
-  Processor_Status_Select_Column2["LastSuccessVersion"] = "last_success_version";
-  Processor_Status_Select_Column2["LastTransactionTimestamp"] = "last_transaction_timestamp";
-  Processor_Status_Select_Column2["LastUpdated"] = "last_updated";
-  return Processor_Status_Select_Column2;
-})(Processor_Status_Select_Column || {});
-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
-  }
-}
-    `;
-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);
-    }
-  };
-}
-
-export {
-  Blob_Activities_Select_Column,
-  Blobs_Select_Column,
-  Cursor_Ordering,
-  Order_By,
-  Placement_Group_Slots_Select_Column,
-  Processor_Status_Select_Column,
-  GetBlobsDocument,
-  GetBlobActivitiesDocument,
-  GetBlobsCountDocument,
-  GetBlobActivitiesCountDocument,
-  GetTotalBlobsSizeDocument,
-  GetPlacementGroupSlotsDocument,
-  GetPlacementGroupSlotsCountDocument,
-  GetProcessorStatusDocument,
-  getSdk
-};

package/dist/chunk-UEZNZBJO.mjs

@@ -1,104 +0,0 @@
-// 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 });
-}
-
-export {
-  readInChunks,
-  zeroPadBytes,
-  concatHashes,
-  buildRequestUrl,
-  getBlobNameSuffix,
-  normalizeAddress
-};

package/dist/chunk-V46D5NBW.mjs

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