thirdweb 5.55.0 → 5.55.1-nightly-b2a2c9784a33394dffbcd32bbd28b2c612a4e603-20240915000420

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/utils/abi/normalizeFunctionParams.ts

@@ -1,4 +1,5 @@
 import type { AbiConstructor, AbiFunction } from "abitype";
+import { parseAbiParams } from "../contract/parse-abi-params.js";
 
 export function normalizeFunctionParams(
   abiFunction: AbiFunction | AbiConstructor | undefined,
@@ -7,23 +8,27 @@ export function normalizeFunctionParams(
   if (!abiFunction) {
     return [];
   }
-  if (abiFunction.inputs?.length !== Object.keys(params).length) {
-    throw new Error(
-      `Expected ${abiFunction.inputs?.length || 0} parameters, but got ${Object.keys(params).length}`,
-    );
-  }
-  return abiFunction.inputs.map((input, index) => {
-    const value = input.name;
-    if (value === undefined) {
-      throw new Error(
-        `Missing named parameter for ${"name" in abiFunction ? abiFunction.name : "constructor"} at index ${index}`,
-      );
-    }
-    const valueWithoutUnderscore = value.replace(/^_+/, "");
-    const normalizedValue = params[value] ?? params[valueWithoutUnderscore]; // handle _name, _symbol, etc passed without underscore in the keys
-    if (normalizedValue === undefined) {
-      throw new Error(`Missing value for parameter ${value} at index ${index}`);
-    }
-    return normalizedValue;
-  });
+
+  return parseAbiParams(
+    abiFunction.inputs.map((i) => i.type),
+    abiFunction.inputs.map((input, index) => {
+      const value = input.name;
+      if (value === undefined) {
+        throw new Error(
+          `Missing named parameter for ${"name" in abiFunction ? abiFunction.name : "constructor"} at index ${index}`,
+        );
+      }
+      const valueWithoutUnderscore = value.replace(/^_+/, "");
+      const normalizedValue =
+        valueWithoutUnderscore in params
+          ? params[valueWithoutUnderscore]
+          : params[value]; // handle _name, _symbol, etc passed without underscore in the keys
+      if (normalizedValue === undefined) {
+        throw new Error(
+          `Missing value for parameter ${value} at index ${index}`,
+        );
+      }
+      return normalizedValue;
+    }),
+  );
 }

package/src/utils/any-evm/deploy-metadata.ts

@@ -48,6 +48,7 @@ export async function fetchDeployMetadata(
   return {
     ...rawMeta,
     ...parsedMeta,
+    version: rawMeta.version,
     bytecode: deployBytecode,
   };
 }
@@ -69,7 +70,7 @@ async function fetchAndParseCompilerMetadata(
       `Could not resolve metadata for contract at ${options.uri}`,
     );
   }
-  return formatCompilerMetadata(metadata);
+  return { ...metadata, ...formatCompilerMetadata(metadata) };
 }
 
 // types
@@ -87,7 +88,37 @@ type RawCompilerMetadata = {
 type ParsedCompilerMetadata = {
   name: string;
   abi: Abi;
-  metadata: Record<string, unknown>;
+  metadata: {
+    compiler: {
+      version: string;
+    };
+    language: string;
+    output: {
+      abi: Abi;
+      devdoc: Record<string, unknown>;
+      userdoc: Record<string, unknown>;
+    };
+    settings: {
+      compilationTarget: Record<string, unknown>;
+      evmVersion: string;
+      libraries: Record<string, string>;
+      optimizer: Record<string, unknown>;
+      remappings: string[];
+    };
+    sources: Record<
+      string,
+      { keccak256: string } & (
+        | {
+            content: string;
+          }
+        | {
+            urls: string[];
+            license?: string;
+          }
+      )
+    >;
+    [key: string]: unknown;
+  };
   info: {
     title?: string;
     author?: string;

package/src/utils/any-evm/get-init-bytecode-with-salt.ts

@@ -1,6 +1,6 @@
-import { type Hex, encodePacked } from "viem";
+import { encodePacked } from "viem/utils";
 import { ensureBytecodePrefix } from "../bytecode/prefix.js";
-import { uint8ArrayToHex } from "../encoding/hex.js";
+import { type Hex, uint8ArrayToHex } from "../encoding/hex.js";
 import { getSaltHash } from "./get-salt-hash.js";
 import { keccakId } from "./keccak-id.js";
 

package/src/utils/contract/parse-abi-params.ts

@@ -79,6 +79,9 @@ export function parseAbiParams(
       return value;
     }
     if (type.startsWith("uint") || type.startsWith("int")) {
+      if (typeof value === "bigint") {
+        return value;
+      }
       if (typeof value !== "string" && typeof value !== "number") {
         throw new Error(`Cannot convert type ${typeof value} to BigInt`);
       }

package/src/version.ts

@@ -1 +1 @@
-export const version = "5.55.0";
+export const version = "5.55.1-nightly-b2a2c9784a33394dffbcd32bbd28b2c612a4e603-20240915000420";