@shelby-protocol/sdk 0.3.1 → 0.4.0

package/dist/core/clients/ShelbyBlobClient.mjs

@@ -122,7 +122,7 @@ var BlobCommitmentsSchema = z.object({
 // 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",
@@ -150,6 +150,27 @@ var NetworkToGasStationBaseUrl = {
 };
 var SHELBY_DEPLOYER = "0x85fdb9a176ab8ef1d9d9c1b60d60b3924f0800ac1de1cc2085fb0b8bb4988e6a";
 
+// 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/erasure/clay-codes.ts
 import {
   createDecoder,
@@ -226,18 +247,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
   }
 }
     `;
@@ -249,7 +272,8 @@ var GetBlobActivitiesDocument = gql`
     limit: $limit
     offset: $offset
   ) {
-    blob_name
+    uid
+    object_name
     event_index
     event_type
     transaction_hash
@@ -395,6 +419,33 @@ var MissingTransactionSubmitterError = class extends Error {
     this.name = "MissingTransactionSubmitterError";
   }
 };
+var COMMIT_REJECTION_REASONS = /* @__PURE__ */ new Set([
+  "AlreadyExists",
+  "NoPriorVersion",
+  "EtagMismatch"
+]);
+var ObjectCommitRejectedError = class extends Error {
+  constructor(blobName, uid, reason) {
+    super(
+      `commit_object rejected the write for '${blobName}' (uid ${uid}): ${reason}`
+    );
+    this.blobName = blobName;
+    this.uid = uid;
+    this.reason = reason;
+    this.name = "ObjectCommitRejectedError";
+  }
+};
+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;
@@ -443,7 +494,10 @@ var ShelbyBlobClient = class _ShelbyBlobClient {
     this.aptos = new Aptos(getAptosConfig(config));
     this.deployer = config.deployer ?? AccountAddress2.fromString(SHELBY_DEPLOYER);
     this.indexer = getShelbyIndexerClient(config);
-    this.defaultOptions = defaultOptions ?? {};
+    this.defaultOptions = {
+      locationHint: config.locationHint,
+      ...defaultOptions
+    };
     this.orderless = config.orderless ?? false;
   }
   /**
@@ -454,7 +508,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
     };
   }
   /**
@@ -496,17 +552,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,
@@ -518,47 +574,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: Hex3.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: Hex3.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.
@@ -570,7 +673,7 @@ var ShelbyBlobClient = class _ShelbyBlobClient {
    *
    * @example
    * ```typescript
-   * // BlobMetadata[]
+   * // FullObjectMetadata[]
    * const blobs = await client.getAccountBlobs({
    *   account: AccountAddress.fromString("0x1"),
    * });
@@ -587,6 +690,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.
    *
@@ -597,7 +719,7 @@ var ShelbyBlobClient = class _ShelbyBlobClient {
    *
    * @example
    * ```typescript
-   * // BlobMetadata[]
+   * // FullObjectMetadata[]
    * const blobs = await client.getBlobs({
    *   where: { owner: { _eq: AccountAddress.fromString("0x1").toString() } },
    * });
@@ -606,12 +728,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,
@@ -620,9 +737,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: Hex3.fromHexInput(blob.blob_commitment).toUint8Array(),
         size: Number(blob.size),
         // TODO: Add encoding when supported in NCI
@@ -634,7 +752,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))
       })
     );
@@ -652,12 +770,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),
@@ -680,9 +801,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;
   }
   /**
@@ -697,8 +819,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);
   }
   /**
@@ -757,12 +880,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
     };
@@ -790,16 +916,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
       }),
@@ -815,10 +941,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.
    *
@@ -833,16 +955,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
       }),
@@ -900,6 +1022,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,
@@ -908,7 +1032,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({
@@ -923,6 +1048,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.
@@ -936,8 +1110,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";
@@ -945,6 +1117,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,
         Hex3.fromHexString(params.blobMerkleRoot).toUint8Array(),
         params.numChunksets,
@@ -952,7 +1126,8 @@ var ShelbyBlobClient = class _ShelbyBlobClient {
         // TODO
         0,
         // payment tier
-        params.encoding
+        params.encoding,
+        ...encryptionFunctionArgs(params)
       ]
     };
   }
@@ -970,8 +1145,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";
@@ -991,6 +1164,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,
@@ -998,7 +1173,8 @@ var ShelbyBlobClient = class _ShelbyBlobClient {
         // TODO
         0,
         // payment tier
-        params.encoding
+        params.encoding,
+        ...encryptionFunctionArgs(params)
       ]
     };
   }
@@ -1009,24 +1185,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.
    *
@@ -1035,42 +1207,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
@@ -1085,5 +1286,6 @@ var ShelbyBlobClient = class _ShelbyBlobClient {
 };
 export {
   MissingTransactionSubmitterError,
+  ObjectCommitRejectedError,
   ShelbyBlobClient
 };