@shelby-protocol/sdk 0.3.1 → 0.4.1

package/dist/core/clients/ShelbyClientConfig.d.ts

@@ -5,7 +5,7 @@ import { ShelbyNetwork } from '../networks.js';
  * Configuration for the Shelby RPC connection.
  */
 type ShelbyRPCConfig = {
-    /** Base URL of the Shelby RPC node (e.g., "https://api.shelbynet.shelby.xyz/shelby"). */
+    /** Base URL of the Shelby RPC node (e.g., "https://shelby.shelbynet.shelby.xyz/shelby"). */
     baseUrl?: string;
     /** API key for authenticating with the RPC node. */
     apiKey?: string;
@@ -57,6 +57,14 @@ interface ShelbyClientConfig {
      * generated automatically for each transaction.
      */
     orderless?: boolean;
+    /**
+     * Best-effort location (region) hint sent with every blob registration from this client,
+     * typically the location closest to where the client runs. Honored only for accounts in
+     * the default `FollowHint` location-preference mode, and overridden by a per-write
+     * `selectedLocation`. Without a resolvable location (no preference, no selection, no
+     * hint), writes abort on chain.
+     */
+    locationHint?: string;
 }
 
 export type { ShelbyClientConfig, ShelbyIndexerConfig, ShelbyRPCConfig };

package/dist/core/clients/ShelbyMetadataClient.d.ts

@@ -32,27 +32,41 @@ declare class ShelbyMetadataClient {
      */
     getStorageProviders(): Promise<StorageProviderInfo[]>;
     /**
-     * Retrieves the list of placement group addresses.
+     * Retrieves the names of every activated location (region). Locations that are
+     * registered but not yet brought online are admin-internal and not listed.
      *
+     * @returns The location name list.
+     *
+     * @example
+     * ```typescript
+     * const locations = await client.getLocationNames();
+     * ```
+     */
+    getLocationNames(): Promise<string[]>;
+    /**
+     * Retrieves the list of placement group addresses in a location.
+     *
+     * @param locationName - The location whose placement groups to list.
      * @returns The placement group address list, or an empty array if none exist.
      *
      * @example
      * ```typescript
-     * const pgList = await client.getPlacementGroupAddresses();
+     * const pgList = await client.getPlacementGroupAddresses("us-east-1");
      * ```
      */
-    getPlacementGroupAddresses(): Promise<AccountAddress[]>;
+    getPlacementGroupAddresses(locationName: string): Promise<AccountAddress[]>;
     /**
-     * Retrieves the list of slice addresses.
+     * Retrieves the list of slice addresses in a location.
      *
+     * @param locationName - The location whose slices to list.
      * @returns The slice group list, or an empty array if none exist.
      *
      * @example
      * ```typescript
-     * const pgList = await client.getSliceAddresses();
+     * const pgList = await client.getSliceAddresses("us-east-1");
      * ```
      */
-    getSliceAddresses(): Promise<AccountAddress[]>;
+    getSliceAddresses(locationName: string): Promise<AccountAddress[]>;
     /**
      * Gets the placement group address for a slice.
      *
@@ -80,6 +94,24 @@ declare class ShelbyMetadataClient {
     getDesignatedStorageProvidersForSlice(params: {
         account: AccountAddressInput;
     }): Promise<(AccountAddress | 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 });
+     * ```
+     */
+    getActiveStorageProvidersForSlice(params: {
+        account: AccountAddressInput;
+    }): Promise<(AccountAddress | null)[]>;
     /**
      * Retrieves the serving storage providers for a slice.
      *

package/dist/core/clients/ShelbyMetadataClient.mjs

@@ -8,7 +8,7 @@ import {
 // src/core/constants.ts
 import { Network } from "@aptos-labs/ts-sdk";
 var NetworkToShelbyRPCBaseUrl = {
-  [Network.SHELBYNET]: "https://api.shelbynet.shelby.xyz/shelby",
+  [Network.SHELBYNET]: "https://shelby.shelbynet.shelby.xyz/shelby",
   [Network.NETNA]: void 0,
   [Network.DEVNET]: void 0,
   [Network.TESTNET]: "https://api.testnet.shelby.xyz/shelby",
@@ -36,6 +36,18 @@ var NetworkToGasStationBaseUrl = {
 };
 var SHELBY_DEPLOYER = "0x85fdb9a176ab8ef1d9d9c1b60d60b3924f0800ac1de1cc2085fb0b8bb4988e6a";
 
+// src/core/types/storage_providers.ts
+var ACTIVE_PROVIDER_CONDITIONS = [
+  "Normal",
+  "Faulty",
+  "Leaving",
+  "Evicted",
+  "PendingLeaving"
+];
+function isActiveProviderCondition(value) {
+  return typeof value === "string" && ACTIVE_PROVIDER_CONDITIONS.includes(value);
+}
+
 // src/core/utils.ts
 import {
   AccountAddress,
@@ -77,6 +89,15 @@ var getAptosConfig = (config) => {
 };
 
 // src/core/clients/ShelbyMetadataClient.ts
+function parseActiveProviderCondition(raw) {
+  const variant = raw?.__variant__;
+  if (!isActiveProviderCondition(variant)) {
+    throw new Error(
+      `Unknown ActiveProviderCondition variant: ${JSON.stringify(raw)}`
+    );
+  }
+  return variant;
+}
 function parseStorageProviderState(raw) {
   switch (raw.__variant__) {
     case "Active":
@@ -84,8 +105,7 @@ function parseStorageProviderState(raw) {
         variant: "Active",
         quota: raw.quota.value,
         stakeAtStartOfStakingEpoch: raw.stake_at_start_of_staking_epoch,
-        faulty: raw.faulty,
-        leaving: raw.leaving
+        condition: parseActiveProviderCondition(raw.condition)
       };
     case "Waitlisted":
       return {
@@ -98,6 +118,10 @@ function parseStorageProviderState(raw) {
         frozenFrom: raw.frozen_from,
         frozenTill: raw.frozen_till
       };
+    default:
+      throw new Error(
+        `Unknown StorageProviderStateDetails variant: ${JSON.stringify(raw)}`
+      );
   }
 }
 var ShelbyMetadataClient = class {
@@ -156,28 +180,52 @@ var ShelbyMetadataClient = class {
     }
   }
   /**
-   * Retrieves the list of placement group addresses.
+   * Retrieves the names of every activated location (region). Locations that are
+   * registered but not yet brought online are admin-internal and not listed.
+   *
+   * @returns The location name list.
+   *
+   * @example
+   * ```typescript
+   * const locations = await client.getLocationNames();
+   * ```
+   */
+  async getLocationNames() {
+    const names = await this.aptos.view({
+      payload: {
+        function: `${this.deployer.toString()}::location::activated_location_names`,
+        functionArguments: []
+      }
+    });
+    return names[0];
+  }
+  /**
+   * Retrieves the list of placement group addresses in a location.
    *
+   * @param locationName - The location whose placement groups to list.
    * @returns The placement group address list, or an empty array if none exist.
    *
    * @example
    * ```typescript
-   * const pgList = await client.getPlacementGroupAddresses();
+   * const pgList = await client.getPlacementGroupAddresses("us-east-1");
    * ```
    */
-  async getPlacementGroupAddresses() {
+  async getPlacementGroupAddresses(locationName) {
     try {
       const pgSizeMetadata = await this.aptos.view({
         payload: {
           function: `${this.deployer.toString()}::placement_group_registry::get_number_of_placement_groups`,
-          functionArguments: []
+          functionArguments: [locationName]
         }
       });
+      if (Number(pgSizeMetadata[0]) === 0) {
+        return [];
+      }
       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]
+          functionArguments: [locationName, 0, finalPlacementGroupIndex]
         }
       });
       const metadata = addressMetadataArray[0];
@@ -191,28 +239,32 @@ var ShelbyMetadataClient = class {
     }
   }
   /**
-   * Retrieves the list of slice addresses.
+   * Retrieves the list of slice addresses in a location.
    *
+   * @param locationName - The location whose slices to list.
    * @returns The slice group list, or an empty array if none exist.
    *
    * @example
    * ```typescript
-   * const pgList = await client.getSliceAddresses();
+   * const pgList = await client.getSliceAddresses("us-east-1");
    * ```
    */
-  async getSliceAddresses() {
+  async getSliceAddresses(locationName) {
     try {
       const sliceSizeMetadata = await this.aptos.view({
         payload: {
           function: `${this.deployer.toString()}::slice_registry::get_number_of_slices`,
-          functionArguments: []
+          functionArguments: [locationName]
         }
       });
+      if (Number(sliceSizeMetadata[0]) === 0) {
+        return [];
+      }
       const finalSliceIndex = sliceSizeMetadata[0] - 1;
       const addressMetadataArray = await this.aptos.view({
         payload: {
           function: `${this.deployer.toString()}::slice_registry::get_slice_addresses`,
-          functionArguments: [0, finalSliceIndex]
+          functionArguments: [locationName, 0, finalSliceIndex]
         }
       });
       const metadata = addressMetadataArray[0];
@@ -272,6 +324,36 @@ var ShelbyMetadataClient = class {
       (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.
    *

package/dist/core/clients/ShelbyMicropaymentChannelClient.d.ts

@@ -111,6 +111,48 @@ declare class ShelbyMicropaymentChannelClient {
         fungibleAssetAddress: AccountAddress;
         publicKey: Uint8Array;
     }): InputGenerateTransactionPayloadData;
+    /**
+     * Withdraws funds from a micropayment channel as the sender.
+     *
+     * @param params.sender - The account that is withdrawing funds.
+     * @param params.receiver - The account the channel is configured to send funds to.
+     * @param params.fungibleAssetAddress - The account address of the fungible asset.
+     * @param params.options - Optional transaction generation options.
+     *
+     * @returns An object containing the pending transaction.
+     *
+     * @example
+     * ```typescript
+     * const { transaction } = await client.senderWithdraw({
+     *   sender: sender,
+     *   receiver: receiver,
+     *   fungibleAssetAddress: fungibleAssetAddress,
+     * });
+     * ```
+     */
+    senderWithdraw(params: {
+        sender: Account;
+        receiver: AccountAddress;
+        fungibleAssetAddress: AccountAddress;
+        options?: InputGenerateTransactionOptions;
+    }): Promise<{
+        transaction: PendingTransactionResponse;
+    }>;
+    /**
+     * Creates a static payload for the sender_withdraw Move function.
+     * This is a helper method for constructing the transaction payload without signing.
+     *
+     * @param params.deployer - Optional deployer account address. Defaults to MICROPAYMENTS_DEPLOYER.
+     * @param params.receiver - The account address of the receiver.
+     * @param params.fungibleAssetAddress - The account address of the fungible asset.
+     *
+     * @returns An Aptos transaction payload data object for the sender_withdraw Move function.
+     */
+    static createSenderWithdrawPayload(params: {
+        deployer?: AccountAddress;
+        receiver: AccountAddress;
+        fungibleAssetAddress: AccountAddress;
+    }): InputGenerateTransactionPayloadData;
     /**
      * Creates a micropayment that can be sent to a receiver.
      * The sender signs a WithdrawApproval message that authorizes the receiver

package/dist/core/clients/ShelbyMicropaymentChannelClient.mjs

@@ -8,7 +8,7 @@ import {
 // src/core/constants.ts
 import { Network } from "@aptos-labs/ts-sdk";
 var NetworkToShelbyRPCBaseUrl = {
-  [Network.SHELBYNET]: "https://api.shelbynet.shelby.xyz/shelby",
+  [Network.SHELBYNET]: "https://shelby.shelbynet.shelby.xyz/shelby",
   [Network.NETNA]: void 0,
   [Network.DEVNET]: void 0,
   [Network.TESTNET]: "https://api.testnet.shelby.xyz/shelby",
@@ -76,18 +76,20 @@ 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) {
+    uid
+    object_name
     owner
     blob_commitment
-    blob_name
     created_at
     expires_at
+    updated_at
     num_chunksets
-    is_deleted
-    is_written
-    placement_group
     size
-    updated_at
     slice_address
+    placement_group
+    is_persisted
+    is_committed
+    is_deleted
   }
 }
     `;
@@ -99,7 +101,8 @@ var GetBlobActivitiesDocument = gql`
     limit: $limit
     offset: $offset
   ) {
-    blob_name
+    uid
+    object_name
     event_index
     event_type
     transaction_hash
@@ -544,6 +547,58 @@ var ShelbyMicropaymentChannelClient = class _ShelbyMicropaymentChannelClient {
       ]
     };
   }
+  /**
+   * Withdraws funds from a micropayment channel as the sender.
+   *
+   * @param params.sender - The account that is withdrawing funds.
+   * @param params.receiver - The account the channel is configured to send funds to.
+   * @param params.fungibleAssetAddress - The account address of the fungible asset.
+   * @param params.options - Optional transaction generation options.
+   *
+   * @returns An object containing the pending transaction.
+   *
+   * @example
+   * ```typescript
+   * const { transaction } = await client.senderWithdraw({
+   *   sender: sender,
+   *   receiver: receiver,
+   *   fungibleAssetAddress: fungibleAssetAddress,
+   * });
+   * ```
+   */
+  async senderWithdraw(params) {
+    const transaction = await this.aptos.transaction.build.simple({
+      options: params.options,
+      data: _ShelbyMicropaymentChannelClient.createSenderWithdrawPayload({
+        deployer: this.deployer,
+        receiver: params.receiver,
+        fungibleAssetAddress: params.fungibleAssetAddress
+      }),
+      sender: params.sender.accountAddress
+    });
+    return {
+      transaction: await this.aptos.signAndSubmitTransaction({
+        signer: params.sender,
+        transaction
+      })
+    };
+  }
+  /**
+   * Creates a static payload for the sender_withdraw Move function.
+   * This is a helper method for constructing the transaction payload without signing.
+   *
+   * @param params.deployer - Optional deployer account address. Defaults to MICROPAYMENTS_DEPLOYER.
+   * @param params.receiver - The account address of the receiver.
+   * @param params.fungibleAssetAddress - The account address of the fungible asset.
+   *
+   * @returns An Aptos transaction payload data object for the sender_withdraw Move function.
+   */
+  static createSenderWithdrawPayload(params) {
+    return {
+      function: `${(params.deployer ?? MICROPAYMENTS_DEPLOYER).toString()}::micropayments::sender_withdraw`,
+      functionArguments: [params.receiver, params.fungibleAssetAddress]
+    };
+  }
   /**
    * Creates a micropayment that can be sent to a receiver.
    * The sender signs a WithdrawApproval message that authorizes the receiver

package/dist/core/clients/ShelbyPlacementGroupClient.mjs

@@ -8,7 +8,7 @@ import { AptosConfig } 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.SHELBYNET]: "https://shelby.shelbynet.shelby.xyz/shelby",
   [Network.NETNA]: void 0,
   [Network.DEVNET]: void 0,
   [Network.TESTNET]: "https://api.testnet.shelby.xyz/shelby",
@@ -70,18 +70,20 @@ 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) {
+    uid
+    object_name
     owner
     blob_commitment
-    blob_name
     created_at
     expires_at
+    updated_at
     num_chunksets
-    is_deleted
-    is_written
-    placement_group
     size
-    updated_at
     slice_address
+    placement_group
+    is_persisted
+    is_committed
+    is_deleted
   }
 }
     `;
@@ -93,7 +95,8 @@ var GetBlobActivitiesDocument = gql`
     limit: $limit
     offset: $offset
   ) {
-    blob_name
+    uid
+    object_name
     event_index
     event_type
     transaction_hash

package/dist/core/clients/ShelbyRPCClient.d.ts

@@ -1,10 +1,12 @@
 import { Account, AccountAddressInput } from '@aptos-labs/ts-sdk';
 import { ShelbyBlob } from '../blobs.js';
-import { BlobName } from '../layout.js';
+import { BlobCommitments } from '../commitments.js';
 import { ShelbyIndexerClient } from '../operations/index.js';
-import { ChallengeResponse, MultipartUploadStatusResponse } from '../rpc-responses.js';
+import { ChallengeResponse } from '../rpc-responses.js';
+import { StorageProviderAck } from '../types/blobs.js';
 import { SenderBuiltMicropayment } from '../types/payments.js';
 import { ShelbyRPCConfig, ShelbyClientConfig } from './ShelbyClientConfig.js';
+import '../layout.js';
 import 'zod';
 import '../../clay-codes-DdXABBDx.js';
 import '@shelby-protocol/clay-codes';
@@ -44,13 +46,26 @@ interface DerivableBlobOwnerAuth extends BlobOwnerAuthBase {
  */
 type BlobOwnerAuth = Ed25519BlobOwnerAuth | DerivableBlobOwnerAuth;
 type BlobDataSource = Uint8Array | ReadableStream<Uint8Array>;
-type PutBlobProgress = {
-    phase: "uploading" | "finalizing";
-    partIdx: number;
-    totalParts: number;
-    partBytes: number;
+type PutBlobChunksetsProgress = {
+    phase: "uploading";
+    chunksetIdx: number;
+    totalChunksets: number;
+    chunksetBytes: number;
     uploadedBytes: number;
     totalBytes: number;
+    acksReceived?: number;
+    /** SP blob acknowledgements from this chunkset (if any) */
+    spAcks?: StorageProviderAck[];
+};
+/**
+ * Result of putBlobChunksets operation.
+ */
+type PutBlobChunksetsResult = {
+    /**
+     * Aggregated SP blob acknowledgements collected across all chunksets.
+     * Deduplicated by slot (latest signature wins if an SP acks multiple times).
+     */
+    spAcks: StorageProviderAck[];
 };
 declare class ShelbyRPCClient {
     #private;
@@ -65,7 +80,7 @@ declare class ShelbyRPCClient {
      * @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
+     *   signing. When set, `putBlobChunksets` uses this instead of the built-in
      *   `signChallenge`. Intended for kit-level overrides (e.g. Solana DAA).
      *
      * @example
@@ -93,23 +108,6 @@ declare class ShelbyRPCClient {
      * ```
      */
     getChallenge(account: AccountAddressInput): Promise<ChallengeResponse>;
-    /**
-     * 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`);
-     * }
-     * ```
-     */
-    getMultipartUploadStatus(account: AccountAddressInput, blobName: string): Promise<MultipartUploadStatusResponse | undefined>;
     /**
      * Sign a challenge using the given account and return auth credentials.
      *
@@ -119,62 +117,53 @@ declare class ShelbyRPCClient {
      */
     signChallenge(account: Account, challenge: string): BlobOwnerAuth;
     /**
-     * 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!");
+     * Uploads blob data to the Shelby RPC node using the v2 chunkset API.
+     * This method authenticates using challenge-response and uploads chunksets
+     * directly to storage providers via the RPC's worker pool.
      *
-     * await client.putBlob({
-     *   account: AccountAddress.from("0x1"),
-     *   blobName: "greetings/hello.txt",
-     *   blobData,
-     * });
-     * ```
-     */
-    putBlob(params: {
-        account: AccountAddressInput;
-        blobName: BlobName;
-        blobData: BlobDataSource;
-        /** Required when blobData is a ReadableStream. Inferred from .length for Uint8Array. */
-        totalBytes?: number;
-        onProgress?: (progress: PutBlobProgress) => void;
-    }): Promise<void>;
-    /**
-     * Uploads blob data to the Shelby RPC node with authentication and resume support.
-     * This method authenticates using challenge-response and can resume interrupted uploads.
+     * This method:
+     * - Sends raw chunkset data directly to the RPC for erasure encoding
+     * - Requires pre-computed blob commitments to generate inclusion proofs
+     * - Does not support resume (each chunkset is idempotent on the SP side)
      *
      * @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.uid - The blob's on-chain UID (from `BlobRegisteredEvent` at registration).
      * @param params.blobData - The raw blob data as a Uint8Array or ReadableStream.
+     * @param params.commitments - Pre-computed blob commitments (from generateCommitments).
      * @param params.totalBytes - Total byte length. Required for streams; optional for Uint8Array.
+     * @param params.chunksetConcurrency - Number of chunksets to upload in parallel. Defaults to 4.
      * @param params.onProgress - Optional callback for upload progress.
+     * @param params.signal - Optional AbortSignal for cancellation. When aborted, in-flight
+     *   HTTP requests are cancelled and an AbortError is thrown.
      *
      * @example
      * ```typescript
-     * await client.putBlobResumable({
-     *   account: myAccount, // Aptos Account with signing capability
-     *   blobName: "documents/report.pdf",
+     * // First, generate commitments for the blob
+     * const commitments = await generateCommitments(provider, fileData);
+     *
+     * // Register the blob on chain, then read its UID from the register tx's
+     * // BlobRegisteredEvent (see ShelbyBlobClient.registeredBlobUids).
+     *
+     * // Upload using chunkset API
+     * await rpcClient.putBlobChunksets({
+     *   account: myAccount,
+     *   uid: blobUid,
      *   blobData: fileData,
-     *   totalBytes: fileData.length,
+     *   commitments,
+     *   chunksetConcurrency: 8,
      * });
      * ```
      */
-    putBlobResumable(params: {
+    putBlobChunksets(params: {
         account: Account;
-        blobName: BlobName;
+        uid: bigint;
         blobData: BlobDataSource;
+        commitments: BlobCommitments;
         totalBytes?: number;
-        partSize?: number;
-        onProgress?: (progress: PutBlobProgress) => void;
-    }): Promise<void>;
+        chunksetConcurrency?: number;
+        onProgress?: (progress: PutBlobChunksetsProgress) => void;
+        signal?: AbortSignal;
+    }): Promise<PutBlobChunksetsResult>;
     /**
      * Downloads a blob from the Shelby RPC node.
      * Returns a streaming response with validation to ensure data integrity.
@@ -225,4 +214,4 @@ declare class ShelbyRPCClient {
     }): Promise<ShelbyBlob>;
 }
 
-export { type AuthScheme, type BlobDataSource, type BlobOwnerAuth, type DerivableBlobOwnerAuth, type Ed25519BlobOwnerAuth, type PutBlobProgress, ShelbyRPCClient };
+export { type AuthScheme, type BlobDataSource, type BlobOwnerAuth, type DerivableBlobOwnerAuth, type Ed25519BlobOwnerAuth, type PutBlobChunksetsProgress, type PutBlobChunksetsResult, ShelbyRPCClient };