@shelby-protocol/sdk 0.3.1 → 0.4.1

package/dist/node/clients/index.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",
@@ -37,6 +37,18 @@ var NetworkToGasStationBaseUrl = {
 var SHELBY_DEPLOYER = "0x85fdb9a176ab8ef1d9d9c1b60d60b3924f0800ac1de1cc2085fb0b8bb4988e6a";
 var MICROPAYMENTS_DEPLOYER = "0x1ae7275148bf6ef742b658fd9cbcc2e094201606f4a7bc707bab0201da8043ee";
 
+// 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,
@@ -168,6 +180,15 @@ var getShelbyRPCBaseUrl = (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":
@@ -175,8 +196,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 {
@@ -189,6 +209,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 {
@@ -247,28 +271,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];
@@ -282,28 +330,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];
@@ -363,6 +415,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.
    *
@@ -438,6 +520,18 @@ var ERASURE_CODE_PARAMS = {
     enumIndex: 1
   }
 };
+function findErasureSchemeByErasureN(erasureN) {
+  return Object.entries(ERASURE_CODE_PARAMS).find(
+    ([, params]) => params.erasure_n === erasureN
+  );
+}
+function requiredAckCount(erasureN) {
+  const scheme = findErasureSchemeByErasureN(erasureN);
+  if (!scheme) {
+    throw new Error(`Unknown erasure coding scheme with erasure_n=${erasureN}`);
+  }
+  return scheme[1].erasure_d;
+}
 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;
@@ -734,6 +828,35 @@ function erasureCodingConfig(encodingScheme) {
 import { createWasmReedSolomonBinding } from "@shelby-protocol/reed-solomon";
 var DEFAULT_CHUNK_SIZE_BYTES2 = 2 * 1024 * 1024;
 
+// src/core/errors.ts
+var ShelbyLocationErrorCodes = {
+  E_LOCATION_NOT_FOUND: "E_LOCATION_NOT_FOUND",
+  E_SELECTED_LOCATION_CONFLICTS_WITH_LOCK: "E_SELECTED_LOCATION_CONFLICTS_WITH_LOCK",
+  E_NO_LOCATION_SELECTED: "E_NO_LOCATION_SELECTED",
+  E_LOCATION_WRITES_FROZEN: "E_LOCATION_WRITES_FROZEN",
+  E_LOCATION_NOT_ACTIVATED: "E_LOCATION_NOT_ACTIVATED"
+};
+function describeLocationError(errorMessage) {
+  if (errorMessage.includes(ShelbyLocationErrorCodes.E_LOCATION_WRITES_FROZEN)) {
+    return "Cannot write: the resolved location is frozen and not currently accepting new data.";
+  }
+  if (errorMessage.includes(ShelbyLocationErrorCodes.E_LOCATION_NOT_ACTIVATED)) {
+    return "Cannot write: the resolved location is not activated yet.";
+  }
+  if (errorMessage.includes(
+    ShelbyLocationErrorCodes.E_SELECTED_LOCATION_CONFLICTS_WITH_LOCK
+  )) {
+    return "Cannot write: the selected location conflicts with the account's locked location preference.";
+  }
+  if (errorMessage.includes(ShelbyLocationErrorCodes.E_NO_LOCATION_SELECTED)) {
+    return "No write location could be resolved: none was selected and the account has no default location or location hint.";
+  }
+  if (errorMessage.includes(ShelbyLocationErrorCodes.E_LOCATION_NOT_FOUND)) {
+    return "Cannot write: the requested location does not exist.";
+  }
+  return void 0;
+}
+
 // src/core/clients/ShelbyBlobClient.ts
 import {
   AccountAddress as AccountAddress3,
@@ -742,6 +865,27 @@ import {
   U32
 } from "@aptos-labs/ts-sdk";
 
+// src/core/types/blobs.ts
+var BLOB_ENCRYPTION_TO_MOVE_ENUM_INDEX = {
+  Unencrypted: 0,
+  AES_GCM_V1: 1
+};
+function blobEncryptionToMoveEnumIndex(encryption) {
+  return BLOB_ENCRYPTION_TO_MOVE_ENUM_INDEX[encryption];
+}
+function blobEncryptionFromMoveVariant(variant) {
+  switch (variant) {
+    case "Unencrypted":
+      return "Unencrypted";
+    case "AES_GCM_V1":
+      return "AES_GCM_V1";
+    default:
+      throw new Error(
+        "Could not parse encryption from Shelby Smart Contract, this SDK is out of date."
+      );
+  }
+}
+
 // src/core/operations/index.ts
 import { Network as Network2 } from "@aptos-labs/ts-sdk";
 import { GraphQLClient } from "graphql-request";
@@ -751,18 +895,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
   }
 }
     `;
@@ -774,7 +920,8 @@ var GetBlobActivitiesDocument = gql`
     limit: $limit
     offset: $offset
   ) {
-    blob_name
+    uid
+    object_name
     event_index
     event_type
     transaction_hash
@@ -920,6 +1067,22 @@ var MissingTransactionSubmitterError = class extends Error {
     this.name = "MissingTransactionSubmitterError";
   }
 };
+var COMMIT_REJECTION_REASONS = /* @__PURE__ */ new Set([
+  "AlreadyExists",
+  "NoPriorVersion",
+  "EtagMismatch"
+]);
+function encryptionFunctionArgs(params) {
+  if (params.omitEncryptionArg) {
+    if (params.encryption && params.encryption !== "Unencrypted") {
+      throw new Error(
+        `Blob encryption (${params.encryption}) is not supported on this network: the deployed contract predates the encryption upgrade (#1739).`
+      );
+    }
+    return [];
+  }
+  return [blobEncryptionToMoveEnumIndex(params.encryption ?? "Unencrypted")];
+}
 var ShelbyBlobClient = class _ShelbyBlobClient {
   aptos;
   deployer;
@@ -968,7 +1131,10 @@ var ShelbyBlobClient = class _ShelbyBlobClient {
     this.aptos = new Aptos2(getAptosConfig(config));
     this.deployer = config.deployer ?? AccountAddress3.fromString(SHELBY_DEPLOYER);
     this.indexer = getShelbyIndexerClient(config);
-    this.defaultOptions = defaultOptions ?? {};
+    this.defaultOptions = {
+      locationHint: config.locationHint,
+      ...defaultOptions
+    };
     this.orderless = config.orderless ?? false;
   }
   /**
@@ -979,7 +1145,9 @@ var ShelbyBlobClient = class _ShelbyBlobClient {
       build: options?.build ?? this.defaultOptions.build,
       submit: options?.submit ?? this.defaultOptions.submit,
       usdSponsor: options?.usdSponsor ?? this.defaultOptions.usdSponsor,
-      chunksetSizeBytes: options?.chunksetSizeBytes ?? this.defaultOptions.chunksetSizeBytes
+      chunksetSizeBytes: options?.chunksetSizeBytes ?? this.defaultOptions.chunksetSizeBytes,
+      selectedLocation: options?.selectedLocation ?? this.defaultOptions.selectedLocation,
+      locationHint: options?.locationHint ?? this.defaultOptions.locationHint
     };
   }
   /**
@@ -1021,17 +1189,17 @@ var ShelbyBlobClient = class _ShelbyBlobClient {
    *
    * @example
    * ```typescript
-   * const metadata = await client.getBlobMetadata({
+   * const metadata = await client.getFullObjectMetadata({
    *   account: AccountAddress.fromString("0x1"),
    *   name: "foo/bar.txt",
    * });
    * ```
    */
-  async getBlobMetadata(params) {
+  async getFullObjectMetadata(params) {
     try {
       const rawMetadata = await this.aptos.view({
         payload: {
-          function: `${this.deployer.toString()}::blob_metadata::get_blob_metadata`,
+          function: `${this.deployer.toString()}::blob_metadata::get_full_object_metadata`,
           functionArguments: [
             createBlobKey({
               account: params.account,
@@ -1043,47 +1211,94 @@ var ShelbyBlobClient = class _ShelbyBlobClient {
       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: Hex4.fromHexInput(
-          metadata.blob_commitment
-        ).toUint8Array(),
-        owner: normalizeAddress(metadata.owner),
+      const view = rawMetadata[0].vec[0];
+      return this.parseBlobMetadata(view.blob_metadata, {
+        uid: BigInt(view.object_metadata.current_blob_uid),
         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
-      };
+        // Any blob bound under an object name has cleared the commit-time
+        // `is_written()` check, so a resolved object is always written.
+        isWritten: true
+      });
     } 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"))) {
+      (error.message?.includes("sub_status: Some(404)") || error.message?.includes("EBLOB_NOT_FOUND") || error.message?.includes("EOBJECT_NOT_FOUND"))) {
+        return void 0;
+      }
+      throw error;
+    }
+  }
+  /**
+   * Retrieves blob metadata directly by its on-chain UID, including blobs in
+   * the pending (registered-but-not-yet-committed) state that
+   * {@link getFullObjectMetadata} cannot resolve by object name. Returns `undefined`
+   * if no blob has that UID.
+   *
+   * The returned `name`/`blobNameSuffix` are empty: the blob layer is keyed by
+   * UID and carries no object name (a name binding is established only at
+   * commit). `isWritten` reflects whether the blob has been committed.
+   */
+  async getFullObjectMetadataByUid(uid) {
+    try {
+      const rawMetadata = await this.aptos.view(
+        {
+          payload: {
+            function: `${this.deployer.toString()}::blob_metadata::get_blob_metadata`,
+            functionArguments: [uid]
+          }
+        }
+      );
+      if (!rawMetadata?.[0]?.vec?.[0]) {
+        return void 0;
+      }
+      const raw = rawMetadata[0].vec[0];
+      return this.parseBlobMetadata(raw, {
+        uid,
+        name: "",
+        isWritten: raw.state.__variant__ === "CommittedObject"
+      });
+    } catch (error) {
+      if (error instanceof Error && (error.message?.includes("sub_status: Some(404)") || error.message?.includes("EBLOB_NOT_FOUND"))) {
         return void 0;
       }
       throw error;
     }
   }
+  /**
+   * Parse the on-chain `BlobMetadata::V1` view shape into the SDK
+   * {@link FullObjectMetadata}. `uid` / `name` / `isWritten` are supplied by the
+   * caller since they depend on the lookup path (by object name vs by UID).
+   */
+  parseBlobMetadata(raw, extra) {
+    const { content } = raw;
+    const variant = content.encoding.__variant__;
+    if (variant !== "ClayCode_16Total_10Data_13Helper" && variant !== "ClayCode_4Total_2Data_3Helper") {
+      throw new Error(
+        "Could not parse encoding from Shelby Smart Contract, this SDK is out of date."
+      );
+    }
+    const encoding = {
+      variant: "clay",
+      ...ERASURE_CODE_PARAMS[variant],
+      ...ERASURE_CODE_AND_CHUNK_MAPPING[variant]
+    };
+    const encryption = blobEncryptionFromMoveVariant(
+      content.encryption?.__variant__ ?? "Unencrypted"
+    );
+    return {
+      uid: extra.uid,
+      blobMerkleRoot: Hex4.fromHexInput(content.blob_commitment).toUint8Array(),
+      owner: normalizeAddress(raw.owner),
+      name: extra.name,
+      blobNameSuffix: extra.name ? getBlobNameSuffix(extra.name) : "",
+      size: Number(content.blob_size),
+      encoding,
+      encryption,
+      expirationMicros: Number(raw.expiration_micros),
+      creationMicros: Number(raw.creation_micros),
+      sliceAddress: normalizeAddress(raw.slice.inner),
+      isWritten: extra.isWritten
+    };
+  }
   /**
    * Retrieves all the blobs and their metadata for an account from the
    * blockchain.
@@ -1095,7 +1310,7 @@ var ShelbyBlobClient = class _ShelbyBlobClient {
    *
    * @example
    * ```typescript
-   * // BlobMetadata[]
+   * // FullObjectMetadata[]
    * const blobs = await client.getAccountBlobs({
    *   account: AccountAddress.fromString("0x1"),
    * });
@@ -1112,6 +1327,25 @@ var ShelbyBlobClient = class _ShelbyBlobClient {
       orderBy: rest.orderBy
     });
   }
+  /**
+   * Object-facing default filter: only committed, non-deleted, unexpired rows.
+   * The blobs table is UID-keyed, so during an atomic overwrite a single
+   * object_name transiently has two non-deleted rows — the currently committed
+   * blob and the new pending (is_committed = "0") blob. Filtering on
+   * is_committed keeps name lookups/listings pinned to the committed object and
+   * avoids returning or duplicating the in-flight pending row. Applied to
+   * getBlobs *and* the getBlobsCount / getTotalBlobsSize aggregates so counts
+   * and sizes agree with the listing mid-overwrite. Callers can override any
+   * key (e.g. is_committed) via their own `where`.
+   */
+  activeBlobsWhere(where) {
+    const defaultActiveFilter = {
+      expires_at: { _gte: String(Date.now() * 1e3) },
+      is_deleted: { _eq: "0" },
+      is_committed: { _eq: "1" }
+    };
+    return { ...defaultActiveFilter, ...where };
+  }
   /**
    * Retrieves blobs and their metadata from the blockchain.
    *
@@ -1122,7 +1356,7 @@ var ShelbyBlobClient = class _ShelbyBlobClient {
    *
    * @example
    * ```typescript
-   * // BlobMetadata[]
+   * // FullObjectMetadata[]
    * const blobs = await client.getBlobs({
    *   where: { owner: { _eq: AccountAddress.fromString("0x1").toString() } },
    * });
@@ -1131,12 +1365,7 @@ var ShelbyBlobClient = class _ShelbyBlobClient {
   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 finalWhere = this.activeBlobsWhere(where);
     const { blobs } = await this.indexer.getBlobs({
       where: finalWhere,
       limit,
@@ -1145,9 +1374,10 @@ var ShelbyBlobClient = class _ShelbyBlobClient {
     });
     return blobs.map(
       (blob) => ({
+        uid: BigInt(blob.uid),
         owner: normalizeAddress(blob.owner),
-        name: blob.blob_name,
-        blobNameSuffix: getBlobNameSuffix(blob.blob_name),
+        name: blob.object_name,
+        blobNameSuffix: getBlobNameSuffix(blob.object_name),
         blobMerkleRoot: Hex4.fromHexInput(blob.blob_commitment).toUint8Array(),
         size: Number(blob.size),
         // TODO: Add encoding when supported in NCI
@@ -1159,7 +1389,7 @@ var ShelbyBlobClient = class _ShelbyBlobClient {
         expirationMicros: Number(blob.expires_at),
         creationMicros: Number(blob.created_at),
         sliceAddress: normalizeAddress(blob.slice_address),
-        isWritten: Boolean(Number(blob.is_written)),
+        isWritten: Boolean(Number(blob.is_persisted)),
         isDeleted: Boolean(Number(blob.is_deleted))
       })
     );
@@ -1177,12 +1407,15 @@ var ShelbyBlobClient = class _ShelbyBlobClient {
       [`${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"
+      [`${this.deployer.toStringLong()}::blob_metadata::BlobPersistedEvent`]: "write_blob",
+      [`${this.deployer.toStringLong()}::blob_metadata::ObjectCommittedEvent`]: "commit_object",
+      [`${this.deployer.toStringLong()}::blob_metadata::ObjectDeletedEvent`]: "delete_object",
+      [`${this.deployer.toStringLong()}::blob_metadata::ObjectCommitRejectedEvent`]: "reject_object_commit"
     };
     return blob_activities.map(
       (activity) => ({
-        blobName: activity.blob_name,
-        accountAddress: normalizeAddress(activity.blob_name.substring(1, 65)),
+        blobName: activity.object_name,
+        accountAddress: normalizeAddress(activity.object_name.substring(1, 65)),
         type: activityTypeMapping[activity.event_type] ?? "unknown",
         eventType: activity.event_type,
         eventIndex: Number(activity.event_index),
@@ -1205,9 +1438,10 @@ var ShelbyBlobClient = class _ShelbyBlobClient {
    * const count = await client.getBlobsCount();
    * ```
    */
-  async getBlobsCount(params) {
-    const { where } = params;
-    const { blobs_aggregate } = await this.indexer.getBlobsCount({ where });
+  async getBlobsCount(params = {}) {
+    const { blobs_aggregate } = await this.indexer.getBlobsCount({
+      where: this.activeBlobsWhere(params.where)
+    });
     return blobs_aggregate?.aggregate?.count ?? 0;
   }
   /**
@@ -1222,8 +1456,9 @@ var ShelbyBlobClient = class _ShelbyBlobClient {
    * ```
    */
   async getTotalBlobsSize(params = {}) {
-    const { where } = params;
-    const { blobs_aggregate } = await this.indexer.getTotalBlobsSize({ where });
+    const { blobs_aggregate } = await this.indexer.getTotalBlobsSize({
+      where: this.activeBlobsWhere(params.where)
+    });
     return Number(blobs_aggregate?.aggregate?.sum?.size ?? 0);
   }
   /**
@@ -1282,12 +1517,15 @@ var ShelbyBlobClient = class _ShelbyBlobClient {
         deployer: this.deployer,
         account: params.account.accountAddress,
         blobName: params.blobName,
+        selectedLocation: options.selectedLocation,
+        locationHint: options.locationHint,
         blobSize: params.size,
         blobMerkleRoot: params.blobMerkleRoot,
         numChunksets: expectedTotalChunksets(params.size, chunksetSize),
         expirationMicros: params.expirationMicros,
         useSponsoredUsdVariant: options.usdSponsor !== void 0,
-        encoding: config.enumIndex
+        encoding: config.enumIndex,
+        encryption: params.encryption
       }),
       sender: params.account.accountAddress
     };
@@ -1315,16 +1553,16 @@ var ShelbyBlobClient = class _ShelbyBlobClient {
    * @example
    * ```typescript
    *
-   * const { transaction } = await client.deleteBlob({
+   * const { transaction } = await client.deleteObject({
    *   account: signer,
    *   blobName: "foo/bar.txt",
    * });
    * ```
    */
-  async deleteBlob(params) {
+  async deleteObject(params) {
     const transaction = await this.aptos.transaction.build.simple({
       options: this.orderlessTxOptions(params.options),
-      data: _ShelbyBlobClient.createDeleteBlobPayload({
+      data: _ShelbyBlobClient.createDeleteObjectPayload({
         deployer: this.deployer,
         blobName: params.blobName
       }),
@@ -1340,10 +1578,6 @@ var ShelbyBlobClient = class _ShelbyBlobClient {
   /**
    * 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.
    *
@@ -1358,16 +1592,16 @@ var ShelbyBlobClient = class _ShelbyBlobClient {
    * @example
    * ```typescript
    *
-   * const { transaction } = await client.deleteMultipleBlobs({
+   * const { transaction } = await client.deleteMultipleObjects({
    *   account: signer,
    *   blobNames: ["foo/bar.txt", "baz.txt"],
    * });
    * ```
    */
-  async deleteMultipleBlobs(params) {
+  async deleteMultipleObjects(params) {
     const transaction = await this.aptos.transaction.build.simple({
       options: this.orderlessTxOptions(params.options),
-      data: _ShelbyBlobClient.createDeleteMultipleBlobsPayload({
+      data: _ShelbyBlobClient.createDeleteMultipleObjectsPayload({
         deployer: this.deployer,
         blobNames: params.blobNames
       }),
@@ -1425,6 +1659,8 @@ var ShelbyBlobClient = class _ShelbyBlobClient {
       data: _ShelbyBlobClient.createBatchRegisterBlobsPayload({
         deployer: this.deployer,
         account: params.account.accountAddress,
+        selectedLocation: options.selectedLocation,
+        locationHint: options.locationHint,
         expirationMicros: params.expirationMicros,
         blobs: params.blobs.map((blob) => ({
           blobName: blob.blobName,
@@ -1433,7 +1669,8 @@ var ShelbyBlobClient = class _ShelbyBlobClient {
           numChunksets: expectedTotalChunksets(blob.blobSize, chunksetSize)
         })),
         useSponsoredUsdVariant: options.usdSponsor !== void 0,
-        encoding: config.enumIndex
+        encoding: config.enumIndex,
+        encryption: params.encryption
       })
     };
     const transaction = options.usdSponsor ? await this.aptos.transaction.build.multiAgent({
@@ -1448,6 +1685,55 @@ var ShelbyBlobClient = class _ShelbyBlobClient {
       })
     };
   }
+  /**
+   * Extracts the on-chain UIDs assigned at registration from a committed
+   * register transaction's events.
+   *
+   * `register_blob` / `register_multiple_blobs` create *pending* blobs and emit
+   * one `BlobRegisteredEvent` per blob. The UID is published only on this event
+   * (the blob is not yet in the `objects` map, so it cannot be read back by
+   * name), so callers must parse it here before uploading bytes or committing.
+   *
+   * @param events - The committed transaction's events (from `waitForTransaction`).
+   * @param deployer - The contract deployer address.
+   * @returns One entry per registered blob, keyed by its full object name
+   *   (`@<owner>/<suffix>`, matching {@link createBlobKey}).
+   */
+  static registeredBlobUids(events, deployer) {
+    const eventType = `${deployer.toStringLong()}::blob_metadata::BlobRegisteredEvent`;
+    return events.filter((event) => event.type === eventType).map((event) => {
+      const data = event.data;
+      return { objectName: data.object_name, uid: BigInt(data.uid) };
+    });
+  }
+  /**
+   * Detects whether `commit_object` rejected the write for `uid` rather than
+   * applying it. A rejected commit is still a *successful* transaction — the
+   * contract tears down the pending blob and emits `ObjectCommitRejectedEvent`
+   * instead of aborting — so callers must inspect the finalized transaction's
+   * events to tell a durable write apart from a silent no-op.
+   *
+   * @param events - The committed transaction's events (from `waitForTransaction`).
+   * @param deployer - The contract deployer address.
+   * @param uid - The UID passed to `commit_object`.
+   * @returns The rejection reason, or `undefined` if the commit was applied.
+   */
+  static findObjectCommitRejection(events, deployer, uid) {
+    const eventType = `${deployer.toStringLong()}::blob_metadata::ObjectCommitRejectedEvent`;
+    const rejection = events.find(
+      (event) => event.type === eventType && BigInt(event.data.uid) === uid
+    );
+    if (!rejection) {
+      return void 0;
+    }
+    const reason = rejection.data.rejection_reason.__variant__;
+    if (!COMMIT_REJECTION_REASONS.has(reason)) {
+      throw new Error(
+        `Unrecognized ObjectCommitRejectedEvent rejection_reason '${reason}' for uid ${uid}`
+      );
+    }
+    return reason;
+  }
   /**
    * Creates a transaction payload to register a blob on the blockchain.
    * This is a static helper method for constructing the Move function call payload.
@@ -1461,8 +1747,6 @@ var ShelbyBlobClient = class _ShelbyBlobClient {
    * @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";
@@ -1470,6 +1754,8 @@ var ShelbyBlobClient = class _ShelbyBlobClient {
       function: `${(params.deployer ?? SHELBY_DEPLOYER).toString()}::blob_metadata::${functionName}`,
       functionArguments: [
         params.blobName,
+        params.selectedLocation ?? null,
+        params.locationHint ?? null,
         params.expirationMicros,
         Hex4.fromHexString(params.blobMerkleRoot).toUint8Array(),
         params.numChunksets,
@@ -1477,7 +1763,8 @@ var ShelbyBlobClient = class _ShelbyBlobClient {
         // TODO
         0,
         // payment tier
-        params.encoding
+        params.encoding,
+        ...encryptionFunctionArgs(params)
       ]
     };
   }
@@ -1495,8 +1782,6 @@ var ShelbyBlobClient = class _ShelbyBlobClient {
    * @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";
@@ -1516,6 +1801,8 @@ var ShelbyBlobClient = class _ShelbyBlobClient {
       function: `${(params.deployer ?? SHELBY_DEPLOYER).toString()}::blob_metadata::${functionName}`,
       functionArguments: [
         blobNames,
+        params.selectedLocation ?? null,
+        params.locationHint ?? null,
         params.expirationMicros,
         blobMerkleRoots,
         blobNumChunksets,
@@ -1523,7 +1810,8 @@ var ShelbyBlobClient = class _ShelbyBlobClient {
         // TODO
         0,
         // payment tier
-        params.encoding
+        params.encoding,
+        ...encryptionFunctionArgs(params)
       ]
     };
   }
@@ -1534,24 +1822,20 @@ var ShelbyBlobClient = class _ShelbyBlobClient {
    * @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
+   * @returns An Aptos transaction payload data object for the delete_object Move function.
    */
-  static createDeleteBlobPayload(params) {
+  static createDeleteObjectPayload(params) {
     return {
-      function: `${(params.deployer ?? SHELBY_DEPLOYER).toString()}::blob_metadata::delete_blob`,
-      functionArguments: [params.blobName]
+      function: `${(params.deployer ?? SHELBY_DEPLOYER).toString()}::blob_metadata::delete_object`,
+      // Second arg is `if_match_etag: Option<vector<u8>>`; `null` => None
+      // (unconditional delete).
+      functionArguments: [params.blobName, null]
     };
   }
   /**
    * 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.
    *
@@ -1560,42 +1844,71 @@ var ShelbyBlobClient = class _ShelbyBlobClient {
    *   (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
+   * @returns An Aptos transaction payload data object for the delete_multiple_objects Move function.
    */
-  static createDeleteMultipleBlobsPayload(params) {
+  static createDeleteMultipleObjectsPayload(params) {
     return {
-      function: `${(params.deployer ?? SHELBY_DEPLOYER).toString()}::blob_metadata::delete_multiple_blobs`,
-      functionArguments: [params.blobNames]
+      function: `${(params.deployer ?? SHELBY_DEPLOYER).toString()}::blob_metadata::delete_multiple_objects`,
+      // Second arg is `if_match_etags: vector<Option<vector<u8>>>`; an empty
+      // vector means "no etag check on any object" (unconditional delete).
+      functionArguments: [params.blobNames, []]
     };
   }
-  static createBlobAcknowledgementsPayload(params) {
-    const ackBitMask = params.storageProviderAcks.reduce(
+  /**
+   * Sort acks by slot and reduce to the `(ack_bits, signatures)` pair the
+   * contract expects: it walks the set bits low-to-high and consumes the
+   * signatures in that same order.
+   */
+  static encodeAcks(storageProviderAcks) {
+    const sortedAcks = [...storageProviderAcks].sort((a, b) => a.slot - b.slot);
+    const ackBitMask = sortedAcks.reduce(
       (acc, ack) => acc | 1 << ack.slot,
       0
     );
     return {
-      function: `${SHELBY_DEPLOYER}::blob_metadata::add_blob_acknowledgements`,
+      ackBits: new U32(Number(ackBitMask)),
+      signatures: sortedAcks.map((ack) => ack.signature)
+    };
+  }
+  /**
+   * Payload for `commit_object(uid, object_name_suffix, overwrite, if_match_etag,
+   * ack_bits, signatures)` — binds a written pending blob under its object name,
+   * finalizing the upload. SP acks may be batched in here (the contract applies
+   * them before the `is_written` check), so register → upload → commit needs
+   * only a single finalize transaction.
+   *
+   * @param params.uid - The blob UID returned at registration.
+   * @param params.blobName - The object name suffix the blob was registered under.
+   * @param params.overwrite - Allow replacing an existing binding under this name.
+   * @param params.storageProviderAcks - Acks applied atomically with the commit.
+   */
+  static createCommitObjectPayload(params) {
+    const { ackBits, signatures } = _ShelbyBlobClient.encodeAcks(
+      params.storageProviderAcks
+    );
+    return {
+      function: `${(params.deployer ?? SHELBY_DEPLOYER).toString()}::blob_metadata::commit_object`,
       functionArguments: [
-        createBlobKey({
-          account: params.blobOwner,
-          blobName: params.blobName
-        }),
-        params.creationMicros,
-        new U32(Number(ackBitMask)),
-        params.storageProviderAcks.map((ack) => ack.signature)
+        params.uid,
+        params.blobName,
+        params.overwrite,
+        // `if_match_etag: Option<vector<u8>>` is `null` => None; conditional
+        // (CAS) writes are not yet exposed by the SDK.
+        null,
+        ackBits,
+        signatures
       ]
     };
   }
-  async addBlobAcknowledgements(params) {
+  async commitObject(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,
+      data: _ShelbyBlobClient.createCommitObjectPayload({
+        deployer: this.deployer,
+        uid: params.uid,
         blobName: params.blobName,
-        creationMicros: params.creationMicros,
+        overwrite: params.overwrite,
         storageProviderAcks: params.storageProviderAcks
       }),
       sender: params.account.accountAddress
@@ -1634,22 +1947,6 @@ 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()
 });
@@ -1866,6 +2163,7 @@ 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";
+var INCLUSION_PROOF_HEADER = "X-Shelby-Inclusion-Proof";
 function buildAuthHeaders(auth) {
   const signatureBase64 = btoa(
     Array.from(auth.signature, (byte) => String.fromCharCode(byte)).join("")
@@ -1889,6 +2187,58 @@ function buildAuthHeaders(auth) {
 function encodeURIComponentKeepSlashes(str) {
   return encodeURIComponent(str).replace(/%2F/g, "/");
 }
+async function generateChunksetInclusionProof(chunksetRoots, chunksetIndex) {
+  if (chunksetRoots.length === 0) {
+    throw new Error("Cannot generate inclusion proof for empty chunkset roots");
+  }
+  if (chunksetIndex < 0 || chunksetIndex >= chunksetRoots.length) {
+    throw new Error(
+      `Chunkset index ${chunksetIndex} out of range [0, ${chunksetRoots.length})`
+    );
+  }
+  if (chunksetRoots.length === 1) {
+    return [];
+  }
+  const zeroHash = new Uint8Array(32);
+  const siblings = [];
+  let currentLeaves = chunksetRoots.map((h) => h.toUint8Array());
+  let currentIdx = chunksetIndex;
+  while (currentLeaves.length > 1) {
+    if (currentLeaves.length % 2 !== 0) {
+      currentLeaves.push(zeroHash);
+    }
+    const siblingIdx = currentIdx % 2 === 0 ? currentIdx + 1 : currentIdx - 1;
+    siblings.push(currentLeaves[siblingIdx]);
+    const nextLeaves = [];
+    for (let i = 0; i < currentLeaves.length; i += 2) {
+      const combined = await concatHashes([
+        currentLeaves[i],
+        currentLeaves[i + 1]
+      ]);
+      nextLeaves.push(combined.toUint8Array());
+    }
+    currentLeaves = nextLeaves;
+    currentIdx = Math.floor(currentIdx / 2);
+  }
+  return siblings;
+}
+function encodeInclusionProof(siblings) {
+  if (siblings.length === 0) {
+    return "NONE";
+  }
+  const totalBytes = siblings.length * 32;
+  const combined = new Uint8Array(totalBytes);
+  let offset = 0;
+  for (const sibling of siblings) {
+    combined.set(sibling, offset);
+    offset += 32;
+  }
+  const binaryString = Array.from(
+    combined,
+    (byte) => String.fromCharCode(byte)
+  ).join("");
+  return btoa(binaryString);
+}
 function validateTotalBytes(totalBytes) {
   if (!Number.isInteger(totalBytes) || totalBytes < 0) {
     throw new Error("totalBytes must be a non-negative integer");
@@ -1920,7 +2270,7 @@ var ShelbyRPCClient = class {
    * @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
@@ -1971,43 +2321,6 @@ var ShelbyRPCClient = class {
     }
     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.
    *
@@ -2024,269 +2337,142 @@ var ShelbyRPCClient = class {
       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.
+   * Upload a single chunkset via the v2 chunkset API.
    */
-  async #uploadPartWithAuth(uploadId, partIdx, partData, auth) {
-    const nRetries = 5;
+  async #uploadChunkset(params) {
+    const maxNonBusyRetries = 5;
     let lastResponse;
     let lastError;
     let attempts = 0;
-    const partUrl = buildRequestUrl(
-      `/v1/multipart-uploads/${uploadId}/parts/${partIdx}`,
+    let consecutive429s = 0;
+    let nonBusyRetries = 0;
+    const chunksetUrl = buildRequestUrl(
+      `/v2/chunksets/${params.account}/${params.chunksetIndex}/${params.uid}`,
       this.baseUrl
     );
-    const authHeaders = buildAuthHeaders(auth);
-    for (let i = 0; i < nRetries; ++i) {
+    const authHeaders = buildAuthHeaders(params.auth);
+    while (true) {
+      if (params.signal?.aborted) {
+        throw new DOMException("Upload aborted", "AbortError");
+      }
       attempts++;
       try {
-        lastResponse = await fetch(partUrl, {
+        lastResponse = await fetch(chunksetUrl, {
           method: "PUT",
           headers: {
             "Content-Type": "application/octet-stream",
             ...this.apiKey ? { Authorization: `Bearer ${this.apiKey}` } : {},
-            ...authHeaders
+            ...authHeaders,
+            [INCLUSION_PROOF_HEADER]: params.inclusionProof
           },
-          body: partData
+          body: params.chunksetData,
+          signal: params.signal
         });
         lastError = void 0;
       } catch (error) {
+        if (error instanceof DOMException && error.name === "AbortError") {
+          throw error;
+        }
         lastError = error;
-        if (i < nRetries - 1) {
-          const delay = 2 ** i * 100;
-          await sleep(delay);
+        consecutive429s = 0;
+        nonBusyRetries++;
+        if (nonBusyRetries < maxNonBusyRetries) {
+          const delay2 = 2 ** nonBusyRetries * 100;
+          await sleep(delay2);
           continue;
         }
         break;
       }
-      if (lastResponse.ok) return;
+      if (lastResponse.ok) {
+        const json = await lastResponse.json();
+        const spAcks = json.spAcks?.map((ack) => ({
+          slot: ack.slot,
+          signature: Uint8Array.from(
+            atob(ack.signature),
+            (c) => c.charCodeAt(0)
+          )
+        }));
+        return {
+          success: json.success,
+          acksReceived: json.acksReceived,
+          spAcks
+        };
+      }
+      if (lastResponse.status === 429) {
+        consecutive429s++;
+        const baseDelay = 500;
+        const jitter = Math.random() * 200;
+        const delay2 = Math.min(
+          3e4,
+          2 ** consecutive429s * baseDelay + jitter
+        );
+        await sleep(delay2);
+        continue;
+      }
+      consecutive429s = 0;
       if (!isRetryableStatus(lastResponse.status)) {
         break;
       }
-      if (i < nRetries - 1) {
-        const delay = 2 ** i * 100;
-        await sleep(delay);
+      nonBusyRetries++;
+      if (nonBusyRetries >= maxNonBusyRetries) {
+        break;
       }
+      const delay = 2 ** nonBusyRetries * 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}`,
+        `Failed to upload chunkset ${params.chunksetIndex} 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}`
+      `Failed to upload chunkset ${params.chunksetIndex} 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.
+   * 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.
+   *
+   * 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,
    * });
    * ```
    */
-  async putBlobResumable(params) {
-    BlobNameSchema.parse(params.blobName);
+  async putBlobChunksets(params) {
     let totalBytes;
     if (params.blobData instanceof Uint8Array) {
       totalBytes = params.totalBytes ?? params.blobData.length;
@@ -2304,110 +2490,146 @@ var ShelbyRPCClient = class {
       totalBytes = params.totalBytes;
     }
     validateTotalBytes(totalBytes);
-    const partSize = params.partSize ?? 5 * 1024 * 1024;
+    const chunksetConcurrency = params.chunksetConcurrency ?? 4;
+    const totalChunksets = params.commitments.chunkset_commitments.length;
+    const rawDataSizeFromCommitments = params.commitments.raw_data_size;
+    if (rawDataSizeFromCommitments !== totalBytes) {
+      throw new Error(
+        `Data size mismatch: commitments were generated for ${rawDataSizeFromCommitments} bytes, but totalBytes=${totalBytes}. This will cause inclusion proof verification to fail.`
+      );
+    }
+    const chunksetRoots = params.commitments.chunkset_commitments.map(
+      (c) => Hex6.fromHexString(c.chunkset_root)
+    );
     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
-          })
-        }
+    const firstChunkset = params.commitments.chunkset_commitments[0];
+    if (!firstChunkset) {
+      throw new Error("Commitments must have at least one chunkset");
+    }
+    const erasure_n = firstChunkset.chunk_commitments.length;
+    const matchingEntry = findErasureSchemeByErasureN(erasure_n);
+    if (!matchingEntry) {
+      throw new Error(
+        `Unknown erasure coding scheme with erasure_n=${erasure_n}`
       );
-      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()
+    }
+    const [schemeKey, matchingParams] = matchingEntry;
+    const erasure_k = matchingParams.erasure_k;
+    const { chunkSizeBytes } = ERASURE_CODE_AND_CHUNK_MAPPING[schemeKey];
+    const chunksetSize = erasure_k * chunkSizeBytes;
+    const expectedChunksetCount = totalBytes === 0 ? 1 : Math.ceil(totalBytes / chunksetSize);
+    if (expectedChunksetCount !== totalChunksets) {
+      throw new Error(
+        `Chunkset count mismatch: expected ${expectedChunksetCount} chunksets for ${totalBytes} bytes with chunksetSize=${chunksetSize}, but commitments have ${totalChunksets} chunksets. This suggests the commitments were generated with a different encoding scheme.`
       );
-      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;
+    let bytesReadFromSource = 0;
+    const inFlight = /* @__PURE__ */ new Set();
+    async function* chunksetsFromBlob() {
+      if (totalBytes === 0) {
+        yield [0, new Uint8Array(chunksetSize)];
+        return;
       }
-      await this.#uploadPartWithAuth(uploadId, partIdx, partData, auth);
-      uploadedBytes += partData.length;
-      params.onProgress?.({
-        phase: "uploading",
-        partIdx,
-        totalParts,
-        partBytes: partData.length,
-        uploadedBytes,
-        totalBytes
+      yield* readInChunks(params.blobData, chunksetSize);
+    }
+    const chunksetIterator = chunksetsFromBlob();
+    const aggregatedAcks = /* @__PURE__ */ new Map();
+    const internalAbort = new AbortController();
+    if (params.signal?.aborted) {
+      internalAbort.abort();
+    } else if (params.signal) {
+      params.signal.addEventListener("abort", () => internalAbort.abort(), {
+        once: true
       });
     }
-    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
+    let iteratorDone = false;
+    let firstError = null;
+    while (!iteratorDone || inFlight.size > 0) {
+      if (internalAbort.signal.aborted) {
+        throw firstError ?? new DOMException("Upload aborted", "AbortError");
+      }
+      while (inFlight.size < chunksetConcurrency && !iteratorDone) {
+        const { value, done } = await chunksetIterator.next();
+        if (done) {
+          iteratorDone = true;
+          break;
         }
+        const [chunksetIdx, chunksetData] = value;
+        bytesReadFromSource += totalBytes === 0 ? 0 : chunksetData.byteLength;
+        const expectedCommitment = params.commitments.chunkset_commitments[chunksetIdx];
+        if (!expectedCommitment) {
+          throw new Error(
+            `Chunkset index ${chunksetIdx} out of range. Commitments only have ${totalChunksets} chunksets. This suggests a chunkset size mismatch between commitment generation and upload.`
+          );
+        }
+        const proofSiblings = await generateChunksetInclusionProof(
+          chunksetRoots,
+          chunksetIdx
+        );
+        const inclusionProof = encodeInclusionProof(proofSiblings);
+        const chunksetDataCopy = new Uint8Array(chunksetData);
+        const chunksetBytes = chunksetDataCopy.length;
+        const uploadPromise = (async () => {
+          const result = await this.#uploadChunkset({
+            account: params.account.accountAddress.toString(),
+            uid: params.uid,
+            chunksetIndex: chunksetIdx,
+            inclusionProof,
+            chunksetData: chunksetDataCopy,
+            auth,
+            signal: internalAbort.signal
+          });
+          const chunksetSpAcks = result.spAcks?.map((ack) => ({
+            slot: ack.slot,
+            signature: ack.signature
+          }));
+          if (chunksetSpAcks) {
+            for (const ack of chunksetSpAcks) {
+              aggregatedAcks.set(ack.slot, ack.signature);
+            }
+          }
+          uploadedBytes += chunksetBytes;
+          params.onProgress?.({
+            phase: "uploading",
+            chunksetIdx,
+            totalChunksets,
+            chunksetBytes,
+            uploadedBytes,
+            totalBytes,
+            acksReceived: result.acksReceived,
+            spAcks: chunksetSpAcks
+          });
+        })().catch((err) => {
+          if (!firstError) {
+            firstError = err;
+            internalAbort.abort();
+          }
+        }).finally(() => {
+          inFlight.delete(uploadPromise);
+        });
+        inFlight.add(uploadPromise);
       }
-    );
-    if (!completeResponse.ok) {
-      const errorBodyText = await completeResponse.text().catch(() => "");
+      if (inFlight.size > 0) {
+        await Promise.race(inFlight);
+      }
+    }
+    if (firstError) {
+      throw firstError;
+    }
+    if (bytesReadFromSource !== totalBytes) {
       throw new Error(
-        `Failed to complete multipart upload! status: ${completeResponse.status}, body: ${errorBodyText}`
+        `Data source produced ${bytesReadFromSource} bytes, but expected ${totalBytes} bytes. The stream may have ended prematurely, resulting in an incomplete upload.`
       );
     }
+    const spAcks = Array.from(
+      aggregatedAcks.entries()
+    ).map(([slot, signature]) => ({ slot, signature }));
+    return { spAcks };
   }
   /**
    * Downloads a blob from the Shelby RPC node.
@@ -2659,6 +2881,59 @@ var ShelbyClient = class {
     }
     return this._provider;
   }
+  /**
+   * Build orderless transaction options (a random replay-protection nonce) for
+   * the per-blob commit transactions. batchUpload finalizes blobs
+   * concurrently, so without orderless replay protection the parallel
+   * same-account submissions collide on the sequence number ("transaction
+   * already in mempool with a different payload"). The nonce makes each commit
+   * independent regardless of the client's `orderless` config flag.
+   */
+  orderlessCommitOptions() {
+    return {
+      build: {
+        options: {
+          replayProtectionNonce: crypto.getRandomValues(new Uint32Array(1))[0]
+        }
+      }
+    };
+  }
+  /**
+   * Resolve the on-chain UID assigned to `blobName` from a committed register
+   * transaction. `register_blob` only publishes the uid -> name mapping via
+   * `BlobRegisteredEvent` (a pending blob is not yet in the `objects` map, so it
+   * cannot be read back by name), so the upload flow must parse it here before
+   * uploading bytes or committing.
+   */
+  uidFromRegisterTx(tx, account, blobName) {
+    const events = "events" in tx ? tx.events : [];
+    const objectName = createBlobKey({ account, blobName });
+    const match = ShelbyBlobClient.registeredBlobUids(
+      events,
+      this.coordination.deployer
+    ).find((registered) => registered.objectName === objectName);
+    if (match === void 0) {
+      throw new Error(
+        `No BlobRegisteredEvent for '${blobName}' in register transaction ${tx.hash}`
+      );
+    }
+    return match.uid;
+  }
+  /**
+   * Await a blob-registration transaction, rephrasing on-chain location
+   * failures into a human-readable message.
+   */
+  async waitForRegistration(transactionHash) {
+    try {
+      return await this.coordination.aptos.waitForTransaction({
+        transactionHash
+      });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      const described = describeLocationError(message);
+      throw described ? new Error(described, { cause: error }) : error;
+    }
+  }
   /**
    * The base URL for the Shelby RPC node.
    */
@@ -2672,8 +2947,8 @@ var ShelbyClient = class {
    *
    * 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`.
+   * using `generateCommitments()`, `coordination.registerBlob()`, `rpc.putBlobChunksets()`,
+   * and `coordination.commitObject()` 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.
@@ -2696,34 +2971,57 @@ var ShelbyClient = class {
    * ```
    */
   async upload(params) {
-    const existingBlobMetadata = await this.coordination.getBlobMetadata({
-      account: params.signer.accountAddress,
-      name: params.blobName
+    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
     });
-    if (!existingBlobMetadata) {
-      const provider = await this.getProvider();
-      const blobCommitments = await generateCommitments(
-        provider,
-        params.blobData
+    const registerTx = await this.waitForRegistration(
+      pendingRegisterBlobTransaction.hash
+    );
+    const uid = this.uidFromRegisterTx(
+      registerTx,
+      params.signer.accountAddress,
+      params.blobName
+    );
+    const { spAcks } = await this.rpc.putBlobChunksets({
+      account: params.signer,
+      uid,
+      blobData: params.blobData,
+      commitments: blobCommitments,
+      totalBytes: params.blobData.length
+    });
+    const requiredAcks = requiredAckCount(provider.config.erasure_n);
+    if (spAcks.length < requiredAcks) {
+      throw new Error(
+        `Insufficient storage provider acknowledgements for '${params.blobName}': got ${spAcks.length}, need ${requiredAcks} (erasure_d) to finalize on chain`
       );
-      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({
+    const { transaction: pendingCommitTransaction } = await this.coordination.commitObject({
       account: params.signer,
+      uid,
       blobName: params.blobName,
-      blobData: params.blobData
+      overwrite: true,
+      storageProviderAcks: spAcks,
+      options: this.orderlessCommitOptions()
+    });
+    const confirmedTx = await this.coordination.aptos.waitForTransaction({
+      transactionHash: pendingCommitTransaction.hash
     });
+    if (!confirmedTx.success) {
+      throw new Error(
+        `commit_object tx failed for '${params.blobName}': ${confirmedTx.vm_status}`
+      );
+    }
   }
   /**
    * Uploads a batch of blobs to the Shelby network.
@@ -2732,8 +3030,8 @@ var ShelbyClient = class {
    *
    * 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`.
+   * `generateCommitments()`, `coordination.registerBlob()`, `rpc.putBlobChunksets()`,
+   * and `coordination.commitObject()` with a `ReadableStream`.
    *
    * @param params.blobs - The blobs to upload.
    * @param params.blobs.blobData - The raw data to upload as a Uint8Array.
@@ -2758,59 +3056,77 @@ var ShelbyClient = class {
    * ```
    */
   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 provider = await this.getProvider();
+    const prepared = await Promise.all(
+      params.blobs.map(async (blob) => ({
+        blob,
+        commitments: await generateCommitments(provider, blob.blobData)
+      }))
+    );
+    const { transaction: pendingRegisterBlobTransaction } = await this.coordination.batchRegisterBlobs({
+      account: params.signer,
+      expirationMicros: params.expirationMicros,
+      blobs: prepared.map((p) => ({
+        blobName: p.blob.blobName,
+        blobSize: p.blob.blobData.length,
+        blobMerkleRoot: p.commitments.blob_merkle_root
+      })),
+      config: provider.config,
+      options: params.options
     });
-    const blobsToRegister = params.blobs.filter(
-      (blob) => !existingBlobs.some(
-        (existingBlob) => existingBlob.name === createBlobKey({
-          account: params.signer.accountAddress,
-          blobName: blob.blobName
-        })
-      )
+    const registerTx = await this.waitForRegistration(
+      pendingRegisterBlobTransaction.hash
     );
-    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 uidByObjectName = new Map(
+      ShelbyBlobClient.registeredBlobUids(
+        "events" in registerTx ? registerTx.events : [],
+        this.coordination.deployer
+      ).map((registered) => [registered.objectName, registered.uid])
+    );
+    const requiredAcks = requiredAckCount(provider.config.erasure_n);
     const limit = pLimit(3);
     await Promise.all(
-      params.blobs.map(
-        (blob) => limit(
-          () => this.rpc.putBlobResumable({
+      prepared.map(
+        (p) => limit(async () => {
+          const objectName = createBlobKey({
+            account: params.signer.accountAddress,
+            blobName: p.blob.blobName
+          });
+          const uid = uidByObjectName.get(objectName);
+          if (uid === void 0) {
+            throw new Error(
+              `No BlobRegisteredEvent for '${p.blob.blobName}' in batch register transaction ${registerTx.hash}`
+            );
+          }
+          const { spAcks } = await this.rpc.putBlobChunksets({
             account: params.signer,
-            blobName: blob.blobName,
-            blobData: blob.blobData
-          })
-        )
+            uid,
+            blobData: p.blob.blobData,
+            commitments: p.commitments,
+            totalBytes: p.blob.blobData.length
+          });
+          if (spAcks.length < requiredAcks) {
+            throw new Error(
+              `Insufficient storage provider acknowledgements for '${p.blob.blobName}': got ${spAcks.length}, need ${requiredAcks} (erasure_d) to finalize on chain`
+            );
+          }
+          const { transaction: pendingCommitTransaction } = await this.coordination.commitObject({
+            account: params.signer,
+            uid,
+            blobName: p.blob.blobName,
+            overwrite: true,
+            storageProviderAcks: spAcks,
+            options: this.orderlessCommitOptions()
+          });
+          const confirmedTx = await this.coordination.aptos.waitForTransaction({
+            transactionHash: pendingCommitTransaction.hash
+          });
+          if (!confirmedTx.success) {
+            throw new Error(
+              `commit_object tx failed for '${p.blob.blobName}': ${confirmedTx.vm_status}`
+            );
+          }
+        })
       )
     );
   }