thirdweb 5.29.6-nightly-c13ffc5f8bbf88998a9bf96730a85ba1713f761a-20240618004239 → 5.30.0-nightly-991cb72bdb1b94fcf0f9a3de36b2ec8ee07ae5ec-20240619000538

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/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/pay/buyWithCrypto/getQuote.ts

@@ -65,6 +65,13 @@ export type GetBuyWithCryptoQuoteParams = {
    */
   toTokenAddress: string;
 
+  /**
+   * Extra details to store with the purchase.
+   *
+   * This details will be stored with the purchase and can be retrieved later via the status API or Webhook
+   */
+  purchaseData?: object;
+
   /**
    * The maximum slippage in basis points (bps) allowed for the swap.
    * For example, if you want to allow a maximum slippage of 0.5%, you should specify `50` bps.
@@ -229,34 +236,27 @@ export async function getBuyWithCryptoQuote(
   params: GetBuyWithCryptoQuoteParams,
 ): Promise<BuyWithCryptoQuote> {
   try {
-    const queryParams = new URLSearchParams({
-      fromAddress: params.fromAddress,
-      fromChainId: params.fromChainId.toString(),
-      fromTokenAddress: params.fromTokenAddress.toLowerCase(),
-      toChainId: params.toChainId.toString(),
-      toTokenAddress: params.toTokenAddress.toLowerCase(),
-    });
-
-    if ("fromAmount" in params && params.fromAmount) {
-      queryParams.append("fromAmount", params.fromAmount);
-    }
-
-    if ("toAmount" in params && params.toAmount) {
-      queryParams.append("toAmount", params.toAmount);
-    }
-
-    if (params.maxSlippageBPS) {
-      queryParams.append("maxSlippageBPS", params.maxSlippageBPS.toString());
-    }
-
-    if (params.intentId) {
-      queryParams.append("intentId", params.intentId);
-    }
-
-    const queryString = queryParams.toString();
-    const url = `${getPayBuyWithCryptoQuoteEndpoint()}?${queryString}`;
+    const clientFetch = getClientFetch(params.client);
 
-    const response = await getClientFetch(params.client)(url);
+    const response = await clientFetch(getPayBuyWithCryptoQuoteEndpoint(), {
+      method: "POST",
+      headers: {
+        Accept: "application/json",
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({
+        fromAddress: params.fromAddress,
+        fromChainId: params.fromChainId.toString(),
+        fromTokenAddress: params.fromTokenAddress,
+        toChainId: params.toChainId.toString(),
+        toTokenAddress: params.toTokenAddress,
+        fromAmount: params.fromAmount,
+        toAmount: params.toAmount,
+        maxSlippageBPS: params.maxSlippageBPS,
+        intentId: params.intentId,
+        purchaseData: params.purchaseData,
+      }),
+    });
 
     // Assuming the response directly matches the SwapResponse interface
     if (!response.ok) {

package/src/pay/buyWithCrypto/getStatus.ts

@@ -70,6 +70,7 @@ export type BuyWithCryptoStatus =
       toAddress: string;
       failureMessage?: string;
       bridge?: string;
+      purchaseData?: object;
     };
 
 export type ValidBuyWithCryptoStatus = Exclude<

package/src/pay/buyWithFiat/getQuote.ts

@@ -15,10 +15,15 @@ export type GetBuyWithFiatQuoteParams = {
   client: ThirdwebClient;
 
   /**
-   * The address of the wallet to which the tokens will be sent.
+   * The address of the wallet where the tokens will be sent.
    */
   toAddress: string;
 
+  /**
+   * The address of the wallet which will be used to buy the token.
+   */
+  fromAddress: string;
+
   /**
    * Chain id of the token to buy.
    */
@@ -62,6 +67,13 @@ export type GetBuyWithFiatQuoteParams = {
    * Defaults to `false`
    */
   isTestMode?: boolean;
+
+  /**
+   * Extra details to store with the purchase.
+   *
+   * This details will be stored with the purchase and can be retrieved later via the status API or Webhook
+   */
+  purchaseData?: object;
 };
 
 /**
@@ -236,33 +248,27 @@ export async function getBuyWithFiatQuote(
   params: GetBuyWithFiatQuoteParams,
 ): Promise<BuyWithFiatQuote> {
   try {
-    const queryParams = new URLSearchParams({
-      toAddress: params.toAddress,
-      fromCurrencySymbol: params.fromCurrencySymbol,
-      toChainId: params.toChainId.toString(),
-      toTokenAddress: params.toTokenAddress.toLowerCase(),
-    });
-
-    if (params.fromAmount) {
-      queryParams.append("fromAmount", params.fromAmount);
-    }
-
-    if (params.toAmount) {
-      queryParams.append("toAmount", params.toAmount);
-    }
-
-    if (params.maxSlippageBPS) {
-      queryParams.append("maxSlippageBPS", params.maxSlippageBPS.toString());
-    }
+    const clientFetch = getClientFetch(params.client);
 
-    if (params.isTestMode) {
-      queryParams.append("isTestMode", params.isTestMode.toString());
-    }
-
-    const queryString = queryParams.toString();
-    const url = `${getPayBuyWithFiatQuoteEndpoint()}?${queryString}`;
-
-    const response = await getClientFetch(params.client)(url);
+    const response = await clientFetch(getPayBuyWithFiatQuoteEndpoint(), {
+      method: "POST",
+      headers: {
+        Accept: "application/json",
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({
+        toAddress: params.toAddress,
+        fromCurrencySymbol: params.fromCurrencySymbol,
+        toChainId: params.toChainId.toString(),
+        toTokenAddress: params.toTokenAddress,
+        fromAmount: params.fromAmount,
+        toAmount: params.toAmount,
+        maxSlippageBPS: params.maxSlippageBPS,
+        isTestMode: params.isTestMode,
+        purchaseData: params.purchaseData,
+        fromAddress: params.fromAddress,
+      }),
+    });
 
     // Assuming the response directly matches the SwapResponse interface
     if (!response.ok) {

package/src/pay/buyWithFiat/getStatus.ts

@@ -116,6 +116,11 @@ export type BuyWithFiatStatus =
        * Message indicating the reason for failure
        */
       failureMessage?: string;
+
+      /**
+       * Arbitrary data sent at the time of fetching the quote
+       */
+      purchaseData?: object;
     };
 
 /**

package/src/react/core/hooks/transaction/useSendTransaction.ts

@@ -47,6 +47,7 @@ export type SendTransactionPayModalConfig =
         | {
             testMode?: boolean;
           };
+      purchaseData?: object;
     }
   | false;
 

package/src/react/native/hooks/wallets/useActiveWalletChain.ts

@@ -8,7 +8,7 @@ import { connectionManager } from "../../index.js";
  * ```jsx
  * import { useActiveWalletChain } from "thirdweb/react";
  *
- * const chainId = useActiveWalletChain();
+ * const activeChain = useActiveWalletChain();
  * ```
  * @walletConnection
  */

package/src/react/web/hooks/transaction/useSendTransaction.tsx

@@ -92,6 +92,7 @@ export function useSendTransaction(config: SendTransactionConfig = {}) {
                 payOptions={{
                   buyWithCrypto: payModal?.buyWithCrypto,
                   buyWithFiat: payModal?.buyWithFiat,
+                  purchaseData: payModal?.purchaseData,
                 }}
               />,
             );

package/src/react/web/hooks/wallets/useActiveWalletChain.ts

@@ -8,7 +8,7 @@ import { connectionManager } from "../../index.js";
  * ```jsx
  * import { useActiveWalletChain } from "thirdweb/react";
  *
- * const chainId = useActiveWalletChain();
+ * const activeChain = useActiveWalletChain();
  * ```
  * @walletConnection
  */