thirdweb 5.84.0 → 5.86.0-nightly-89beb3c5d356b17a60b85ed0a2242e779c4d56a2-20250121000314

package/src/ai/execute.ts

@@ -8,22 +8,46 @@ import { type Input, nebulaFetch } from "./common.js";
  *
  * @param input - The input for the transaction.
  * @returns The transaction hash.
- * @beta
+ * @beta This API is in early access and might change in the future.
  * @nebula
  *
  * @example
  * ```ts
  * import { Nebula } from "thirdweb/ai";
  *
+ * const wallet = createWallet("io.metamask");
+ * const account = wallet.connect({ client });
+ *
  * const result = await Nebula.execute({
- *   client: TEST_CLIENT,
- *   prompt: "send 0.0001 ETH to vitalik.eth",
- *   account: TEST_ACCOUNT_A,
- *   context: {
+ *   client,
+ *   account, // transactions will be sent from this account
+ *   message: "send 0.0001 ETH to vitalik.eth",
+ *   contextFilter: {
  *     chains: [sepolia],
  *   },
  * });
  * ```
+ *
+ * Multi message prompt:
+ *
+ * ```ts
+ * Nebula.execute({
+ *  client,
+ *  account,
+ *  messages: [
+ *    { role: "user", content: "What's the address of vitalik.eth" },
+ *    {
+ *      role: "assistant",
+ *      content:
+ *        "The address of vitalik.eth is 0xd8dA6BF26964aF8E437eEa5e3616511D7G3a3298",
+ *    },
+ *    { role: "user", content: "Send them 0.0001 ETH" },
+ *  ],
+ *  contextFilter: {
+ *    chains: [sepolia],
+ *  },
+ * });
+ * ```
  */
 export async function execute(
   input: Input & { account: Account },

package/src/analytics/track/pay.ts

@@ -17,6 +17,7 @@ export async function trackPayEvent(args: {
   toAmount?: string;
   chainId?: number;
   dstChainId?: number;
+  error?: string;
 }) {
   return track({
     client: args.client,
@@ -32,6 +33,7 @@ export async function trackPayEvent(args: {
       amountWei: args.fromAmount,
       dstTokenAddress: args.toToken,
       dstChainId: args.chainId,
+      errorCode: args.error,
     },
   });
 }

package/src/auth/verify-signature.test.ts

@@ -1,10 +1,11 @@
 import * as ox__Bytes from "ox/Bytes";
-import { describe, expect, it, test } from "vitest";
+import { beforeAll, describe, expect, it, test } from "vitest";
 import { FORKED_ETHEREUM_CHAIN } from "../../test/src/chains.js";
 import { TEST_CLIENT } from "../../test/src/test-clients.js";
 import { TEST_ACCOUNT_A } from "../../test/src/test-wallets.js";
 import { ethereum, mainnet } from "../chains/chain-definitions/ethereum.js";
 import { sepolia } from "../chains/chain-definitions/sepolia.js";
+import type { Account } from "../wallets/interfaces/wallet.js";
 import { smartWallet } from "../wallets/smart/smart-wallet.js";
 import {
   verifyContractWalletSignature,
@@ -64,7 +65,7 @@ describe("verifyEOASignature", () => {
 
 describe.runIf(process.env.TW_SECRET_KEY)(
   "verifyContractWalletSignature",
-  async () => {
+  () => {
     it("should verify a valid signature", async () => {
       expect(
         await verifySignature({
@@ -107,15 +108,19 @@ describe.runIf(process.env.TW_SECRET_KEY)(
 
 describe.runIf(process.env.TW_SECRET_KEY)(
   "verifyContractWalletSignature",
-  async () => {
+  () => {
     const message = "Hakuna matata";
     const wallet = smartWallet({
       chain: ethereum,
       gasless: true,
     });
-    const smartAccount = await wallet.connect({
-      client: TEST_CLIENT,
-      personalAccount: TEST_ACCOUNT_A,
+    let smartAccount: Account;
+
+    beforeAll(async () => {
+      smartAccount = await wallet.connect({
+        client: TEST_CLIENT,
+        personalAccount: TEST_ACCOUNT_A,
+      });
     });
 
     test("should verify a smart account signature", async () => {

package/src/chains/chain-definitions/mode.ts

@@ -0,0 +1,16 @@
+import { defineChain } from "../utils.js";
+
+/**
+ * @chain
+ */
+export const mode = /* @__PURE__ */ defineChain({
+  id: 919,
+  name: "Mode",
+  nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
+  blockExplorers: [
+    {
+      name: "Modescout",
+      url: "https://explorer.mode.network/",
+    },
+  ],
+});

package/src/contract/deployment/zksync/implementations.ts

@@ -14,6 +14,9 @@ export const ZKSYNC_IMPLEMENTATIONS: Record<number, Record<string, string>> = {
   [37111]: {
     MarketplaceV3: "0x56Abb6a3f25DCcdaDa106191053b1CC54C196DEE",
   },
+  [555271]: {
+    MarketplaceV3: "0x9EB0830B0b10010F2a53383517A7D0B75531Bb1b",
+  },
 };
 
 export const ZKSYNC_WETH: Record<number, string> = {
@@ -21,4 +24,5 @@ export const ZKSYNC_WETH: Record<number, string> = {
   [324]: "0x5AEa5775959fBC2557Cc8789bC1bf90A239D9a91",
   [11124]: "0x9EDCde0257F2386Ce177C3a7FCdd97787F0D841d",
   [37111]: "0xaA91D645D7a6C1aeaa5988e0547267B77d33fe16",
+  [555271]: "0xb0b8b267d44c64BA6dD1Daf442949887c85199f6",
 };

package/src/exports/chains.ts

@@ -77,4 +77,5 @@ export { celoAlfajoresTestnet } from "../chains/chain-definitions/celo-alfajores
 export { fraxtalTestnet } from "../chains/chain-definitions/fraxtal-testnet.js";
 export { metalL2Testnet } from "../chains/chain-definitions/metal-l2-testnet.js";
 export { modeTestnet } from "../chains/chain-definitions/mode-testnet.js";
+export { mode } from "../chains/chain-definitions/mode.js";
 export { soneiumMinato } from "../chains/chain-definitions/soneium-minato.js";

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

@@ -7,7 +7,7 @@ import { resolveL2Name } from "./resolve-l2-name.js";
 // skip this test suite if there is no secret key available to test with
 // TODO: remove reliance on secret key during unit tests entirely
 describe.runIf(process.env.TW_SECRET_KEY)("ENS:resolve-l2-name", () => {
-  it("should resolve Basename", async () => {
+  it.skip("should resolve Basename", async () => {
     const ens = await resolveL2Name({
       client: TEST_CLIENT,
       // myk.base.eth

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

@@ -42,8 +42,27 @@ export type DeployMarketplaceContractOptions = Prettify<
 >;
 
 /**
- * TODO not quite ready for public consumption yet
- * @internal
+ * Deploys a marketplace contract.
+ * @param options - The options for deploying the marketplace contract.
+ * 
+ * @extension MARKETPLACE
+ *
+ * @example
+ * ```ts
+ * import { deployMarketplaceContract } from "thirdweb/deploys";
+ *
+ * const address = await deployMarketplaceContract({
+      client,
+      chain,
+      account,
+      params: {
+        name: "MarketplaceV3",
+        description: "MarketplaceV3 deployed using thirdweb SDK",
+        platformFeeRecipient: "0x21d514c90ee4E4e4Cd16Ce9185BF01F0F1eE4A04",
+        platformFeeBps: 1000, 
+      },
+    });
+ * ```
  */
 export async function deployMarketplaceContract(
   options: DeployMarketplaceContractOptions,

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

@@ -50,7 +50,7 @@ export type DeployPublishedContractOptions = {
  * ```ts
  * import { deployPublishedContract } from "thirdweb/deploys";
  *
- * const address = await deployedPublishedContract({
+ * const address = await deployPublishedContract({
  *   client,
  *   chain,
  *   account,
@@ -68,7 +68,7 @@ export type DeployPublishedContractOptions = {
  * ```ts
  * import { deployPublishedContract } from "thirdweb/deploys";
  *
- * const address = await deployedPublishedContract({
+ * const address = await deployPublishedContract({
  *   client,
  *   chain,
  *   account,

package/src/gas/fee-data.ts

@@ -38,6 +38,7 @@ const FORCE_GAS_PRICE_CHAIN_IDS = [
   9768, // MainnetZ Testnet
   2442, // Polygon zkEVM Cardona Testnet
   1942999413, // Humanity Testnet
+  1952959480, // Lumia Testnet
 ];
 
 /**

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

@@ -1,4 +1,5 @@
 import { type UseMutationResult, useMutation } from "@tanstack/react-query";
+import { trackPayEvent } from "../../../../analytics/track/pay.js";
 import type { Chain } from "../../../../chains/types.js";
 import type { BuyWithCryptoStatus } from "../../../../pay/buyWithCrypto/getStatus.js";
 import type { BuyWithFiatStatus } from "../../../../pay/buyWithFiat/getStatus.js";
@@ -146,6 +147,13 @@ export function useSendTransactionCore(args: {
       }
 
       if (!showPayModal) {
+        trackPayEvent({
+          client: tx.client,
+          walletAddress: account.address,
+          walletType: wallet?.id,
+          dstChainId: tx.chain.id,
+          event: "pay_transaction_modal_disabled",
+        });
         return sendTransaction({
           transaction: tx,
           account,
@@ -174,7 +182,17 @@ export function useSendTransactionCore(args: {
               await Promise.all([
                 resolvePromisedValue(tx.value),
                 resolvePromisedValue(tx.erc20Value),
-                fetchBuySupportedDestinations(tx.client).catch(() => null),
+                fetchBuySupportedDestinations(tx.client).catch((err) => {
+                  trackPayEvent({
+                    client: tx.client,
+                    walletAddress: account.address,
+                    walletType: wallet?.id,
+                    dstChainId: tx.chain.id,
+                    event: "pay_transaction_modal_pay_api_error",
+                    error: err?.message,
+                  });
+                  return null;
+                }),
               ]);
 
             if (!supportedDestinations) {
@@ -198,6 +216,14 @@ export function useSendTransactionCore(args: {
                     ),
                 ))
             ) {
+              trackPayEvent({
+                client: tx.client,
+                walletAddress: account.address,
+                walletType: wallet?.id,
+                dstChainId: tx.chain.id,
+                event: "pay_transaction_modal_chain_token_not_supported",
+                error: `chain ${tx.chain.id} ${_erc20Value ? `/ token ${_erc20Value?.tokenAddress}` : ""} not supported`,
+              });
               // chain/token not supported, just send the tx
               sendTx();
               return;
@@ -241,6 +267,13 @@ export function useSendTransactionCore(args: {
                 resolveTx: resolve,
               });
             } else {
+              trackPayEvent({
+                client: tx.client,
+                walletAddress: account.address,
+                walletType: wallet?.id,
+                dstChainId: tx.chain.id,
+                event: "pay_transaction_modal_has_enough_funds",
+              });
               sendTx();
             }
           } catch (e) {

package/src/react/web/ui/prebuilt/NFT/description.tsx

@@ -95,6 +95,7 @@ export function NFTDescription({
     queryKey: [
       "_internal_nft_description_",
       contract.chain.id,
+      contract.address,
       tokenId.toString(),
       {
         resolver:

package/src/react/web/ui/prebuilt/NFT/media.test.tsx

@@ -7,6 +7,8 @@ import {
 import { getFunctionId } from "../../../../../utils/function-id.js";
 import { fetchNftMedia, getQueryKey } from "./media.js";
 
+const testContractAddress = "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48";
+
 describe.runIf(process.env.TW_SECRET_KEY)("NFTMedia", () => {
   it("fetchNftMedia should work with ERC721", async () => {
     const desc = await fetchNftMedia({
@@ -77,9 +79,16 @@ describe.runIf(process.env.TW_SECRET_KEY)("NFTMedia", () => {
   });
 
   it("getQueryKey should work without mediaResolver", () => {
-    expect(getQueryKey({ chainId: 1, tokenId: 1n })).toStrictEqual([
+    expect(
+      getQueryKey({
+        chainId: 1,
+        tokenId: 1n,
+        contractAddress: testContractAddress,
+      }),
+    ).toStrictEqual([
       "_internal_nft_media_",
       1,
+      testContractAddress,
       "1",
       {
         resolver: undefined,
@@ -90,6 +99,7 @@ describe.runIf(process.env.TW_SECRET_KEY)("NFTMedia", () => {
   it("getQueryKey should work with mediaResolver being an object", () => {
     expect(
       getQueryKey({
+        contractAddress: testContractAddress,
         chainId: 1,
         tokenId: 1n,
         mediaResolver: {
@@ -100,6 +110,7 @@ describe.runIf(process.env.TW_SECRET_KEY)("NFTMedia", () => {
     ).toStrictEqual([
       "_internal_nft_media_",
       1,
+      testContractAddress,
       "1",
       {
         resolver: {
@@ -119,12 +130,14 @@ describe.runIf(process.env.TW_SECRET_KEY)("NFTMedia", () => {
     expect(
       getQueryKey({
         chainId: 1,
+        contractAddress: testContractAddress,
         tokenId: 1n,
         mediaResolver: fn,
       }),
     ).toStrictEqual([
       "_internal_nft_media_",
       1,
+      testContractAddress,
       "1",
       {
         resolver: fnId,

package/src/react/web/ui/prebuilt/NFT/media.tsx

@@ -133,6 +133,7 @@ export function NFTMedia({
   const { contract, tokenId } = useNFTContext();
   const mediaQuery = useQuery({
     queryKey: getQueryKey({
+      contractAddress: contract.address,
       chainId: contract.chain.id,
       tokenId,
       mediaResolver,
@@ -164,6 +165,7 @@ export function NFTMedia({
  * @internal
  */
 export function getQueryKey(props: {
+  contractAddress: string;
   chainId: number;
   tokenId: bigint;
   mediaResolver?:
@@ -171,10 +173,11 @@ export function getQueryKey(props: {
     | (() => NFTMediaInfo)
     | (() => Promise<NFTMediaInfo>);
 }) {
-  const { chainId, tokenId, mediaResolver } = props;
+  const { chainId, tokenId, mediaResolver, contractAddress } = props;
   return [
     "_internal_nft_media_",
     chainId,
+    contractAddress,
     tokenId.toString(),
     {
       resolver:

package/src/react/web/ui/prebuilt/NFT/name.test.tsx

@@ -7,6 +7,8 @@ import {
 import { getFunctionId } from "../../../../../utils/function-id.js";
 import { fetchNftName, getQueryKey } from "./name.js";
 
+const testContractAddress = "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48";
+
 describe.runIf(process.env.TW_SECRET_KEY)("NFTName", () => {
   it("fetchNftName should work with ERC721", async () => {
     const desc = await fetchNftName({
@@ -61,9 +63,16 @@ describe.runIf(process.env.TW_SECRET_KEY)("NFTName", () => {
   });
 
   it("getQueryKey should work without nameResolver", () => {
-    expect(getQueryKey({ chainId: 1, tokenId: 1n })).toStrictEqual([
+    expect(
+      getQueryKey({
+        chainId: 1,
+        tokenId: 1n,
+        contractAddress: testContractAddress,
+      }),
+    ).toStrictEqual([
       "_internal_nft_name_",
       1,
+      testContractAddress,
       "1",
       { resolver: undefined },
     ]);
@@ -71,16 +80,38 @@ describe.runIf(process.env.TW_SECRET_KEY)("NFTName", () => {
 
   it("getQueryKey should work with nameResolver being a string", () => {
     expect(
-      getQueryKey({ chainId: 1, tokenId: 1n, nameResolver: "test" }),
-    ).toStrictEqual(["_internal_nft_name_", 1, "1", { resolver: "test" }]);
+      getQueryKey({
+        chainId: 1,
+        tokenId: 1n,
+        nameResolver: "test",
+        contractAddress: testContractAddress,
+      }),
+    ).toStrictEqual([
+      "_internal_nft_name_",
+      1,
+      testContractAddress,
+      "1",
+      { resolver: "test" },
+    ]);
   });
 
   it("getQueryKey should work with nameResolver being a () => string", () => {
     const fn = () => "test";
     const fnId = getFunctionId(fn);
     expect(
-      getQueryKey({ chainId: 1, tokenId: 1n, nameResolver: fn }),
-    ).toStrictEqual(["_internal_nft_name_", 1, "1", { resolver: fnId }]);
+      getQueryKey({
+        chainId: 1,
+        tokenId: 1n,
+        nameResolver: fn,
+        contractAddress: testContractAddress,
+      }),
+    ).toStrictEqual([
+      "_internal_nft_name_",
+      1,
+      testContractAddress,
+      "1",
+      { resolver: fnId },
+    ]);
   });
 
   it("getQueryKey should work with nameResolver being a async () => string", () => {
@@ -91,7 +122,14 @@ describe.runIf(process.env.TW_SECRET_KEY)("NFTName", () => {
         chainId: 1,
         tokenId: 1n,
         nameResolver: fn,
+        contractAddress: testContractAddress,
       }),
-    ).toStrictEqual(["_internal_nft_name_", 1, "1", { resolver: fnId }]);
+    ).toStrictEqual([
+      "_internal_nft_name_",
+      1,
+      testContractAddress,
+      "1",
+      { resolver: fnId },
+    ]);
   });
 });

package/src/react/web/ui/prebuilt/NFT/name.tsx

@@ -95,6 +95,7 @@ export function NFTName({
 
   const nameQuery = useQuery({
     queryKey: getQueryKey({
+      contractAddress: contract.address,
       chainId: contract.chain.id,
       tokenId,
       nameResolver,
@@ -118,14 +119,16 @@ export function NFTName({
  * @internal
  */
 export function getQueryKey(props: {
+  contractAddress: string;
   chainId: number;
   tokenId: bigint;
   nameResolver?: string | (() => string) | (() => Promise<string>);
 }) {
-  const { chainId, tokenId, nameResolver } = props;
+  const { chainId, tokenId, nameResolver, contractAddress } = props;
   return [
     "_internal_nft_name_",
     chainId,
+    contractAddress,
     tokenId.toString(),
     {
       resolver:

package/src/utils/extensions/drops/get-claim-params.ts

@@ -32,7 +32,6 @@ export type GetClaimParamsOptions = {
  * Get the claim parameters for a given drop
  * @param options - The options for getting the claim parameters
  * @returns The claim parameters
- * @extension ERC1155
  * @example
  * ```ts
  * import { getClaimParams } from "thirdweb/utils";
@@ -45,7 +44,7 @@ export type GetClaimParamsOptions = {
  *  tokenId: 0n,
  * });
  * ```
- * @extension COMMON
+ * @utils
  */
 export async function getClaimParams(options: GetClaimParamsOptions) {
   const cc: ClaimCondition = await (async () => {

package/src/version.ts

@@ -1 +1 @@
-export const version = "5.84.0";
+export const version = "5.86.0-nightly-89beb3c5d356b17a60b85ed0a2242e779c4d56a2-20250121000314";

package/src/wallets/connection/autoConnect.ts

@@ -27,6 +27,7 @@ import type { AutoConnectProps } from "./types.js";
  * @param props - The auto-connect configuration properties
  * @param props.wallets - Array of wallet instances to consider for auto-connection
  * @returns {boolean} a promise resolving to true or false depending on whether the auto connect function connected to a wallet or not
+ * @walletConnection
  */
 export const autoConnect = async (
   props: AutoConnectProps & {