@shelby-protocol/sdk 0.0.1-experimental.3 → 0.0.1

package/dist/chunk-KBUWZXFA.mjs

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

package/dist/chunk-LTV26KU4.mjs

@@ -0,0 +1,141 @@
+import {
+  concatHashes,
+  readInChunks,
+  zeroPadBytes
+} from "./chunk-KBUWZXFA.mjs";
+import {
+  DEFAULT_CHUNKSET_SIZE_BYTES
+} from "./chunk-APML3CGJ.mjs";
+import {
+  DEFAULT_ERASURE_K,
+  DEFAULT_ERASURE_M
+} from "./chunk-ZPW742E7.mjs";
+
+// src/core/commitments.ts
+import { z } from "zod";
+var ChunksetCommitmentSchema = z.object({
+  // Chunkset root (vector commitment of child chunks)
+  chunkset_root: z.string().nullable(),
+  // the size is known statically from the current configuration
+  chunk_commitments: z.array(z.string())
+}).refine(
+  (data) => {
+    return data.chunk_commitments.length === DEFAULT_ERASURE_K + DEFAULT_ERASURE_M;
+  },
+  {
+    message: `Chunkset must have exactly ${DEFAULT_ERASURE_K + DEFAULT_ERASURE_M} chunks (ERASURE_K + ERASURE_M = ${DEFAULT_ERASURE_K} + ${DEFAULT_ERASURE_M})`,
+    path: ["chunk_commitments"]
+  }
+);
+function expectedTotalChunksets(rawSize, chunksetSize = DEFAULT_CHUNKSET_SIZE_BYTES) {
+  if (chunksetSize <= 0) {
+    throw new Error("chunksetSize must be positive");
+  }
+  if (rawSize === 0) return 1;
+  return Math.ceil(rawSize / chunksetSize);
+}
+var BlobCommitmentsSchema = z.object({
+  schema_version: z.string(),
+  raw_data_size: z.number(),
+  // FIXME I am not sure about this being here, or if it should be somewhere else
+  blob_merkle_root: z.string(),
+  chunkset_commitments: z.array(ChunksetCommitmentSchema)
+}).refine(
+  (data) => {
+    return expectedTotalChunksets(data.raw_data_size) === data.chunkset_commitments.length;
+  },
+  {
+    message: "Total chunkset count mismatches with raw data size",
+    // FIXME put more details in here
+    path: ["chunkset_commitments"]
+  }
+);
+async function generateChunksetCommitments(shouldPad, chunksetIdx, chunksetData, expectedChunksetSize, provider, onChunk) {
+  const { erasure_n } = provider.config;
+  const chunkCommitments = [];
+  const chunksetPayload = shouldPad ? zeroPadBytes(chunksetData, expectedChunksetSize) : validatePrePaddedChunkset(
+    chunksetData,
+    expectedChunksetSize,
+    chunksetIdx
+  );
+  const { chunks } = provider.encode(chunksetPayload);
+  if (chunks.length !== erasure_n) {
+    throw new Error(
+      `Erasure provider produced ${chunks.length} chunks, expected ${erasure_n}.`
+    );
+  }
+  let chunkIdx = 0;
+  for (const chunkData of chunks) {
+    if (onChunk !== void 0) {
+      await onChunk(chunksetIdx, chunkIdx, chunkData);
+    }
+    const chunkHash = await concatHashes([chunkData]);
+    chunkCommitments.push(chunkHash);
+    chunkIdx += 1;
+  }
+  const h = await concatHashes(
+    chunkCommitments.map((chunk) => chunk.toUint8Array())
+  );
+  const entry = {
+    chunkset_root: h.toString(),
+    chunk_commitments: chunkCommitments.map((chunk) => chunk.toString())
+  };
+  return { h, entry };
+}
+async function generateCommitments(provider, fullData, onChunk, options) {
+  const expectedChunksetSize = DEFAULT_CHUNKSET_SIZE_BYTES;
+  const shouldPad = options?.pad ?? true;
+  const chunksetCommitments = [];
+  const chunksetCommitmentHashes = [];
+  let rawDataSize = 0;
+  const chunksetGen = readInChunks(fullData, expectedChunksetSize);
+  for await (const [chunksetIdx, chunksetData] of chunksetGen) {
+    rawDataSize += chunksetData.length;
+    const { h, entry } = await generateChunksetCommitments(
+      shouldPad,
+      chunksetIdx,
+      chunksetData,
+      expectedChunksetSize,
+      provider,
+      onChunk
+    );
+    chunksetCommitments.push(entry);
+    chunksetCommitmentHashes.push(h);
+  }
+  if (rawDataSize === 0) {
+    const zeroChunkset = new Uint8Array(expectedChunksetSize);
+    const { h, entry } = await generateChunksetCommitments(
+      shouldPad,
+      0,
+      zeroChunkset,
+      expectedChunksetSize,
+      provider,
+      onChunk
+    );
+    chunksetCommitments.push(entry);
+    chunksetCommitmentHashes.push(h);
+  }
+  return {
+    schema_version: "1.3",
+    raw_data_size: rawDataSize,
+    blob_merkle_root: (await concatHashes(
+      chunksetCommitmentHashes.map((chunk) => chunk.toUint8Array())
+    )).toString(),
+    chunkset_commitments: chunksetCommitments
+  };
+}
+function validatePrePaddedChunkset(chunkset, expectedSize, chunksetIdx) {
+  if (chunkset.byteLength !== expectedSize) {
+    throw new Error(
+      `Chunkset ${chunksetIdx} has size ${chunkset.byteLength} bytes but expected ${expectedSize} bytes. Enable padding or supply pre-padded data before calling generateCommitments.`
+    );
+  }
+  return chunkset;
+}
+
+export {
+  ChunksetCommitmentSchema,
+  expectedTotalChunksets,
+  BlobCommitmentsSchema,
+  generateCommitments
+};

package/dist/chunk-NTJSNNA7.mjs

@@ -0,0 +1,175 @@
+import {
+  getAptosConfig
+} from "./chunk-RBFWGDMY.mjs";
+import {
+  SHELBY_DEPLOYER
+} from "./chunk-HPVCKAN2.mjs";
+
+// src/node/clients/ShelbyMetadataClient.ts
+import {
+  AccountAddress,
+  Aptos,
+  Hex
+} from "@aptos-labs/ts-sdk";
+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 Aptos(getAptosConfig(config));
+    this.deployer = config.deployer ?? AccountAddress.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()}::global_metadata::get_all_storage_providers`,
+          functionArguments: []
+        }
+      });
+      const metadata = rawMetadata[0];
+      return metadata.map((provider) => ({
+        address: AccountAddress.fromString(provider.address),
+        ipAddress: provider.ip_address,
+        port: provider.port,
+        blsPublicKey: Hex.fromHexInput(provider.bls_public_key).toUint8Array(),
+        failureDomain: provider.failure_domain
+      }));
+    } 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()}::global_metadata::get_number_of_placement_groups`,
+          functionArguments: []
+        }
+      });
+      const finalPlacementGroupIndex = pgSizeMetadata[0] - 1;
+      const addressMetadataArray = await this.aptos.view({
+        payload: {
+          function: `${this.deployer.toString()}::global_metadata::get_placement_group_addresses`,
+          functionArguments: [0, finalPlacementGroupIndex]
+        }
+      });
+      const metadata = addressMetadataArray[0];
+      return metadata.map((pg) => AccountAddress.fromString(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()}::global_metadata::get_number_of_slices`,
+          functionArguments: []
+        }
+      });
+      const finalSliceIndex = sliceSizeMetadata[0] - 1;
+      const addressMetadataArray = await this.aptos.view({
+        payload: {
+          function: `${this.deployer.toString()}::global_metadata::get_slice_addresses`,
+          functionArguments: [0, finalSliceIndex]
+        }
+      });
+      const metadata = addressMetadataArray[0];
+      return metadata.map((slice) => AccountAddress.fromString(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;
+    }
+  }
+  /**
+   * Retrieves the storage providers assigned to a slice, through a placement group.
+   *
+   * @param params.account - The address of the slice account.
+   * @returns The list of storage providers for the slice, or an empty array if none exist.
+   *
+   * @example
+   * ```typescript
+   * const pgInfo = await client.getStorageProvidersForSlice();
+   * ```
+   */
+  async getStorageProvidersForSlice(params) {
+    const sliceMetadata = await this.aptos.view({
+      payload: {
+        function: `${this.deployer.toString()}::slice::get_slice_info`,
+        functionArguments: [params.account.toString()]
+      }
+    });
+    const placementGroupAddress = sliceMetadata[0].placement_group_assignments[0].placement_group_address;
+    const rawMetadata = await this.aptos.view({
+      payload: {
+        function: `${this.deployer.toString()}::placement_group::get_placement_group_info`,
+        functionArguments: [placementGroupAddress]
+      }
+    });
+    const members = rawMetadata[0].members;
+    const keys = members.flatMap((m) => {
+      const active = m.active?.vec.map((a) => a.address) ?? [];
+      const others = m.others?.data.map((o) => o.key) ?? [];
+      return [...active, ...others];
+    });
+    return keys.map((k) => AccountAddress.fromString(k));
+  }
+};
+
+export {
+  ShelbyMetadataClient
+};

package/dist/{chunk-QEMIORTL.mjs → chunk-OTBLZL2S.mjs}

@@ -1,7 +1,7 @@
 // src/core/blobs.ts
 import { AccountAddress } from "@aptos-labs/ts-sdk";
 var createBlobKey = (params) => {
-  return `${AccountAddress.from(params.account).toString()}.${params.blobName}`;
+  return `@${AccountAddress.from(params.account).toStringLongWithoutPrefix()}/${params.blobName}`;
 };
 
 export {

package/dist/chunk-RBFWGDMY.mjs

@@ -0,0 +1,30 @@
+// src/core/clients/utils.ts
+import { AptosConfig, Network } from "@aptos-labs/ts-sdk";
+var getAptosConfig = (config) => {
+  if (config.aptos) {
+    return new AptosConfig(config.aptos);
+  }
+  let aptosConfig;
+  switch (config.network) {
+    case "local":
+      aptosConfig = new AptosConfig({
+        network: Network.LOCAL
+      });
+      break;
+    case "shelbynet":
+      aptosConfig = new AptosConfig({
+        network: Network.SHELBYNET,
+        clientConfig: {
+          API_KEY: config.apiKey
+        }
+      });
+      break;
+    default:
+      throw new Error(`Unsupported network: ${config.network}`);
+  }
+  return aptosConfig;
+};
+
+export {
+  getAptosConfig
+};

package/dist/chunk-VRLIOKWG.mjs

@@ -0,0 +1,11 @@
+// src/core/networks.ts
+import { Network } from "@aptos-labs/ts-sdk";
+var shelbyNetworks = [Network.LOCAL, Network.SHELBYNET];
+var isShelbyNetwork = (network) => {
+  return shelbyNetworks.includes(network.toLowerCase());
+};
+
+export {
+  shelbyNetworks,
+  isShelbyNetwork
+};