thirdweb 5.55.0-nightly-8035923cdad943a47fc909e04522c351d06804f0-20240913000407 → 5.55.1-nightly-b2a2c9784a33394dffbcd32bbd28b2c612a4e603-20240915000420

package/src/extensions/marketplace/direct-listings/write/createListing.ts

@@ -10,7 +10,7 @@ import type { BaseTransactionOptions } from "../../../../transaction/types.js";
 import { toUnits } from "../../../../utils/units.js";
 import { isERC721 } from "../../../erc721/read/isERC721.js";
 import { isERC1155 } from "../../../erc1155/read/isERC1155.js";
-import { createListing as generatedCreateListing } from "../../__generated__/IDirectListings/write/createListing.js";
+import * as CreateListing from "../../__generated__/IDirectListings/write/createListing.js";
 
 /**
  * @extension MARKETPLACE
@@ -88,7 +88,7 @@ export type CreateListingParams = {
 export function createListing(
   options: BaseTransactionOptions<CreateListingParams>,
 ) {
-  return generatedCreateListing({
+  return CreateListing.createListing({
     contract: options.contract,
     asyncParams: async () => {
       const assetContract = getContract({
@@ -182,3 +182,19 @@ export function createListing(
     },
   });
 }
+
+/**
+ * Checks if the `createListing` 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 `createListing` method is supported.
+ * @extension MARKETPLACE
+ * @example
+ * ```ts
+ * import { isCreateAuctionSupported } from "thirdweb/extensions/marketplace";
+ *
+ * const supported = isCreateAuctionSupported(["0x..."]);
+ * ```
+ */
+export function isCreateListingSupported(availableSelectors: string[]) {
+  return CreateListing.isCreateListingSupported(availableSelectors);
+}

package/src/extensions/marketplace/english-auctions/read/getAuction.ts

@@ -1,18 +1,14 @@
 import { eth_getBlockByNumber } from "../../../../rpc/actions/eth_getBlockByNumber.js";
 import { getRpcClient } from "../../../../rpc/rpc.js";
 import type { BaseTransactionOptions } from "../../../../transaction/types.js";
-
-import {
-  type GetAuctionParams as GetAuctionParamsGenerated,
-  getAuction as getAuctionGenerated,
-} from "../../__generated__/IEnglishAuctions/read/getAuction.js";
+import * as GetAuction from "../../__generated__/IEnglishAuctions/read/getAuction.js";
 import type { EnglishAuction } from "../types.js";
 import { mapEnglishAuction } from "../utils.js";
 
 /**
  * @extension MARKETPLACE
  */
-export type GetAuctionParams = GetAuctionParamsGenerated;
+export type GetAuctionParams = GetAuction.GetAuctionParams;
 
 /**
  * Retrieves an auction listing based on the provided options.
@@ -32,7 +28,7 @@ export async function getAuction(
 ): Promise<EnglishAuction> {
   const rpcClient = getRpcClient(options.contract);
   const [rawAuction, latestBlock] = await Promise.all([
-    getAuctionGenerated(options),
+    GetAuction.getAuction(options),
     eth_getBlockByNumber(rpcClient, {
       blockTag: "latest",
     }),
@@ -44,3 +40,19 @@ export async function getAuction(
     rawAuction,
   });
 }
+
+/**
+ * Checks if the `getAuction` 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 `getAuction` method is supported.
+ * @extension MARKETPLACE
+ * @example
+ * ```ts
+ * import { isGetAuctionSupported } from "thirdweb/extensions/marketplace";
+ *
+ * const supported = isGetAuctionSupported(["0x..."]);
+ * ```
+ */
+export function isGetAuctionSupported(availableSelectors: string[]) {
+  return GetAuction.isGetAuctionSupported(availableSelectors);
+}

package/src/extensions/marketplace/english-auctions/read/getWinningBid.ts

@@ -1,15 +1,12 @@
-import { ADDRESS_ZERO } from "../../../../constants/addresses.js";
+import { ZERO_ADDRESS } from "../../../../constants/addresses.js";
 import type { BaseTransactionOptions } from "../../../../transaction/types.js";
 import { resolveCurrencyValue } from "../../../../utils/extensions/resolve-currency-value.js";
-import {
-  type GetWinningBidParams as GeneratedWinningBidParams,
-  getWinningBid as getWinningBidGenerated,
-} from "../../__generated__/IEnglishAuctions/read/getWinningBid.js";
+import * as GetWinningBid from "../../__generated__/IEnglishAuctions/read/getWinningBid.js";
 
 /**
  * @extension MARKETPLACE
  */
-export type GetWinningBidParams = GeneratedWinningBidParams;
+export type GetWinningBidParams = GetWinningBid.GetWinningBidParams;
 
 /**
  * Retrieves the winning bid information for a given auction.
@@ -31,9 +28,9 @@ export async function getWinningBid(
   options: BaseTransactionOptions<GetWinningBidParams>,
 ) {
   const [bidderAddress, currencyAddress, bidAmountWei] =
-    await getWinningBidGenerated(options);
+    await GetWinningBid.getWinningBid(options);
 
-  if (bidderAddress === ADDRESS_ZERO) {
+  if (bidderAddress === ZERO_ADDRESS) {
     return undefined;
   }
 
@@ -49,3 +46,19 @@ export async function getWinningBid(
     }),
   };
 }
+
+/**
+ * Checks if the `getWinningBid` 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 `getWinningBid` method is supported.
+ * @extension MARKETPLACE
+ * @example
+ * ```ts
+ * import { isGetWinningBidSupported } from "thirdweb/extensions/marketplace";
+ *
+ * const supported = isGetWinningBidSupported(["0x..."]);
+ * ```
+ */
+export function isGetWinningBidSupported(availableSelectors: string[]) {
+  return GetWinningBid.isGetWinningBidSupported(availableSelectors);
+}

package/src/extensions/marketplace/english-auctions/write/bidInAuction.ts

@@ -1,9 +1,9 @@
 import { isNativeTokenAddress } from "../../../../constants/addresses.js";
 import type { BaseTransactionOptions } from "../../../../transaction/types.js";
-import { isNewWinningBid } from "../../__generated__/IEnglishAuctions/read/isNewWinningBid.js";
-import { bidInAuction as generatedBidInAuction } from "../../__generated__/IEnglishAuctions/write/bidInAuction.js";
-import { getAuction } from "../read/getAuction.js";
-import { getWinningBid } from "../read/getWinningBid.js";
+import * as IsNewWinningBid from "../../__generated__/IEnglishAuctions/read/isNewWinningBid.js";
+import * as BidInAuction from "../../__generated__/IEnglishAuctions/write/bidInAuction.js";
+import * as GetAuction from "../read/getAuction.js";
+import * as GetWinningBid from "../read/getWinningBid.js";
 
 /**
  * @extension MARKETPLACE
@@ -39,10 +39,10 @@ export type BidInAuctionParams = {
 export function bidInAuction(
   options: BaseTransactionOptions<BidInAuctionParams>,
 ) {
-  return generatedBidInAuction({
+  return BidInAuction.bidInAuction({
     contract: options.contract,
     asyncParams: async () => {
-      const auction = await getAuction({
+      const auction = await GetAuction.getAuction({
         contract: options.contract,
         auctionId: options.auctionId,
       });
@@ -70,13 +70,13 @@ export function bidInAuction(
       if (resolvedBidAmountWei > auction.buyoutCurrencyValue.value) {
         throw new Error("Bid amount is above the buyout amount");
       }
-      const existingWinningBid = await getWinningBid({
+      const existingWinningBid = await GetWinningBid.getWinningBid({
         auctionId: options.auctionId,
         contract: options.contract,
       });
       if (existingWinningBid) {
         // check if the bid amount is sufficient to outbid the existing winning bid
-        const isNewWinner = await isNewWinningBid({
+        const isNewWinner = await IsNewWinningBid.isNewWinningBid({
           contract: options.contract,
           auctionId: options.auctionId,
           bidAmount: resolvedBidAmountWei,
@@ -106,3 +106,24 @@ export function bidInAuction(
     },
   });
 }
+
+/**
+ * Checks if the `bidInAuction` 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 `bidInAuction` method is supported.
+ * @extension MARKETPLACE
+ * @example
+ * ```ts
+ * import { isBidInAuctionSupported } from "thirdweb/extensions/marketplace";
+ *
+ * const supported = isBidInAuctionSupported(["0x..."]);
+ * ```
+ */
+export function isBidInAuctionSupported(availableSelectors: string[]) {
+  return (
+    BidInAuction.isBidInAuctionSupported(availableSelectors) &&
+    GetWinningBid.isGetWinningBidSupported(availableSelectors) &&
+    GetAuction.isGetAuctionSupported(availableSelectors) &&
+    IsNewWinningBid.isIsNewWinningBidSupported(availableSelectors)
+  );
+}

package/src/extensions/marketplace/english-auctions/write/cancelAuction.ts

@@ -1,6 +1,9 @@
 import type { BaseTransactionOptions } from "../../../../transaction/types.js";
-import { cancelAuction as generatedCancelAuction } from "../../__generated__/IEnglishAuctions/write/cancelAuction.js";
-import { getWinningBid } from "../read/getWinningBid.js";
+import * as CancelAuction from "../../__generated__/IEnglishAuctions/write/cancelAuction.js";
+import {
+  getWinningBid,
+  isGetWinningBidSupported,
+} from "../read/getWinningBid.js";
 
 /**
  * @extension MARKETPLACE
@@ -32,7 +35,7 @@ export type CancelAuctionParams = {
 export function cancelAuction(
   options: BaseTransactionOptions<CancelAuctionParams>,
 ) {
-  return generatedCancelAuction({
+  return CancelAuction.cancelAuction({
     contract: options.contract,
     asyncParams: async () => {
       const winningBid = await getWinningBid({
@@ -51,3 +54,22 @@ export function cancelAuction(
     },
   });
 }
+
+/**
+ * Checks if the `cancelAuction` 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 `cancelAuction` method is supported.
+ * @extension MARKETPLACE
+ * @example
+ * ```ts
+ * import { isCancelAuctionSupported } from "thirdweb/extensions/marketplace";
+ *
+ * const supported = isCancelAuctionSupported(["0x..."]);
+ * ```
+ */
+export function isCancelAuctionSupported(availableSelectors: string[]) {
+  return (
+    CancelAuction.isCancelAuctionSupported(availableSelectors) &&
+    isGetWinningBidSupported(availableSelectors)
+  );
+}

package/src/extensions/marketplace/english-auctions/write/createAuction.ts

@@ -10,7 +10,7 @@ import type { BaseTransactionOptions } from "../../../../transaction/types.js";
 import { toUnits } from "../../../../utils/units.js";
 import { isERC721 } from "../../../erc721/read/isERC721.js";
 import { isERC1155 } from "../../../erc1155/read/isERC1155.js";
-import { createAuction as generatedCreateAuction } from "../../__generated__/IEnglishAuctions/write/createAuction.js";
+import * as CreateAuction from "../../__generated__/IEnglishAuctions/write/createAuction.js";
 
 /**
  * @extension MARKETPLACE
@@ -119,7 +119,7 @@ export type CreateAuctionParams = {
 export function createAuction(
   options: BaseTransactionOptions<CreateAuctionParams>,
 ) {
-  return generatedCreateAuction({
+  return CreateAuction.createAuction({
     ...options,
     asyncParams: async () => {
       const assetContract = getContract({
@@ -245,3 +245,19 @@ export function createAuction(
     },
   });
 }
+
+/**
+ * Checks if the `createAuction` 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 `createAuction` method is supported.
+ * @extension MARKETPLACE
+ * @example
+ * ```ts
+ * import { isCreateAuctionSupported } from "thirdweb/extensions/marketplace";
+ *
+ * const supported = isCreateAuctionSupported(["0x..."]);
+ * ```
+ */
+export function isCreateAuctionSupported(availableSelectors: string[]) {
+  return CreateAuction.isCreateAuctionSupported(availableSelectors);
+}

package/src/extensions/prebuilts/deploy-published.ts

@@ -18,6 +18,7 @@ import type { FetchDeployMetadataResult } from "../../utils/any-evm/deploy-metad
 import { isZkSyncChain } from "../../utils/any-evm/zksync/isZkSyncChain.js";
 import type { Hex } from "../../utils/encoding/hex.js";
 import type { Account } from "../../wallets/interfaces/wallet.js";
+import { getAllDefaultConstructorParamsForImplementation } from "./get-required-transactions.js";
 
 /**
  * @extension DEPLOY
@@ -168,7 +169,12 @@ export async function deployContractfromDeployMetadata(
           client,
           account,
           contractId: deployMetadata.name,
-          constructorParams: implementationConstructorParams,
+          constructorParams:
+            implementationConstructorParams ||
+            (await getAllDefaultConstructorParamsForImplementation({
+              chain,
+              client,
+            })),
           publisher: deployMetadata.publisher,
         });
 

package/src/extensions/prebuilts/get-required-transactions.test.ts

@@ -2,7 +2,7 @@ import { describe, expect, it } from "vitest";
 import { CLEAN_ANVIL_CHAIN } from "../../../test/src/chains.js";
 import { TEST_CLIENT } from "../../../test/src/test-clients.js";
 import { fetchPublishedContractMetadata } from "../../contract/deployment/publisher.js";
-import { getRequiredTransactionCount } from "./get-required-transactions.js";
+import { getRequiredTransactions } from "./get-required-transactions.js";
 
 describe.runIf(process.env.TW_SECRET_KEY)(
   "getRequiredTransactions",
@@ -11,47 +11,49 @@ describe.runIf(process.env.TW_SECRET_KEY)(
   },
   () => {
     it("should count transactions for a published direct deploy contract", async () => {
-      const metadata = await fetchPublishedContractMetadata({
+      const deployMetadata = await fetchPublishedContractMetadata({
         client: TEST_CLIENT,
         contractId: "AccountFactory",
       });
-      const results = await getRequiredTransactionCount({
+      const results = await getRequiredTransactions({
         client: TEST_CLIENT,
         chain: CLEAN_ANVIL_CHAIN,
-        metadata,
+        deployMetadata,
       });
       expect(results.length).toBe(1);
     });
 
     it("should count transactions for a published autofactory contract", async () => {
-      const metadata = await fetchPublishedContractMetadata({
+      const deployMetadata = await fetchPublishedContractMetadata({
         client: TEST_CLIENT,
         contractId: "Airdrop",
       });
-      const results = await getRequiredTransactionCount({
+      const results = await getRequiredTransactions({
         client: TEST_CLIENT,
         chain: CLEAN_ANVIL_CHAIN,
-        metadata,
+        deployMetadata,
       });
       expect(results.length).toBe(4);
     });
 
     it("should count transactions for a modular contract with modules", async () => {
-      const metadata = await fetchPublishedContractMetadata({
+      const deployMetadata = await fetchPublishedContractMetadata({
         client: TEST_CLIENT,
         contractId: "ERC721CoreInitializable",
       });
-      const results = await getRequiredTransactionCount({
+      const results = await getRequiredTransactions({
         client: TEST_CLIENT,
         chain: CLEAN_ANVIL_CHAIN,
-        metadata,
+        deployMetadata,
         modules: await Promise.all(
           ["ClaimableERC721", "BatchMetadataERC721", "RoyaltyERC721"].map(
             (contractId) =>
               fetchPublishedContractMetadata({
                 client: TEST_CLIENT,
                 contractId,
-              }),
+              }).then((m) => ({
+                deployMetadata: m,
+              })),
           ),
         ),
       });

package/src/extensions/prebuilts/get-required-transactions.ts

@@ -5,6 +5,8 @@ import { getDeployedInfraContract } from "../../contract/deployment/utils/infra.
 import { getDeployedInfraContractFromMetadata } from "../../contract/deployment/utils/infra.js";
 import { computePublishedContractAddress } from "../../utils/any-evm/compute-published-contract-address.js";
 import type { FetchDeployMetadataResult } from "../../utils/any-evm/deploy-metadata.js";
+import { isZkSyncChain } from "../../utils/any-evm/zksync/isZkSyncChain.js";
+import type { DeployContractfromDeployMetadataOptions } from "./deploy-published.js";
 
 /**
  * @internal
@@ -13,6 +15,7 @@ export type DeployTransactionType =
   | "infra"
   | "implementation"
   | "module"
+  | "extension"
   | "proxy";
 
 /**
@@ -26,36 +29,42 @@ export type DeployTransactionResult = {
 /**
  * @internal
  */
-export async function getRequiredTransactionCount(options: {
-  chain: Chain;
-  client: ThirdwebClient;
-  metadata: FetchDeployMetadataResult;
-  constructorParams?: Record<string, unknown>;
-  implementationConstructorParams?: Record<string, unknown>;
-  modules?: FetchDeployMetadataResult[];
-}): Promise<DeployTransactionResult[]> {
+export async function getRequiredTransactions(
+  options: Omit<
+    DeployContractfromDeployMetadataOptions,
+    "account" | "initializeParams"
+  >,
+): Promise<DeployTransactionResult[]> {
   const {
     chain,
     client,
-    metadata,
+    deployMetadata,
     implementationConstructorParams,
     modules = [],
   } = options;
 
-  if (metadata?.deployType === "autoFactory") {
-    const results: (DeployTransactionResult | null)[] = await Promise.all([
+  if (deployMetadata?.deployType === "autoFactory") {
+    const results: (
+      | DeployTransactionResult
+      | DeployTransactionResult[]
+      | null
+    )[] = await Promise.all([
       getDeployedCreate2Factory({
         chain,
         client,
       }).then((c) =>
-        c ? null : ({ type: "infra", contractId: "Create2Factory" } as const),
+        c || isZkSyncChain(chain)
+          ? null
+          : ({ type: "infra", contractId: "Create2Factory" } as const),
       ),
       getDeployedInfraContract({
         chain,
         client,
         contractId: "Forwarder",
       }).then((c) =>
-        c ? null : ({ type: "infra", contractId: "Forwarder" } as const),
+        c || isZkSyncChain(chain)
+          ? null
+          : ({ type: "infra", contractId: "Forwarder" } as const),
       ),
       getDeployedInfraContract({
         chain,
@@ -69,42 +78,150 @@ export async function getRequiredTransactionCount(options: {
           }),
         },
       }).then((c) =>
-        c ? null : ({ type: "infra", contractId: "TWCloneFactory" } as const),
+        c || isZkSyncChain(chain)
+          ? null
+          : ({ type: "infra", contractId: "TWCloneFactory" } as const),
       ),
       // TODO (deploy): add WETH contract check for implementations that need it (check implementation constructor params)
-      getDeployedInfraContract({
+      getTransactionsForImplementation({
         chain,
         client,
-        contractId: metadata.name,
-        constructorParams: implementationConstructorParams,
-        publisher: metadata.publisher,
-        version: metadata.version,
-      }).then((c) =>
-        c
-          ? null
-          : ({
-              type: "implementation",
-              contractId: metadata.name,
-            } as const),
-      ),
+        deployMetadata,
+        implementationConstructorParams,
+      }),
       ...modules.map((m) =>
         getDeployedInfraContractFromMetadata({
           chain,
           client,
-          contractMetadata: m,
+          contractMetadata: m.deployMetadata,
         }).then((c) =>
           c
             ? null
             : ({
                 type: "module",
-                contractId: m.name,
+                contractId: m.deployMetadata.name,
               } as const),
         ),
       ),
     ]);
-    results.push({ type: "proxy", contractId: metadata.name });
-    return results.filter((r) => r !== null);
+    results.push({ type: "proxy", contractId: deployMetadata.name });
+    return results.flat().filter((r) => r !== null);
   }
 
-  return [{ type: "implementation", contractId: metadata.name }];
+  return [{ type: "implementation", contractId: deployMetadata.name }];
+}
+
+async function getTransactionsForImplementation(options: {
+  chain: Chain;
+  client: ThirdwebClient;
+  deployMetadata: FetchDeployMetadataResult;
+  implementationConstructorParams?: Record<string, unknown>;
+}): Promise<DeployTransactionResult[]> {
+  const { chain, client, deployMetadata, implementationConstructorParams } =
+    options;
+
+  if (deployMetadata.name === "MarketplaceV3") {
+    return getTransactionsForMaketplaceV3(options);
+  }
+
+  const constructorParams =
+    implementationConstructorParams ??
+    (await getAllDefaultConstructorParamsForImplementation({
+      chain,
+      client,
+    }));
+
+  const result = await getDeployedInfraContract({
+    chain,
+    client,
+    contractId: deployMetadata.name,
+    constructorParams,
+    publisher: deployMetadata.publisher,
+    version: deployMetadata.version,
+  }).then((c) =>
+    c
+      ? null
+      : ({
+          type: "implementation",
+          contractId: deployMetadata.name,
+        } as const),
+  );
+  return result ? [result] : [];
+}
+
+async function getTransactionsForMaketplaceV3(options: {
+  chain: Chain;
+  client: ThirdwebClient;
+}): Promise<DeployTransactionResult[]> {
+  const { chain, client } = options;
+  const WETHAdress = await computePublishedContractAddress({
+    chain,
+    client,
+    contractId: "WETH9",
+  });
+  const extensions: (DeployTransactionResult | null)[] = await Promise.all([
+    getDeployedInfraContract({
+      chain,
+      client,
+      contractId: "WETH9",
+    }).then((c) =>
+      c ? null : ({ type: "infra", contractId: "WETH9" } as const),
+    ),
+    getDeployedInfraContract({
+      chain,
+      client,
+      contractId: "DirectListingsLogic",
+      constructorParams: { _nativeTokenWrapper: WETHAdress },
+    }).then((c) =>
+      c
+        ? null
+        : ({ type: "extension", contractId: "DirectListingsLogic" } as const),
+    ),
+    getDeployedInfraContract({
+      chain,
+      client,
+      contractId: "EnglishAuctionsLogic",
+      constructorParams: { _nativeTokenWrapper: WETHAdress },
+    }).then((c) =>
+      c
+        ? null
+        : ({ type: "extension", contractId: "EnglishAuctionsLogic" } as const),
+    ),
+    getDeployedInfraContract({
+      chain,
+      client,
+      contractId: "OffersLogic",
+    }).then((c) =>
+      c ? null : ({ type: "extension", contractId: "OffersLogic" } as const),
+    ),
+  ]);
+  // hacky assumption: if we need to deploy any of the extensions, we also need to deploy the implementation
+  const transactions = extensions.filter((e) => e !== null);
+  if (transactions.length) {
+    transactions.push({ type: "implementation", contractId: "MarketplaceV3" });
+  }
+  return transactions;
+}
+
+export async function getAllDefaultConstructorParamsForImplementation(args: {
+  chain: Chain;
+  client: ThirdwebClient;
+}) {
+  const { chain, client } = args;
+  const [forwarder, weth] = await Promise.all([
+    computePublishedContractAddress({
+      chain,
+      client,
+      contractId: "Forwarder",
+    }),
+    computePublishedContractAddress({
+      chain,
+      client,
+      contractId: "WETH9",
+    }),
+  ]);
+  return {
+    trustedForwarder: forwarder,
+    nativeTokenWrapper: weth,
+  };
 }

package/src/gas/fee-data.ts

@@ -138,6 +138,7 @@ export async function getDefaultGasOverrides(
 async function getDynamicFeeData(
   client: ThirdwebClient,
   chain: Chain,
+  percentMultiplier = 10,
 ): Promise<FeeData> {
   let maxFeePerGas: null | bigint = null;
   let maxPriorityFeePerGas_: null | bigint = null;
@@ -173,7 +174,10 @@ async function getDynamicFeeData(
   }
 
   // add 10% tip to maxPriorityFeePerGas for faster processing
-  maxPriorityFeePerGas_ = getPreferredPriorityFee(maxPriorityFeePerGas_);
+  maxPriorityFeePerGas_ = getPreferredPriorityFee(
+    maxPriorityFeePerGas_,
+    percentMultiplier,
+  );
   // eip-1559 formula, doubling the base fee ensures that the tx can be included in the next 6 blocks no matter how busy the network is
   // good article on the subject: https://www.blocknative.com/blog/eip-1559-fees
   maxFeePerGas = baseBlockFee * 2n + maxPriorityFeePerGas_;

package/src/pay/buyWithFiat/getQuote.ts

@@ -1,5 +1,6 @@
 import type { ThirdwebClient } from "../../client/client.js";
 import { getClientFetch } from "../../utils/fetch.js";
+import type { FiatProvider } from "../utils/commonTypes.js";
 import { getPayBuyWithFiatQuoteEndpoint } from "../utils/definitions.js";
 
 /**
@@ -82,6 +83,13 @@ export type GetBuyWithFiatQuoteParams = {
    * If erc20, will onramp native token + erc20
    */
   toGasAmountWei?: string;
+
+  /**
+   * Optional parameter to specify the preferred onramp provider.
+   *
+   * By default, we choose a recommended provider based on the location of the user, KYC status, and currency.
+   */
+  preferredProvider?: FiatProvider;
 };
 
 /**
@@ -303,6 +311,7 @@ export async function getBuyWithFiatQuote(
         purchaseData: params.purchaseData,
         fromAddress: params.fromAddress,
         toGasAmountWei: params.toGasAmountWei,
+        preferredProvider: params.preferredProvider,
       }),
     });
 

package/src/pay/utils/commonTypes.ts

@@ -16,3 +16,5 @@ export type PayOnChainTransactionDetails = {
   completedAt?: string; // ISO DATE
   explorerLink?: string;
 };
+
+export type FiatProvider = "STRIPE" | "TRANSAK" | "KADO";