thirdweb 5.29.4 → 5.29.5-nightly-a9ce10f39ad47f386e8086e230679093aab08754-20240617192538

package/dist/types/extensions/erc721/drops/write/updateMetadata.d.ts

@@ -0,0 +1,37 @@
+import type { ThirdwebClient } from "../../../../client/client.js";
+import type { BaseTransactionOptions } from "../../../../transaction/types.js";
+import type { NFTInput } from "../../../../utils/nft/parseNft.js";
+import { type UpdateBatchBaseURIParams } from "../../__generated__/DropERC721/write/updateBatchBaseURI.js";
+export type UpdateMetadataParams = {
+    targetTokenId: bigint;
+    newMetadata: NFTInput;
+    client: ThirdwebClient;
+};
+/**
+ * @internal
+ */
+export declare function getUpdateMetadataParams(options: BaseTransactionOptions<UpdateMetadataParams>): Promise<UpdateBatchBaseURIParams>;
+/**
+ * Update the metadata of the single token in an NFT Drop (DropERC721) collection
+ * For NFT Collection, please use `setTokenURI`
+ * @param options
+ * @returns the prepared transaction
+ * @extension ERC721
+ * @example
+ * ```ts
+ * import { updateMetadata } from "thirdweb/extensions/erc721";
+ *
+ * const transaction = updateMetadata({
+ *  contract,
+ *  targetTokenId: 0n,
+ *  newMetadata: {
+ *    name: "this is the new nft name",
+ *    description: "...",
+ *    image: "new image uri"
+ *    // ...
+ *  }
+ * });
+ * ```
+ */
+export declare function updateMetadata(options: BaseTransactionOptions<UpdateMetadataParams>): import("../../../../transaction/prepare-transaction.js").PreparedTransaction<any, import("abitype").AbiFunction, import("../../../../transaction/prepare-transaction.js").PrepareTransactionOptions>;
+//# sourceMappingURL=updateMetadata.d.ts.map

package/dist/types/extensions/erc721/drops/write/updateMetadata.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"updateMetadata.d.ts","sourceRoot":"","sources":["../../../../../../src/extensions/erc721/drops/write/updateMetadata.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AACnE,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,kCAAkC,CAAC;AAC/E,OAAO,KAAK,EAAO,QAAQ,EAAE,MAAM,mCAAmC,CAAC;AACvE,OAAO,EACL,KAAK,wBAAwB,EAE9B,MAAM,4DAA4D,CAAC;AAGpE,MAAM,MAAM,oBAAoB,GAAG;IACjC,aAAa,EAAE,MAAM,CAAC;IACtB,WAAW,EAAE,QAAQ,CAAC;IACtB,MAAM,EAAE,cAAc,CAAC;CACxB,CAAC;AAEF;;GAEG;AACH,wBAAsB,uBAAuB,CAC3C,OAAO,EAAE,sBAAsB,CAAC,oBAAoB,CAAC,GACpD,OAAO,CAAC,wBAAwB,CAAC,CAsEnC;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,cAAc,CAC5B,OAAO,EAAE,sBAAsB,CAAC,oBAAoB,CAAC,wMAOtD"}

package/dist/types/version.d.ts

@@ -1,2 +1,2 @@
-export declare const version = "5.29.4";
+export declare const version = "5.29.5-nightly-a9ce10f39ad47f386e8086e230679093aab08754-20240617192538";
 //# sourceMappingURL=version.d.ts.map

package/dist/types/version.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"version.d.ts","sourceRoot":"","sources":["../../src/version.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,OAAO,WAAW,CAAC"}
+{"version":3,"file":"version.d.ts","sourceRoot":"","sources":["../../src/version.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,OAAO,2EAA2E,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "thirdweb",
-  "version": "5.29.4",
+  "version": "5.29.5-nightly-a9ce10f39ad47f386e8086e230679093aab08754-20240617192538",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/thirdweb-dev/js.git#main"

package/src/exports/extensions/erc721.ts

@@ -163,3 +163,7 @@ export {
   type BatchToReveal,
   getBatchesToReveal,
 } from "../../extensions/erc721/lazyMinting/read/getBatchesToReveal.js";
+export {
+  updateMetadata,
+  type UpdateMetadataParams,
+} from "../../extensions/erc721/drops/write/updateMetadata.js";

package/src/extensions/erc721/__generated__/DropERC721/write/freezeBatchBaseURI.ts

@@ -0,0 +1,141 @@
+import type { AbiParameterToPrimitiveType } from "abitype";
+import type {
+  BaseTransactionOptions,
+  WithOverrides,
+} from "../../../../../transaction/types.js";
+import { prepareContractCall } from "../../../../../transaction/prepare-contract-call.js";
+import { encodeAbiParameters } from "../../../../../utils/abi/encodeAbiParameters.js";
+import { once } from "../../../../../utils/promise/once.js";
+import type { ThirdwebContract } from "../../../../../contract/contract.js";
+import { detectMethod } from "../../../../../utils/bytecode/detectExtension.js";
+
+/**
+ * Represents the parameters for the "freezeBatchBaseURI" function.
+ */
+export type FreezeBatchBaseURIParams = WithOverrides<{
+  index: AbiParameterToPrimitiveType<{ type: "uint256"; name: "_index" }>;
+}>;
+
+export const FN_SELECTOR = "0xa07ced9e" as const;
+const FN_INPUTS = [
+  {
+    type: "uint256",
+    name: "_index",
+  },
+] as const;
+const FN_OUTPUTS = [] as const;
+
+/**
+ * Checks if the `freezeBatchBaseURI` method is supported by the given contract.
+ * @param contract The ThirdwebContract.
+ * @returns A promise that resolves to a boolean indicating if the `freezeBatchBaseURI` method is supported.
+ * @extension ERC721
+ * @example
+ * ```ts
+ * import { isFreezeBatchBaseURISupported } from "thirdweb/extensions/erc721";
+ *
+ * const supported = await isFreezeBatchBaseURISupported(contract);
+ * ```
+ */
+export async function isFreezeBatchBaseURISupported(
+  contract: ThirdwebContract<any>,
+) {
+  return detectMethod({
+    contract,
+    method: [FN_SELECTOR, FN_INPUTS, FN_OUTPUTS] as const,
+  });
+}
+
+/**
+ * Encodes the parameters for the "freezeBatchBaseURI" function.
+ * @param options - The options for the freezeBatchBaseURI function.
+ * @returns The encoded ABI parameters.
+ * @extension ERC721
+ * @example
+ * ```ts
+ * import { encodeFreezeBatchBaseURIParams } "thirdweb/extensions/erc721";
+ * const result = encodeFreezeBatchBaseURIParams({
+ *  index: ...,
+ * });
+ * ```
+ */
+export function encodeFreezeBatchBaseURIParams(
+  options: FreezeBatchBaseURIParams,
+) {
+  return encodeAbiParameters(FN_INPUTS, [options.index]);
+}
+
+/**
+ * Encodes the "freezeBatchBaseURI" function into a Hex string with its parameters.
+ * @param options - The options for the freezeBatchBaseURI function.
+ * @returns The encoded hexadecimal string.
+ * @extension ERC721
+ * @example
+ * ```ts
+ * import { encodeFreezeBatchBaseURI } "thirdweb/extensions/erc721";
+ * const result = encodeFreezeBatchBaseURI({
+ *  index: ...,
+ * });
+ * ```
+ */
+export function encodeFreezeBatchBaseURI(options: FreezeBatchBaseURIParams) {
+  // we do a "manual" concat here to avoid the overhead of the "concatHex" function
+  // we can do this because we know the specific formats of the values
+  return (FN_SELECTOR +
+    encodeFreezeBatchBaseURIParams(options).slice(
+      2,
+    )) as `${typeof FN_SELECTOR}${string}`;
+}
+
+/**
+ * Prepares a transaction to call the "freezeBatchBaseURI" function on the contract.
+ * @param options - The options for the "freezeBatchBaseURI" function.
+ * @returns A prepared transaction object.
+ * @extension ERC721
+ * @example
+ * ```ts
+ * import { freezeBatchBaseURI } from "thirdweb/extensions/erc721";
+ *
+ * const transaction = freezeBatchBaseURI({
+ *  contract,
+ *  index: ...,
+ *  overrides: {
+ *    ...
+ *  }
+ * });
+ *
+ * // Send the transaction
+ * ...
+ *
+ * ```
+ */
+export function freezeBatchBaseURI(
+  options: BaseTransactionOptions<
+    | FreezeBatchBaseURIParams
+    | {
+        asyncParams: () => Promise<FreezeBatchBaseURIParams>;
+      }
+  >,
+) {
+  const asyncOptions = once(async () => {
+    return "asyncParams" in options ? await options.asyncParams() : options;
+  });
+
+  return prepareContractCall({
+    contract: options.contract,
+    method: [FN_SELECTOR, FN_INPUTS, FN_OUTPUTS] as const,
+    params: async () => {
+      const resolvedOptions = await asyncOptions();
+      return [resolvedOptions.index] as const;
+    },
+    value: async () => (await asyncOptions()).overrides?.value,
+    accessList: async () => (await asyncOptions()).overrides?.accessList,
+    gas: async () => (await asyncOptions()).overrides?.gas,
+    gasPrice: async () => (await asyncOptions()).overrides?.gasPrice,
+    maxFeePerGas: async () => (await asyncOptions()).overrides?.maxFeePerGas,
+    maxPriorityFeePerGas: async () =>
+      (await asyncOptions()).overrides?.maxPriorityFeePerGas,
+    nonce: async () => (await asyncOptions()).overrides?.nonce,
+    extraGas: async () => (await asyncOptions()).overrides?.extraGas,
+  });
+}

package/src/extensions/erc721/__generated__/DropERC721/write/setMaxTotalSupply.ts

@@ -0,0 +1,144 @@
+import type { AbiParameterToPrimitiveType } from "abitype";
+import type {
+  BaseTransactionOptions,
+  WithOverrides,
+} from "../../../../../transaction/types.js";
+import { prepareContractCall } from "../../../../../transaction/prepare-contract-call.js";
+import { encodeAbiParameters } from "../../../../../utils/abi/encodeAbiParameters.js";
+import { once } from "../../../../../utils/promise/once.js";
+import type { ThirdwebContract } from "../../../../../contract/contract.js";
+import { detectMethod } from "../../../../../utils/bytecode/detectExtension.js";
+
+/**
+ * Represents the parameters for the "setMaxTotalSupply" function.
+ */
+export type SetMaxTotalSupplyParams = WithOverrides<{
+  maxTotalSupply: AbiParameterToPrimitiveType<{
+    type: "uint256";
+    name: "_maxTotalSupply";
+  }>;
+}>;
+
+export const FN_SELECTOR = "0x3f3e4c11" as const;
+const FN_INPUTS = [
+  {
+    type: "uint256",
+    name: "_maxTotalSupply",
+  },
+] as const;
+const FN_OUTPUTS = [] as const;
+
+/**
+ * Checks if the `setMaxTotalSupply` method is supported by the given contract.
+ * @param contract The ThirdwebContract.
+ * @returns A promise that resolves to a boolean indicating if the `setMaxTotalSupply` method is supported.
+ * @extension ERC721
+ * @example
+ * ```ts
+ * import { isSetMaxTotalSupplySupported } from "thirdweb/extensions/erc721";
+ *
+ * const supported = await isSetMaxTotalSupplySupported(contract);
+ * ```
+ */
+export async function isSetMaxTotalSupplySupported(
+  contract: ThirdwebContract<any>,
+) {
+  return detectMethod({
+    contract,
+    method: [FN_SELECTOR, FN_INPUTS, FN_OUTPUTS] as const,
+  });
+}
+
+/**
+ * Encodes the parameters for the "setMaxTotalSupply" function.
+ * @param options - The options for the setMaxTotalSupply function.
+ * @returns The encoded ABI parameters.
+ * @extension ERC721
+ * @example
+ * ```ts
+ * import { encodeSetMaxTotalSupplyParams } "thirdweb/extensions/erc721";
+ * const result = encodeSetMaxTotalSupplyParams({
+ *  maxTotalSupply: ...,
+ * });
+ * ```
+ */
+export function encodeSetMaxTotalSupplyParams(
+  options: SetMaxTotalSupplyParams,
+) {
+  return encodeAbiParameters(FN_INPUTS, [options.maxTotalSupply]);
+}
+
+/**
+ * Encodes the "setMaxTotalSupply" function into a Hex string with its parameters.
+ * @param options - The options for the setMaxTotalSupply function.
+ * @returns The encoded hexadecimal string.
+ * @extension ERC721
+ * @example
+ * ```ts
+ * import { encodeSetMaxTotalSupply } "thirdweb/extensions/erc721";
+ * const result = encodeSetMaxTotalSupply({
+ *  maxTotalSupply: ...,
+ * });
+ * ```
+ */
+export function encodeSetMaxTotalSupply(options: SetMaxTotalSupplyParams) {
+  // we do a "manual" concat here to avoid the overhead of the "concatHex" function
+  // we can do this because we know the specific formats of the values
+  return (FN_SELECTOR +
+    encodeSetMaxTotalSupplyParams(options).slice(
+      2,
+    )) as `${typeof FN_SELECTOR}${string}`;
+}
+
+/**
+ * Prepares a transaction to call the "setMaxTotalSupply" function on the contract.
+ * @param options - The options for the "setMaxTotalSupply" function.
+ * @returns A prepared transaction object.
+ * @extension ERC721
+ * @example
+ * ```ts
+ * import { setMaxTotalSupply } from "thirdweb/extensions/erc721";
+ *
+ * const transaction = setMaxTotalSupply({
+ *  contract,
+ *  maxTotalSupply: ...,
+ *  overrides: {
+ *    ...
+ *  }
+ * });
+ *
+ * // Send the transaction
+ * ...
+ *
+ * ```
+ */
+export function setMaxTotalSupply(
+  options: BaseTransactionOptions<
+    | SetMaxTotalSupplyParams
+    | {
+        asyncParams: () => Promise<SetMaxTotalSupplyParams>;
+      }
+  >,
+) {
+  const asyncOptions = once(async () => {
+    return "asyncParams" in options ? await options.asyncParams() : options;
+  });
+
+  return prepareContractCall({
+    contract: options.contract,
+    method: [FN_SELECTOR, FN_INPUTS, FN_OUTPUTS] as const,
+    params: async () => {
+      const resolvedOptions = await asyncOptions();
+      return [resolvedOptions.maxTotalSupply] as const;
+    },
+    value: async () => (await asyncOptions()).overrides?.value,
+    accessList: async () => (await asyncOptions()).overrides?.accessList,
+    gas: async () => (await asyncOptions()).overrides?.gas,
+    gasPrice: async () => (await asyncOptions()).overrides?.gasPrice,
+    maxFeePerGas: async () => (await asyncOptions()).overrides?.maxFeePerGas,
+    maxPriorityFeePerGas: async () =>
+      (await asyncOptions()).overrides?.maxPriorityFeePerGas,
+    nonce: async () => (await asyncOptions()).overrides?.nonce,
+    extraGas: async () => (await asyncOptions()).overrides?.extraGas,
+  });
+}

package/src/extensions/erc721/__generated__/DropERC721/write/updateBatchBaseURI.ts

@@ -0,0 +1,149 @@
+import type { AbiParameterToPrimitiveType } from "abitype";
+import type {
+  BaseTransactionOptions,
+  WithOverrides,
+} from "../../../../../transaction/types.js";
+import { prepareContractCall } from "../../../../../transaction/prepare-contract-call.js";
+import { encodeAbiParameters } from "../../../../../utils/abi/encodeAbiParameters.js";
+import { once } from "../../../../../utils/promise/once.js";
+import type { ThirdwebContract } from "../../../../../contract/contract.js";
+import { detectMethod } from "../../../../../utils/bytecode/detectExtension.js";
+
+/**
+ * Represents the parameters for the "updateBatchBaseURI" function.
+ */
+export type UpdateBatchBaseURIParams = WithOverrides<{
+  index: AbiParameterToPrimitiveType<{ type: "uint256"; name: "_index" }>;
+  uri: AbiParameterToPrimitiveType<{ type: "string"; name: "_uri" }>;
+}>;
+
+export const FN_SELECTOR = "0xde903ddd" as const;
+const FN_INPUTS = [
+  {
+    type: "uint256",
+    name: "_index",
+  },
+  {
+    type: "string",
+    name: "_uri",
+  },
+] as const;
+const FN_OUTPUTS = [] as const;
+
+/**
+ * Checks if the `updateBatchBaseURI` method is supported by the given contract.
+ * @param contract The ThirdwebContract.
+ * @returns A promise that resolves to a boolean indicating if the `updateBatchBaseURI` method is supported.
+ * @extension ERC721
+ * @example
+ * ```ts
+ * import { isUpdateBatchBaseURISupported } from "thirdweb/extensions/erc721";
+ *
+ * const supported = await isUpdateBatchBaseURISupported(contract);
+ * ```
+ */
+export async function isUpdateBatchBaseURISupported(
+  contract: ThirdwebContract<any>,
+) {
+  return detectMethod({
+    contract,
+    method: [FN_SELECTOR, FN_INPUTS, FN_OUTPUTS] as const,
+  });
+}
+
+/**
+ * Encodes the parameters for the "updateBatchBaseURI" function.
+ * @param options - The options for the updateBatchBaseURI function.
+ * @returns The encoded ABI parameters.
+ * @extension ERC721
+ * @example
+ * ```ts
+ * import { encodeUpdateBatchBaseURIParams } "thirdweb/extensions/erc721";
+ * const result = encodeUpdateBatchBaseURIParams({
+ *  index: ...,
+ *  uri: ...,
+ * });
+ * ```
+ */
+export function encodeUpdateBatchBaseURIParams(
+  options: UpdateBatchBaseURIParams,
+) {
+  return encodeAbiParameters(FN_INPUTS, [options.index, options.uri]);
+}
+
+/**
+ * Encodes the "updateBatchBaseURI" function into a Hex string with its parameters.
+ * @param options - The options for the updateBatchBaseURI function.
+ * @returns The encoded hexadecimal string.
+ * @extension ERC721
+ * @example
+ * ```ts
+ * import { encodeUpdateBatchBaseURI } "thirdweb/extensions/erc721";
+ * const result = encodeUpdateBatchBaseURI({
+ *  index: ...,
+ *  uri: ...,
+ * });
+ * ```
+ */
+export function encodeUpdateBatchBaseURI(options: UpdateBatchBaseURIParams) {
+  // we do a "manual" concat here to avoid the overhead of the "concatHex" function
+  // we can do this because we know the specific formats of the values
+  return (FN_SELECTOR +
+    encodeUpdateBatchBaseURIParams(options).slice(
+      2,
+    )) as `${typeof FN_SELECTOR}${string}`;
+}
+
+/**
+ * Prepares a transaction to call the "updateBatchBaseURI" function on the contract.
+ * @param options - The options for the "updateBatchBaseURI" function.
+ * @returns A prepared transaction object.
+ * @extension ERC721
+ * @example
+ * ```ts
+ * import { updateBatchBaseURI } from "thirdweb/extensions/erc721";
+ *
+ * const transaction = updateBatchBaseURI({
+ *  contract,
+ *  index: ...,
+ *  uri: ...,
+ *  overrides: {
+ *    ...
+ *  }
+ * });
+ *
+ * // Send the transaction
+ * ...
+ *
+ * ```
+ */
+export function updateBatchBaseURI(
+  options: BaseTransactionOptions<
+    | UpdateBatchBaseURIParams
+    | {
+        asyncParams: () => Promise<UpdateBatchBaseURIParams>;
+      }
+  >,
+) {
+  const asyncOptions = once(async () => {
+    return "asyncParams" in options ? await options.asyncParams() : options;
+  });
+
+  return prepareContractCall({
+    contract: options.contract,
+    method: [FN_SELECTOR, FN_INPUTS, FN_OUTPUTS] as const,
+    params: async () => {
+      const resolvedOptions = await asyncOptions();
+      return [resolvedOptions.index, resolvedOptions.uri] as const;
+    },
+    value: async () => (await asyncOptions()).overrides?.value,
+    accessList: async () => (await asyncOptions()).overrides?.accessList,
+    gas: async () => (await asyncOptions()).overrides?.gas,
+    gasPrice: async () => (await asyncOptions()).overrides?.gasPrice,
+    maxFeePerGas: async () => (await asyncOptions()).overrides?.maxFeePerGas,
+    maxPriorityFeePerGas: async () =>
+      (await asyncOptions()).overrides?.maxPriorityFeePerGas,
+    nonce: async () => (await asyncOptions()).overrides?.nonce,
+    extraGas: async () => (await asyncOptions()).overrides?.extraGas,
+  });
+}

package/src/extensions/erc721/drops/write/updateMetadata.test.ts

@@ -0,0 +1,127 @@
+import { beforeEach, describe, expect, it } from "vitest";
+import { ANVIL_CHAIN } from "~test/chains.js";
+import { TEST_CLIENT } from "~test/test-clients.js";
+import { TEST_ACCOUNT_A } from "~test/test-wallets.js";
+
+import {
+  type ThirdwebContract,
+  getContract,
+} from "../../../../contract/contract.js";
+import { deployERC721Contract } from "../../../../extensions/prebuilts/deploy-erc721.js";
+import { sendAndConfirmTransaction } from "../../../../transaction/actions/send-and-confirm-transaction.js";
+import type { NFTInput } from "../../../../utils/nft/parseNft.js";
+import { getNFT } from "../../read/getNFT.js";
+import { getNFTs } from "../../read/getNFTs.js";
+import { lazyMint } from "../../write/lazyMint.js";
+import { getUpdateMetadataParams, updateMetadata } from "./updateMetadata.js";
+
+let contract: ThirdwebContract;
+const account = TEST_ACCOUNT_A;
+const client = TEST_CLIENT;
+const chain = ANVIL_CHAIN;
+
+describe("erc721: updateMetadata", () => {
+  beforeEach(async () => {
+    const address = await deployERC721Contract({
+      client,
+      chain,
+      account,
+      type: "DropERC721",
+      params: {
+        name: "NFTDrop",
+      },
+    });
+    contract = getContract({
+      address,
+      client,
+      chain,
+    });
+  });
+
+  it("should update the metadata for the selected token | case 1", async () => {
+    const metadatas: NFTInput[] = [
+      { name: "token 0" },
+      { name: "token 1" },
+      { name: "token 2" },
+    ];
+
+    const lazyMintTx = lazyMint({ contract, nfts: metadatas });
+    await sendAndConfirmTransaction({ transaction: lazyMintTx, account });
+
+    const transaction = updateMetadata({
+      contract,
+      targetTokenId: 0n,
+      newMetadata: { name: "token 0 - updated" },
+      client,
+    });
+    await sendAndConfirmTransaction({ transaction, account });
+    const nfts = await getNFTs({ contract });
+    expect(nfts[0]?.metadata.name).toBe("token 0 - updated");
+
+    // The other tokens should not change
+    expect(nfts[1]?.metadata.name).toBe("token 1");
+    expect(nfts[2]?.metadata.name).toBe("token 2");
+  });
+
+  it("should update the metadata for the selected token | case 2", async () => {
+    const nftBatch1: NFTInput[] = [
+      { name: "token 0" },
+      { name: "token 1" },
+      { name: "token 2" },
+    ];
+
+    const batch1 = lazyMint({ contract, nfts: nftBatch1 });
+    await sendAndConfirmTransaction({ transaction: batch1, account });
+
+    const nftBatch2: NFTInput[] = [
+      { name: "token 3" },
+      { name: "token 4" },
+      { name: "token 5" },
+    ];
+    const batch2 = lazyMint({ contract, nfts: nftBatch2 });
+    await sendAndConfirmTransaction({ transaction: batch2, account });
+
+    // firstly, update the token in the first batch
+    const transaction1 = updateMetadata({
+      contract,
+      targetTokenId: 0n,
+      newMetadata: { name: "token 0 - updated" },
+      client,
+    });
+    await sendAndConfirmTransaction({ transaction: transaction1, account });
+    const nft = await getNFT({ contract, tokenId: 0n });
+    expect(nft.metadata.name).toBe("token 0 - updated");
+
+    const tokenUriAfterUpdatedFirstTime = nft.tokenURI;
+
+    // Update token in the second batch
+    const transaction2 = updateMetadata({
+      contract,
+      targetTokenId: 5n,
+      newMetadata: { name: "token 5 - updated" },
+      client,
+    });
+    await sendAndConfirmTransaction({ transaction: transaction2, account });
+
+    const allNfts = await getNFTs({ contract });
+    expect(allNfts[0]?.metadata.name).toBe("token 0 - updated");
+    expect(allNfts.at(-1)?.metadata.name).toBe("token 5 - updated");
+
+    // The tokenUri of tokenId#0 after the second updateMetadata should still be the same
+    // since it belong to another batch
+    expect(allNfts[0]?.tokenURI).toBe(tokenUriAfterUpdatedFirstTime);
+  });
+
+  it("should throw error if there's no batch", async () => {
+    await expect(() =>
+      getUpdateMetadataParams({
+        contract,
+        targetTokenId: 0n,
+        newMetadata: { name: "token 0 - updated" },
+        client,
+      }),
+    ).rejects.toThrowError(
+      "No base URI set. Please set a base URI before updating metadata",
+    );
+  });
+});