@shelby-protocol/sdk 0.3.0 → 0.4.0

package/dist/chunk-6FJNAUU5.mjs

@@ -1,278 +0,0 @@
-import {
-  getAptosConfig
-} from "./chunk-V4B3GAMQ.mjs";
-import {
-  normalizeAddress
-} from "./chunk-UEZNZBJO.mjs";
-import {
-  SHELBY_DEPLOYER
-} from "./chunk-MNCQBEMS.mjs";
-
-// src/core/clients/ShelbyMetadataClient.ts
-import {
-  AccountAddress,
-  Aptos,
-  Hex
-} from "@aptos-labs/ts-sdk";
-function parseStorageProviderState(raw) {
-  switch (raw.__variant__) {
-    case "Active":
-      return {
-        variant: "Active",
-        quota: raw.quota.value,
-        stakeAtStartOfStakingEpoch: raw.stake_at_start_of_staking_epoch,
-        faulty: raw.faulty,
-        leaving: raw.leaving
-      };
-    case "Waitlisted":
-      return {
-        variant: "Waitlisted"
-      };
-    case "Frozen":
-      return {
-        variant: "Frozen",
-        frozenReason: raw.frozen_reason,
-        frozenFrom: raw.frozen_from,
-        frozenTill: raw.frozen_till
-      };
-  }
-}
-var ShelbyMetadataClient = class {
-  aptos;
-  deployer;
-  /**
-   * 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()}::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: Hex.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 active storage providers for a slice.
-   *
-   * Active SPs have a complete copy of the data for the slot, and are not in any data transfer/repair/reconstruction phase.
-   * Active SP can be audited for the data it contains.
-   * Each slot has at most one active SP.
-   *
-   * @param params.account - The address of the slice account.
-   * @returns An array where result[i] is the active SP for slot i, or null if no SP is active.
-   *
-   * @example
-   * ```typescript
-   * const providers = await client.getActiveStorageProvidersForSlice({ account: sliceAddress });
-   * ```
-   */
-  async getActiveStorageProvidersForSlice(params) {
-    const placementGroupAddress = await this.getPlacementGroupAddressForSlice(
-      params.account
-    );
-    const rawMetadata = await this.aptos.view({
-      payload: {
-        function: `${this.deployer.toString()}::placement_group::get_active_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))
-    );
-  }
-};
-
-export {
-  ShelbyMetadataClient
-};

package/dist/chunk-6XSZRDLJ.mjs

@@ -1,375 +0,0 @@
-import {
-  ShelbyRPCClient
-} from "./chunk-WFWRBNTW.mjs";
-import {
-  ShelbyBlobClient
-} from "./chunk-5BVSWXQJ.mjs";
-import {
-  defaultErasureCodingConfig
-} from "./chunk-AY3HBWXA.mjs";
-import {
-  ClayErasureCodingProvider
-} from "./chunk-OEK24ON7.mjs";
-import {
-  ShelbyMetadataClient
-} from "./chunk-6FJNAUU5.mjs";
-import {
-  getAptosConfig,
-  getShelbyRPCBaseUrl
-} from "./chunk-V4B3GAMQ.mjs";
-import {
-  createBlobKey
-} from "./chunk-3NRBHSMQ.mjs";
-import {
-  generateCommitments
-} from "./chunk-RNNJXTX2.mjs";
-import {
-  normalizeAddress
-} from "./chunk-UEZNZBJO.mjs";
-
-// src/core/clients/ShelbyClient.ts
-import {
-  Aptos,
-  DEFAULT_TXN_TIMEOUT_SEC,
-  Network,
-  TransactionResponseType
-} from "@aptos-labs/ts-sdk";
-import pLimit from "p-limit";
-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 Aptos(getAptosConfig(config));
-    this.coordination = new ShelbyBlobClient(config);
-    this.metadata = new ShelbyMetadataClient(config);
-    this.rpc = new ShelbyRPCClient(config);
-    this._provider = provider;
-  }
-  /**
-   * 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.putBlob({
-      account: params.signer.accountAddress,
-      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.putBlob({
-            account: params.signer.accountAddress,
-            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 === Network.TESTNET) {
-      throw new Error(
-        `ShelbyUSD cannot be minted programmatically on ${Network.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
-};

package/dist/chunk-7P6ASYW6.mjs

@@ -1,9 +0,0 @@
-var __defProp = Object.defineProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-
-export {
-  __export
-};

package/dist/chunk-A4IG6GSE.mjs

@@ -1,21 +0,0 @@
-import {
-  __export
-} from "./chunk-7P6ASYW6.mjs";
-
-// src/node/testUtil.ts
-var testUtil_exports = {};
-__export(testUtil_exports, {
-  makeChunk: () => makeChunk
-});
-function makeChunk(n) {
-  const c = Buffer.alloc(n);
-  for (let i = 0; i < n; ++i) {
-    c[i] = i % 256;
-  }
-  return c;
-}
-
-export {
-  makeChunk,
-  testUtil_exports
-};