thirdweb 5.49.0 → 5.50.0-nightly-ff3abfa79e4f5f8806676d97c11ff24ffd62266f-20240901000406

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "thirdweb",
-  "version": "5.49.0",
+  "version": "5.50.0-nightly-ff3abfa79e4f5f8806676d97c11ff24ffd62266f-20240901000406",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/thirdweb-dev/js.git#main"

package/src/adapters/ethers5.test.ts

@@ -1,11 +1,19 @@
 import * as ethers5 from "ethers5";
-import { describe, expect, test } from "vitest";
-import { ANVIL_CHAIN } from "../../test/src/chains.js";
+import { describe, expect, it, test } from "vitest";
+import { USDT_CONTRACT } from "~test/test-contracts.js";
+import { ANVIL_CHAIN, FORKED_ETHEREUM_CHAIN } from "../../test/src/chains.js";
 import { TEST_CLIENT } from "../../test/src/test-clients.js";
 import { ANVIL_PKEY_A, TEST_ACCOUNT_B } from "../../test/src/test-wallets.js";
+import { resolveContractAbi } from "../contract/actions/resolve-abi.js";
+import { decimals } from "../extensions/erc20/__generated__/IERC20/read/decimals.js";
 import { randomBytesBuffer } from "../utils/random.js";
 import { privateKeyToAccount } from "../wallets/private-key.js";
-import { toEthersSigner } from "./ethers5.js";
+import {
+  fromEthersContract,
+  toEthersContract,
+  toEthersProvider,
+  toEthersSigner,
+} from "./ethers5.js";
 
 const account = privateKeyToAccount({
   privateKey: ANVIL_PKEY_A,
@@ -110,4 +118,35 @@ describe("ethers5 adapter", () => {
     });
     expect(txResponse.hash.length).toBe(66);
   });
+
+  it("toEthersContract should work", async () => {
+    const ethersContract = await toEthersContract(ethers5, USDT_CONTRACT);
+    expect(ethersContract.address.toLowerCase()).toBe(
+      USDT_CONTRACT.address.toLowerCase(),
+    );
+    const decimals = await ethersContract.decimals();
+    expect(decimals.toString()).toBe("6");
+  });
+
+  it("fromEthersContract should work", async () => {
+    const provider = toEthersProvider(
+      ethers5,
+      TEST_CLIENT,
+      FORKED_ETHEREUM_CHAIN,
+    );
+    const ethersContract = new ethers5.Contract(
+      USDT_CONTRACT.address,
+      await resolveContractAbi(USDT_CONTRACT),
+      provider,
+    );
+
+    const thirdwebContract = await fromEthersContract({
+      client: TEST_CLIENT,
+      ethersContract,
+      chain: FORKED_ETHEREUM_CHAIN,
+    });
+
+    const _decimals = await decimals({ contract: thirdwebContract });
+    expect(_decimals).toBe(6);
+  });
 });

package/src/adapters/ethers5.ts

@@ -274,7 +274,7 @@ export const ethers5Adapter = /* @__PURE__ */ (() => {
  * @returns The ethers.js provider.
  * @internal
  */
-function toEthersProvider(
+export function toEthersProvider(
   ethers: Ethers5,
   client: ThirdwebClient,
   chain: Chain,
@@ -299,7 +299,7 @@ function toEthersProvider(
  * @returns A Promise that resolves to an ethers.js Contract.
  * @internal
  */
-async function toEthersContract<abi extends Abi = []>(
+export async function toEthersContract<abi extends Abi = []>(
   ethers: Ethers5,
   twContract: ThirdwebContract<abi>,
 ): Promise<ethers5.Contract> {
@@ -336,7 +336,7 @@ type FromEthersContractOptions = {
  * @returns A promise that resolves to a ThirdwebContract instance.
  * @internal
  */
-async function fromEthersContract<abi extends Abi>(
+export async function fromEthersContract<abi extends Abi>(
   options: FromEthersContractOptions,
 ): Promise<ThirdwebContract<abi>> {
   return getContract({

package/src/exports/extensions/ens.ts

@@ -17,3 +17,13 @@ export {
   type ResolveNameOptions,
   resolveName,
 } from "../../extensions/ens/resolve-name.js";
+
+export {
+  type ResolveL2NameOptions,
+  resolveL2Name,
+} from "../../extensions/ens/resolve-l2-name.js";
+
+export {
+  BASENAME_RESOLVER_ADDRESS,
+  BASE_SEPOLIA_BASENAME_RESOLVER_ADDRESS,
+} from "../../extensions/ens/constants.js";

package/src/extensions/ens/__generated__/L2Resolver/read/name.ts

@@ -0,0 +1,122 @@
+import type { AbiParameterToPrimitiveType } from "abitype";
+import { readContract } from "../../../../../transaction/read-contract.js";
+import type { BaseTransactionOptions } from "../../../../../transaction/types.js";
+import { encodeAbiParameters } from "../../../../../utils/abi/encodeAbiParameters.js";
+import { decodeAbiParameters } from "viem";
+import type { Hex } from "../../../../../utils/encoding/hex.js";
+import { detectMethod } from "../../../../../utils/bytecode/detectExtension.js";
+
+/**
+ * Represents the parameters for the "name" function.
+ */
+export type NameParams = {
+  node: AbiParameterToPrimitiveType<{ type: "bytes32"; name: "node" }>;
+};
+
+export const FN_SELECTOR = "0x691f3431" as const;
+const FN_INPUTS = [
+  {
+    type: "bytes32",
+    name: "node",
+  },
+] as const;
+const FN_OUTPUTS = [
+  {
+    type: "string",
+  },
+] as const;
+
+/**
+ * Checks if the `name` method is supported by the given contract.
+ * @param availableSelectors An array of 4byte function selectors of the contract. You can get this in various ways, such as using "whatsabi" or if you have the ABI of the contract available you can use it to generate the selectors.
+ * @returns A boolean indicating if the `name` method is supported.
+ * @extension ENS
+ * @example
+ * ```ts
+ * import { isNameSupported } from "thirdweb/extensions/ens";
+ *
+ * const supported = isNameSupported(["0x..."]);
+ * ```
+ */
+export function isNameSupported(availableSelectors: string[]) {
+  return detectMethod({
+    availableSelectors,
+    method: [FN_SELECTOR, FN_INPUTS, FN_OUTPUTS] as const,
+  });
+}
+
+/**
+ * Encodes the parameters for the "name" function.
+ * @param options - The options for the name function.
+ * @returns The encoded ABI parameters.
+ * @extension ENS
+ * @example
+ * ```ts
+ * import { encodeNameParams } "thirdweb/extensions/ens";
+ * const result = encodeNameParams({
+ *  node: ...,
+ * });
+ * ```
+ */
+export function encodeNameParams(options: NameParams) {
+  return encodeAbiParameters(FN_INPUTS, [options.node]);
+}
+
+/**
+ * Encodes the "name" function into a Hex string with its parameters.
+ * @param options - The options for the name function.
+ * @returns The encoded hexadecimal string.
+ * @extension ENS
+ * @example
+ * ```ts
+ * import { encodeName } "thirdweb/extensions/ens";
+ * const result = encodeName({
+ *  node: ...,
+ * });
+ * ```
+ */
+export function encodeName(options: NameParams) {
+  // 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 +
+    encodeNameParams(options).slice(2)) as `${typeof FN_SELECTOR}${string}`;
+}
+
+/**
+ * Decodes the result of the name function call.
+ * @param result - The hexadecimal result to decode.
+ * @returns The decoded result as per the FN_OUTPUTS definition.
+ * @extension ENS
+ * @example
+ * ```ts
+ * import { decodeNameResult } from "thirdweb/extensions/ens";
+ * const result = decodeNameResult("...");
+ * ```
+ */
+export function decodeNameResult(result: Hex) {
+  return decodeAbiParameters(FN_OUTPUTS, result)[0];
+}
+
+/**
+ * Calls the "name" function on the contract.
+ * @param options - The options for the name function.
+ * @returns The parsed result of the function call.
+ * @extension ENS
+ * @example
+ * ```ts
+ * import { name } from "thirdweb/extensions/ens";
+ *
+ * const result = await name({
+ *  contract,
+ *  node: ...,
+ * });
+ *
+ * ```
+ */
+export async function name(options: BaseTransactionOptions<NameParams>) {
+  return readContract({
+    contract: options.contract,
+    method: [FN_SELECTOR, FN_INPUTS, FN_OUTPUTS] as const,
+    params: [options.node],
+  });
+}

package/src/extensions/ens/constants.ts

@@ -1,2 +1,6 @@
 export const UNIVERSAL_RESOLVER_ADDRESS =
   "0xce01f8eee7E479C928F8919abD53E553a36CeF67";
+export const BASENAME_RESOLVER_ADDRESS =
+  "0xC6d566A56A1aFf6508b41f6c90ff131615583BCD";
+export const BASE_SEPOLIA_BASENAME_RESOLVER_ADDRESS =
+  "0x6533C94869D28fAA8dF77cc63f9e2b2D6Cf77eBA";

package/src/extensions/ens/resolve-address.test.ts

@@ -1,5 +1,7 @@
 import { describe, expect, it } from "vitest";
 import { TEST_CLIENT } from "../../../test/src/test-clients.js";
+import { base } from "../../chains/chain-definitions/base.js";
+import { BASENAME_RESOLVER_ADDRESS } from "./constants.js";
 import { resolveAddress } from "./resolve-address.js";
 
 // skip this test suite if there is no secret key available to test with
@@ -22,4 +24,15 @@ describe.runIf(process.env.TW_SECRET_KEY)("ENS:resolve-address", () => {
     });
     expect(address).toBe("0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045");
   });
+
+  it("should resolve Basename", async () => {
+    const name = "myk.base.eth";
+    const address = await resolveAddress({
+      client: TEST_CLIENT,
+      name,
+      resolverChain: base,
+      resolverAddress: BASENAME_RESOLVER_ADDRESS,
+    });
+    expect(address).toBe("0x653Ff253b0c7C1cc52f484e891b71f9f1F010Bfb");
+  });
 });

package/src/extensions/ens/resolve-address.ts

@@ -32,6 +32,18 @@ export type ResolveAddressOptions = {
  *    name: "vitalik.eth",
  * });
  * ```
+ *
+ * Resolve an address to a Basename.
+ * ```ts
+ * import { resolveAddress, BASENAME_RESOLVER_ADDRESS } from "thirdweb/extensions/ens";
+ * import { base } from "thirdweb/chains";
+ * const address = await resolveAddress({
+ *    client,
+ *    name: "myk.base.eth",
+ *    resolverAddress: BASENAME_RESOLVER_ADDRESS,
+ *    resolverChain: base,
+ * });
+ * ```
  * @extension ENS
  * @returns A promise that resolves to the Ethereum address.
  */
@@ -58,7 +70,7 @@ export async function resolveAddress(options: ResolveAddressOptions) {
       return resolvedAddress;
     },
     {
-      cacheKey: `ens:addr:${name}`,
+      cacheKey: `ens:addr:${resolverChain?.id || 1}:${name}`,
       // 1min cache
       cacheTime: 60 * 1000,
     },

package/src/extensions/ens/resolve-l2-name.test.ts

@@ -0,0 +1,30 @@
+import { describe, expect, it } from "vitest";
+import { TEST_CLIENT } from "../../../test/src/test-clients.js";
+import { base } from "../../chains/chain-definitions/base.js";
+import { BASENAME_RESOLVER_ADDRESS } from "./constants.js";
+import { resolveL2Name } from "./resolve-l2-name.js";
+
+// skip this test suite if there is no secret key available to test with
+// TODO: remove reliance on secret key during unit tests entirely
+describe.runIf(process.env.TW_SECRET_KEY)("ENS:resolve-l2-name", () => {
+  it("should resolve Basename", async () => {
+    const ens = await resolveL2Name({
+      client: TEST_CLIENT,
+      // myk.base.eth
+      address: "0x653Ff253b0c7C1cc52f484e891b71f9f1F010Bfb",
+      resolverChain: base,
+      resolverAddress: BASENAME_RESOLVER_ADDRESS,
+    });
+    expect(ens).toBe("myk.base.eth");
+  });
+
+  it("should return null if no Basename exists for the address", async () => {
+    const ens = await resolveL2Name({
+      client: TEST_CLIENT,
+      address: "0xc6248746A9CA5935ae722E2061347A5897548c03",
+      resolverChain: base,
+      resolverAddress: BASENAME_RESOLVER_ADDRESS,
+    });
+    expect(ens).toBeNull();
+  });
+});

package/src/extensions/ens/resolve-l2-name.ts

@@ -0,0 +1,107 @@
+import type { Address } from "abitype";
+import { type Hex, encodePacked, keccak256, namehash } from "viem";
+import type { Chain } from "../../chains/types.js";
+import type { ThirdwebClient } from "../../client/client.js";
+import { getContract } from "../../contract/contract.js";
+import { withCache } from "../../utils/promise/withCache.js";
+import { name } from "./__generated__/L2Resolver/read/name.js";
+
+/**
+ * @extension ENS
+ */
+export type ResolveL2NameOptions = {
+  client: ThirdwebClient;
+  address: Address;
+  resolverAddress: string;
+  resolverChain: Chain;
+};
+
+/**
+ * Convert an address to a reverse node for ENS resolution
+ *
+ * @internal
+ */
+export const convertReverseNodeToBytes = (
+  address: Address,
+  chainId: number,
+) => {
+  const addressFormatted = address.toLocaleLowerCase() as Address;
+  const addressNode = keccak256(addressFormatted.substring(2) as Hex);
+  const cointype = (0x80000000 | chainId) >>> 0;
+
+  const chainCoinType = cointype.toString(16).toLocaleUpperCase();
+  const reverseNode = namehash(`${chainCoinType.toLocaleUpperCase()}.reverse`);
+
+  const addressReverseNode = keccak256(
+    encodePacked(["bytes32", "bytes32"], [reverseNode, addressNode]),
+  );
+  return addressReverseNode;
+};
+
+/**
+ * Resolves the L2 name for a specified address.
+ * @param options - The options for resolving an L2 ENS address.
+ * @example
+ * ```ts
+ * import { resolveL2Name } from "thirdweb/extensions/ens";
+ * const name = await resolveL2Name({
+ *    client,
+ *    address: "0x1234...",
+ *    resolverAddress: "0x...",
+ *    resolverChain: base,
+ * });
+ * ```
+ *
+ * Resolve a Basename.
+ * ```ts
+ * import { resolveL2Name, BASENAME_RESOLVER_ADDRESS } from "thirdweb/extensions/ens";
+ * import { base } from "thirdweb/chains";
+ * const name = await resolveL2Name({
+ *    client,
+ *    address: "0x1234...",
+ *    resolverAddress: BASENAME_RESOLVER_ADDRESS,
+ *    resolverChain: base,
+ * });
+ * ```
+ * @extension ENS
+ * @returns A promise that resolves to the Ethereum address.
+ */
+export async function resolveL2Name(options: ResolveL2NameOptions) {
+  const { client, address, resolverAddress, resolverChain } = options;
+
+  return withCache(
+    async () => {
+      const contract = getContract({
+        client,
+        chain: resolverChain,
+        address: resolverAddress,
+      });
+
+      const reverseName = convertReverseNodeToBytes(
+        address,
+        resolverChain.id || 1,
+      );
+
+      const resolvedName = await name({
+        contract,
+        node: reverseName,
+      }).catch((e) => {
+        if ("data" in e && e.data === "0x7199966d") {
+          return null;
+        }
+        throw e;
+      });
+
+      if (resolvedName === "") {
+        return null;
+      }
+
+      return resolvedName;
+    },
+    {
+      cacheKey: `ens:name:${resolverChain}:${address}`,
+      // 1min cache
+      cacheTime: 60 * 1000,
+    },
+  );
+}

package/src/extensions/ens/resolve-name.ts

@@ -65,7 +65,7 @@ export async function resolveName(options: ResolveNameOptions) {
       return name;
     },
     {
-      cacheKey: `ens:name:${address}`,
+      cacheKey: `ens:name:${resolverChain?.id || 1}:${address}`,
       // 1min cache
       cacheTime: 60 * 1000,
     },

package/src/extensions/erc1155/drops/write/claimTo.test.ts

@@ -1,13 +1,12 @@
-import { beforeEach, describe, expect, it } from "vitest";
+import { 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 { TEST_ACCOUNT_A, TEST_ACCOUNT_B } from "~test/test-wallets.js";
 
+import { TEST_CONTRACT_URI } from "~test/ipfs-uris.js";
 import { NATIVE_TOKEN_ADDRESS } from "../../../../constants/addresses.js";
-import {
-  type ThirdwebContract,
-  getContract,
-} from "../../../../contract/contract.js";
+import { getContract } from "../../../../contract/contract.js";
+import { deployERC20Contract } from "../../../../extensions/prebuilts/deploy-erc20.js";
 import { deployERC1155Contract } from "../../../../extensions/prebuilts/deploy-erc1155.js";
 import { sendAndConfirmTransaction } from "../../../../transaction/actions/send-and-confirm-transaction.js";
 import { totalSupply } from "../../__generated__/IERC1155/read/totalSupply.js";
@@ -15,13 +14,12 @@ import { lazyMint } from "../../write/lazyMint.js";
 import { claimTo } from "./claimTo.js";
 import { setClaimConditions } from "./setClaimConditions.js";
 
-let contract: ThirdwebContract;
 const account = TEST_ACCOUNT_A;
 const client = TEST_CLIENT;
 const chain = ANVIL_CHAIN;
 
 describe.runIf(process.env.TW_SECRET_KEY)("erc1155 claimTo extension", () => {
-  beforeEach(async () => {
+  it("should claim the nft", async () => {
     const address = await deployERC1155Contract({
       client,
       chain,
@@ -29,17 +27,16 @@ describe.runIf(process.env.TW_SECRET_KEY)("erc1155 claimTo extension", () => {
       type: "DropERC1155",
       params: {
         name: "Edition Drop",
+        contractURI: TEST_CONTRACT_URI,
       },
     });
-    contract = getContract({
+    const contract = getContract({
       address,
       client,
       chain,
     });
-
-    const transaction = lazyMint({ contract, nfts: [{ name: "token 0" }] });
-    await sendAndConfirmTransaction({ transaction, account });
-
+    const lazyMintTx = lazyMint({ contract, nfts: [{ name: "token 0" }] });
+    await sendAndConfirmTransaction({ transaction: lazyMintTx, account });
     const setClaimTx = setClaimConditions({
       contract,
       tokenId: 0n,
@@ -53,20 +50,135 @@ describe.runIf(process.env.TW_SECRET_KEY)("erc1155 claimTo extension", () => {
         },
       ],
     });
+    await sendAndConfirmTransaction({ transaction: setClaimTx, account });
 
+    const transaction = claimTo({
+      contract,
+      tokenId: 0n,
+      quantity: 1n,
+      to: account.address,
+    });
+    await sendAndConfirmTransaction({ transaction, account });
+    const supplyCount = await totalSupply({ contract, id: 0n });
+    expect(supplyCount).toBe(1n);
+  });
+
+  it("should claim with allowlist", async () => {
+    const address = await deployERC1155Contract({
+      client,
+      chain,
+      account,
+      type: "DropERC1155",
+      params: {
+        name: "Edition Drop",
+        contractURI: TEST_CONTRACT_URI,
+      },
+    });
+    const contract = getContract({
+      address,
+      client,
+      chain,
+    });
+    const lazyMintTx = lazyMint({ contract, nfts: [{ name: "token 0" }] });
+    await sendAndConfirmTransaction({ transaction: lazyMintTx, account });
+    const setClaimTx = setClaimConditions({
+      contract,
+      tokenId: 0n,
+      phases: [
+        {
+          maxClaimableSupply: 100n,
+          maxClaimablePerWallet: 5n,
+          currencyAddress: NATIVE_TOKEN_ADDRESS,
+          price: 0.06,
+          startTime: new Date(),
+          overrideList: [
+            {
+              address: TEST_ACCOUNT_B.address,
+              maxClaimable: "50",
+              price: "0.3",
+              currencyAddress: NATIVE_TOKEN_ADDRESS,
+            },
+          ],
+        },
+      ],
+    });
     await sendAndConfirmTransaction({ transaction: setClaimTx, account });
+
+    const transaction = claimTo({
+      contract,
+      tokenId: 0n,
+      quantity: 50n,
+      to: TEST_ACCOUNT_B.address,
+    });
+    await sendAndConfirmTransaction({ transaction, account: TEST_ACCOUNT_B });
+    const supplyCount = await totalSupply({ contract, id: 0n });
+    expect(supplyCount).toBe(50n);
   });
 
-  it("should claim the nft", async () => {
+  /**
+   * This is to document the behavior where one can claim without paying if the claiming address
+   * is the same as the PrimaryRecipientAddress, because of this Solidity code:
+   * ```solidity
+   * // CurrencyTransferLib.sol
+   * function safeTransferERC20(address _currency, address _from, address _to, uint256 _amount) internal {
+   *   if (_from == _to) {
+   *     return;
+   *   }
+   *   ...
+   * }
+   * ```
+   */
+  it("address that is the same with PrimaryFeeRecipient can claim without paying ERC20", async () => {
+    const tokenAddress = await deployERC20Contract({
+      client,
+      chain,
+      account,
+      type: "TokenERC20",
+      params: {
+        name: "token20",
+        contractURI: TEST_CONTRACT_URI,
+      },
+    });
+    const address = await deployERC1155Contract({
+      client,
+      chain,
+      account,
+      type: "DropERC1155",
+      params: {
+        name: "Edition Drop",
+        contractURI: TEST_CONTRACT_URI,
+        saleRecipient: account.address,
+      },
+    });
+    const contract = getContract({
+      address,
+      client,
+      chain,
+    });
+    const lazyMintTx = lazyMint({ contract, nfts: [{ name: "token 0" }] });
+    await sendAndConfirmTransaction({ transaction: lazyMintTx, account });
+    const setClaimTx = setClaimConditions({
+      contract,
+      tokenId: 0n,
+      phases: [
+        {
+          maxClaimableSupply: 100n,
+          maxClaimablePerWallet: 100n,
+          currencyAddress: tokenAddress,
+          price: 1000,
+          startTime: new Date(),
+        },
+      ],
+    });
+    await sendAndConfirmTransaction({ transaction: setClaimTx, account });
+
     const transaction = claimTo({
       contract,
       tokenId: 0n,
       quantity: 1n,
       to: account.address,
     });
-
     await sendAndConfirmTransaction({ transaction, account });
-
     const supplyCount = await totalSupply({ contract, id: 0n });
     expect(supplyCount).toBe(1n);
   });

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

@@ -0,0 +1,55 @@
+import { 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 { TEST_CONTRACT_URI } from "~test/ipfs-uris.js";
+import { getContract } from "../../../../contract/contract.js";
+import { deployERC1155Contract } from "../../../../extensions/prebuilts/deploy-erc1155.js";
+import { sendAndConfirmTransaction } from "../../../../transaction/actions/send-and-confirm-transaction.js";
+import { getNFTs } from "../../read/getNFTs.js";
+import { lazyMint } from "../../write/lazyMint.js";
+import { updateMetadata } from "./updateMetadata.js";
+
+const account = TEST_ACCOUNT_A;
+const client = TEST_CLIENT;
+const chain = ANVIL_CHAIN;
+describe.runIf(process.env.TW_SECRET_KEY)("updateMetadata ERC1155", () => {
+  it("should update metadata", async () => {
+    const address = await deployERC1155Contract({
+      client,
+      chain,
+      account,
+      type: "DropERC1155",
+      params: {
+        name: "Edition Drop",
+        contractURI: TEST_CONTRACT_URI,
+      },
+    });
+    const contract = getContract({
+      address,
+      client,
+      chain,
+    });
+    const lazyMintTx = lazyMint({
+      contract,
+      nfts: [{ name: "token 0" }, { name: "token 1" }, { name: "token 2" }],
+    });
+    await sendAndConfirmTransaction({ transaction: lazyMintTx, account });
+
+    const updateTx = updateMetadata({
+      contract,
+      targetTokenId: 1n,
+      newMetadata: { name: "token 1 - updated" },
+      client,
+    });
+    await sendAndConfirmTransaction({ transaction: updateTx, account });
+
+    const nfts = await getNFTs({ contract });
+
+    expect(nfts.length).toBe(3);
+    expect(nfts[0]?.metadata.name).toBe("token 0");
+    expect(nfts[1]?.metadata.name).toBe("token 1 - updated");
+    expect(nfts[2]?.metadata.name).toBe("token 2");
+  });
+});