thirdweb 5.29.6 → 5.30.0-nightly-33777df88fb190c2af8ad25e4930040884996f1e-20240620000630

package/src/extensions/erc1155/__generated__/DropERC1155/write/setSaleRecipientForToken.ts

@@ -0,0 +1,157 @@
+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 "setSaleRecipientForToken" function.
+ */
+export type SetSaleRecipientForTokenParams = WithOverrides<{
+  tokenId: AbiParameterToPrimitiveType<{ type: "uint256"; name: "_tokenId" }>;
+  saleRecipient: AbiParameterToPrimitiveType<{
+    type: "address";
+    name: "_saleRecipient";
+  }>;
+}>;
+
+export const FN_SELECTOR = "0x29c49b9b" as const;
+const FN_INPUTS = [
+  {
+    type: "uint256",
+    name: "_tokenId",
+  },
+  {
+    type: "address",
+    name: "_saleRecipient",
+  },
+] as const;
+const FN_OUTPUTS = [] as const;
+
+/**
+ * Checks if the `setSaleRecipientForToken` method is supported by the given contract.
+ * @param contract The ThirdwebContract.
+ * @returns A promise that resolves to a boolean indicating if the `setSaleRecipientForToken` method is supported.
+ * @extension ERC1155
+ * @example
+ * ```ts
+ * import { isSetSaleRecipientForTokenSupported } from "thirdweb/extensions/erc1155";
+ *
+ * const supported = await isSetSaleRecipientForTokenSupported(contract);
+ * ```
+ */
+export async function isSetSaleRecipientForTokenSupported(
+  contract: ThirdwebContract<any>,
+) {
+  return detectMethod({
+    contract,
+    method: [FN_SELECTOR, FN_INPUTS, FN_OUTPUTS] as const,
+  });
+}
+
+/**
+ * Encodes the parameters for the "setSaleRecipientForToken" function.
+ * @param options - The options for the setSaleRecipientForToken function.
+ * @returns The encoded ABI parameters.
+ * @extension ERC1155
+ * @example
+ * ```ts
+ * import { encodeSetSaleRecipientForTokenParams } "thirdweb/extensions/erc1155";
+ * const result = encodeSetSaleRecipientForTokenParams({
+ *  tokenId: ...,
+ *  saleRecipient: ...,
+ * });
+ * ```
+ */
+export function encodeSetSaleRecipientForTokenParams(
+  options: SetSaleRecipientForTokenParams,
+) {
+  return encodeAbiParameters(FN_INPUTS, [
+    options.tokenId,
+    options.saleRecipient,
+  ]);
+}
+
+/**
+ * Encodes the "setSaleRecipientForToken" function into a Hex string with its parameters.
+ * @param options - The options for the setSaleRecipientForToken function.
+ * @returns The encoded hexadecimal string.
+ * @extension ERC1155
+ * @example
+ * ```ts
+ * import { encodeSetSaleRecipientForToken } "thirdweb/extensions/erc1155";
+ * const result = encodeSetSaleRecipientForToken({
+ *  tokenId: ...,
+ *  saleRecipient: ...,
+ * });
+ * ```
+ */
+export function encodeSetSaleRecipientForToken(
+  options: SetSaleRecipientForTokenParams,
+) {
+  // 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 +
+    encodeSetSaleRecipientForTokenParams(options).slice(
+      2,
+    )) as `${typeof FN_SELECTOR}${string}`;
+}
+
+/**
+ * Prepares a transaction to call the "setSaleRecipientForToken" function on the contract.
+ * @param options - The options for the "setSaleRecipientForToken" function.
+ * @returns A prepared transaction object.
+ * @extension ERC1155
+ * @example
+ * ```ts
+ * import { setSaleRecipientForToken } from "thirdweb/extensions/erc1155";
+ *
+ * const transaction = setSaleRecipientForToken({
+ *  contract,
+ *  tokenId: ...,
+ *  saleRecipient: ...,
+ *  overrides: {
+ *    ...
+ *  }
+ * });
+ *
+ * // Send the transaction
+ * ...
+ *
+ * ```
+ */
+export function setSaleRecipientForToken(
+  options: BaseTransactionOptions<
+    | SetSaleRecipientForTokenParams
+    | {
+        asyncParams: () => Promise<SetSaleRecipientForTokenParams>;
+      }
+  >,
+) {
+  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.tokenId, resolvedOptions.saleRecipient] 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/erc1155/__generated__/DropERC1155/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 ERC1155
+ * @example
+ * ```ts
+ * import { isUpdateBatchBaseURISupported } from "thirdweb/extensions/erc1155";
+ *
+ * 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 ERC1155
+ * @example
+ * ```ts
+ * import { encodeUpdateBatchBaseURIParams } "thirdweb/extensions/erc1155";
+ * 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 ERC1155
+ * @example
+ * ```ts
+ * import { encodeUpdateBatchBaseURI } "thirdweb/extensions/erc1155";
+ * 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 ERC1155
+ * @example
+ * ```ts
+ * import { updateBatchBaseURI } from "thirdweb/extensions/erc1155";
+ *
+ * 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/erc1155/drops/write/claimTo.test.ts

@@ -0,0 +1,73 @@
+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 { NATIVE_TOKEN_ADDRESS } from "../../../../constants/addresses.js";
+import {
+  type ThirdwebContract,
+  getContract,
+} from "../../../../contract/contract.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";
+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("erc1155 claimTo extension", () => {
+  beforeEach(async () => {
+    const address = await deployERC1155Contract({
+      client,
+      chain,
+      account,
+      type: "DropERC1155",
+      params: {
+        name: "Edition Drop",
+      },
+    });
+    contract = getContract({
+      address,
+      client,
+      chain,
+    });
+
+    const transaction = lazyMint({ contract, nfts: [{ name: "token 0" }] });
+    await sendAndConfirmTransaction({ transaction, account });
+
+    const setClaimTx = setClaimConditions({
+      contract,
+      tokenId: 0n,
+      phases: [
+        {
+          maxClaimableSupply: 100n,
+          maxClaimablePerWallet: 100n,
+          currencyAddress: NATIVE_TOKEN_ADDRESS,
+          price: 0.1,
+          startTime: new Date(),
+        },
+      ],
+    });
+
+    await sendAndConfirmTransaction({ transaction: setClaimTx, account });
+  });
+
+  it("should claim the nft", async () => {
+    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,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 { deployERC1155Contract } from "../../../../extensions/prebuilts/deploy-erc1155.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.runIf(process.env.TW_SECRET_KEY)("erc1155: updateMetadata", () => {
+  beforeEach(async () => {
+    const address = await deployERC1155Contract({
+      client,
+      chain,
+      account,
+      type: "DropERC1155",
+      params: {
+        name: "EditionDrop",
+      },
+    });
+    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",
+    );
+  });
+});

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

@@ -0,0 +1,125 @@
+import { getBaseURICount } from "../../../erc721/__generated__/IBatchMintMetadata/read/getBaseURICount.js";
+import {
+  type UpdateBatchBaseURIParams,
+  updateBatchBaseURI,
+} from "../../__generated__/DropERC1155/write/updateBatchBaseURI.js";
+
+import type { ThirdwebClient } from "../../../../client/client.js";
+import type { BaseTransactionOptions } from "../../../../transaction/types.js";
+import type { NFT, NFTInput } from "../../../../utils/nft/parseNft.js";
+
+export type UpdateMetadataParams = {
+  targetTokenId: bigint;
+  newMetadata: NFTInput;
+  client: ThirdwebClient;
+};
+
+/**
+ * @internal
+ */
+export async function getUpdateMetadataParams(
+  options: BaseTransactionOptions<UpdateMetadataParams>,
+): Promise<UpdateBatchBaseURIParams> {
+  const { contract, targetTokenId, newMetadata, client } = options;
+  const batchCount = await getBaseURICount(options);
+  if (batchCount === 0n) {
+    throw new Error(
+      "No base URI set. Please set a base URI before updating metadata",
+    );
+  }
+
+  // Look for the batchId & determine the start + end tokenId of the batch
+  const [{ getBatchIdAtIndex }, { getNFT }] = await Promise.all([
+    import("../../__generated__/BatchMintMetadata/read/getBatchIdAtIndex.js"),
+    import("../../read/getNFT.js"),
+  ]);
+
+  let startTokenId = 0n;
+  let endTokenId = 0n;
+  let batchIndex = 0n;
+  for (let i = 0n; i < batchCount; i += 1n) {
+    batchIndex = i;
+    endTokenId = await getBatchIdAtIndex({ contract, index: batchIndex });
+    if (endTokenId > targetTokenId) {
+      break;
+    }
+    startTokenId = endTokenId;
+  }
+
+  const range = Array.from(
+    { length: Number(endTokenId - startTokenId) },
+    (_, k) => BigInt(k) + startTokenId,
+  );
+
+  const currentMetadatas = await Promise.all(
+    range.map((id) => getNFT({ contract, tokenId: id })),
+  );
+
+  // Abort if any of the items failed to load
+  if (currentMetadatas.some((item) => item === undefined || !item.tokenURI)) {
+    throw new Error(
+      `Failed to load all ${range.length} items from batchIndex: ${batchIndex}`,
+    );
+  }
+
+  const newMetadatas: NFTInput[] = [];
+  for (let i = 0; i < currentMetadatas.length; i++) {
+    const { id, metadata } = currentMetadatas[i] as NFT;
+    if (targetTokenId === id) {
+      newMetadatas.push(newMetadata);
+    } else {
+      newMetadatas.push(metadata);
+    }
+  }
+
+  const { uploadOrExtractURIs } = await import("../../../../utils/ipfs.js");
+  const batchOfUris = await uploadOrExtractURIs(
+    newMetadatas,
+    client,
+    Number(startTokenId),
+  );
+
+  if (!batchOfUris || !batchOfUris.length || !batchOfUris[0]) {
+    throw new Error("Failed to upload batch of new metadatas");
+  }
+
+  const baseUri = batchOfUris[0].substring(0, batchOfUris[0].lastIndexOf("/"));
+
+  // IMPORTANT: The new ipfs URI must have the trailing slash at the end
+  // this is required by the Drop contract
+  const uri = `${baseUri}/`;
+
+  return { index: batchIndex, uri };
+}
+
+/**
+ * Update the metadata of the single token in an Edition Drop (DropERC1155) collection
+ * For Edition contracts, use `setTokenURI`
+ * @param options
+ * @returns the prepared transaction
+ * @extension ERC1155
+ * @example
+ * ```ts
+ * import { updateMetadata } from "thirdweb/extensions/erc1155";
+ *
+ * const transaction = updateMetadata({
+ *  contract,
+ *  targetTokenId: 0n,
+ *  newMetadata: {
+ *    name: "this is the new nft name",
+ *    description: "...",
+ *    image: "new image uri"
+ *    // ...
+ *  }
+ * });
+ * ```
+ */
+export function updateMetadata(
+  options: BaseTransactionOptions<UpdateMetadataParams>,
+) {
+  const { contract } = options;
+  return updateBatchBaseURI({
+    contract,
+    asyncParams: async () => getUpdateMetadataParams(options),
+  });
+}

package/src/extensions/erc721/write/mintTo.test.ts

@@ -0,0 +1,67 @@
+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 { tokenURI } from "../__generated__/IERC721A/read/tokenURI.js";
+import { getNFT } from "../read/getNFT.js";
+import { mintTo } from "./mintTo.js";
+
+let contract: ThirdwebContract;
+const account = TEST_ACCOUNT_A;
+const client = TEST_CLIENT;
+const chain = ANVIL_CHAIN;
+
+describe("erc721 mintTo extension", () => {
+  beforeEach(async () => {
+    const address = await deployERC721Contract({
+      client,
+      chain,
+      account,
+      type: "TokenERC721",
+      params: {
+        name: "NFTDrop",
+      },
+    });
+    contract = getContract({
+      address,
+      client,
+      chain,
+    });
+  });
+
+  it("should mint an nft when passed an object", async () => {
+    const transaction = mintTo({
+      contract,
+      nft: { name: "token 0" },
+      to: account.address,
+    });
+    await sendAndConfirmTransaction({
+      transaction,
+      account,
+    });
+
+    const nft = await getNFT({ contract, tokenId: 0n });
+    expect(nft.metadata.name).toBe("token 0");
+  });
+
+  it("should mint an nft when passed a string", async () => {
+    const transaction = mintTo({
+      contract,
+      nft: "ipfs://fake-token-uri",
+      to: account.address,
+    });
+    await sendAndConfirmTransaction({
+      transaction,
+      account,
+    });
+    const _uri = await tokenURI({ contract, tokenId: 0n });
+    expect(_uri).toBe("ipfs://fake-token-uri");
+  });
+});