thirdweb 5.84.0-nightly-0fdfb8aa778a344aa847503f668e48feb5f72548-20250115000312 → 5.85.0

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-nightly-0fdfb8aa778a344aa847503f668e48feb5f72548-20250115000312";
+export const version = "5.85.0";

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 & {

package/src/wallets/engine/engine-account.test.ts

@@ -0,0 +1,69 @@
+import { describe, expect, it } from "vitest";
+import { TEST_CLIENT } from "../../../test/src/test-clients.js";
+import { TEST_ACCOUNT_B } from "../../../test/src/test-wallets.js";
+import { typedData } from "../../../test/src/typed-data.js";
+import { sepolia } from "../../chains/chain-definitions/sepolia.js";
+import { getContract } from "../../contract/contract.js";
+import { claimTo } from "../../extensions/erc1155/drops/write/claimTo.js";
+import { sendTransaction } from "../../transaction/actions/send-transaction.js";
+import { engineAccount } from "./index.js";
+
+describe.runIf(
+  process.env.TW_SECRET_KEY &&
+    process.env.ENGINE_URL &&
+    process.env.ENGINE_AUTH_TOKEN &&
+    process.env.ENGINE_WALLET_ADDRESS,
+)("Engine", () => {
+  const engineAcc = engineAccount({
+    engineUrl: process.env.ENGINE_URL as string,
+    authToken: process.env.ENGINE_AUTH_TOKEN as string,
+    walletAddress: process.env.ENGINE_WALLET_ADDRESS as string,
+    chain: sepolia,
+  });
+
+  it("should sign a message", async () => {
+    const signature = await engineAcc.signMessage({
+      message: "hello",
+    });
+    expect(signature).toBeDefined();
+  });
+
+  it("should sign typed data", async () => {
+    const signature = await engineAcc.signTypedData({
+      ...typedData.basic,
+    });
+    expect(signature).toBeDefined();
+  });
+
+  it("should send a tx", async () => {
+    const tx = await sendTransaction({
+      account: engineAcc,
+      transaction: {
+        client: TEST_CLIENT,
+        chain: sepolia,
+        to: TEST_ACCOUNT_B.address,
+        value: 0n,
+      },
+    });
+    expect(tx).toBeDefined();
+  });
+
+  it("should send a extension tx", async () => {
+    const nftContract = getContract({
+      client: TEST_CLIENT,
+      chain: sepolia,
+      address: "0xe2cb0eb5147b42095c2FfA6F7ec953bb0bE347D8",
+    });
+    const claimTx = claimTo({
+      contract: nftContract,
+      to: TEST_ACCOUNT_B.address,
+      tokenId: 0n,
+      quantity: 1n,
+    });
+    const tx = await sendTransaction({
+      account: engineAcc,
+      transaction: claimTx,
+    });
+    expect(tx).toBeDefined();
+  });
+});

package/src/wallets/engine/index.ts

@@ -0,0 +1,198 @@
+import type { Chain } from "../../chains/types.js";
+import type { Hex } from "../../utils/encoding/hex.js";
+import { toHex } from "../../utils/encoding/hex.js";
+import type { Account, SendTransactionOption } from "../interfaces/wallet.js";
+
+/**
+ * Options for creating an engine account.
+ */
+export type EngineAccountOptions = {
+  /**
+   * The URL of your engine instance.
+   */
+  engineUrl: string;
+  /**
+   * The auth token to use with the engine instance.
+   */
+  authToken: string;
+  /**
+   * The backend wallet to use for sending transactions inside engine.
+   */
+  walletAddress: string;
+  /**
+   * The chain to use for signing messages and typed data (smart backend wallet only).
+   */
+  chain?: Chain;
+};
+
+/**
+ * Creates an account that uses your engine backend wallet for sending transactions and signing messages.
+ *
+ * @param options - The options for the engine account.
+ * @returns An account that uses your engine backend wallet.
+ *
+ * @beta
+ * @wallet
+ *
+ * @example
+ * ```ts
+ * import { engineAccount } from "thirdweb/wallets/engine";
+ *
+ * const engineAcc = engineAccount({
+ *   engineUrl: "https://engine.thirdweb.com",
+ *   authToken: "your-auth-token",
+ *   walletAddress: "0x...",
+ * });
+ *
+ * // then use the account as you would any other account
+ * const transaction = claimTo({
+ *   contract,
+ *   to: "0x...",
+ *   quantity: 1n,
+ * });
+ * const result = await sendTransaction({ transaction, account: engineAcc });
+ * console.log("Transaction sent:", result.transactionHash);
+ * ```
+ */
+export function engineAccount(options: EngineAccountOptions): Account {
+  const { engineUrl, authToken, walletAddress, chain } = options;
+
+  // these are shared across all methods
+  const headers: HeadersInit = {
+    "x-backend-wallet-address": walletAddress,
+    Authorization: `Bearer ${authToken}`,
+    "Content-Type": "application/json",
+  };
+
+  return {
+    address: walletAddress,
+    sendTransaction: async (transaction: SendTransactionOption) => {
+      const ENGINE_URL = new URL(engineUrl);
+      ENGINE_URL.pathname = `/backend-wallet/${transaction.chainId}/send-transaction`;
+
+      const engineData: Record<string, string | undefined> = {
+        // add to address if we have it (is optional to pass to engine)
+        toAddress: transaction.to || undefined,
+        // engine wants a hex string here so we serialize it
+        data: transaction.data || "0x",
+        // value is always required
+        value: toHex(transaction.value ?? 0n),
+      };
+
+      // TODO: gas overrides etc?
+
+      const engineRes = await fetch(ENGINE_URL, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(engineData),
+      });
+      if (!engineRes.ok) {
+        const body = await engineRes.text();
+        throw new Error(
+          `Engine request failed with status ${engineRes.status} - ${body}`,
+        );
+      }
+      const engineJson = (await engineRes.json()) as {
+        result: {
+          queueId: string;
+        };
+      };
+
+      // wait for the queueId to be processed
+      ENGINE_URL.pathname = `/transaction/status/${engineJson.result.queueId}`;
+      const startTime = Date.now();
+      const TIMEOUT_IN_MS = 5 * 60 * 1000; // 5 minutes in milliseconds
+
+      while (Date.now() - startTime < TIMEOUT_IN_MS) {
+        const queueRes = await fetch(ENGINE_URL, {
+          method: "GET",
+          headers,
+        });
+        if (!queueRes.ok) {
+          const body = await queueRes.text();
+          throw new Error(
+            `Engine request failed with status ${queueRes.status} - ${body}`,
+          );
+        }
+        const queueJSON = (await queueRes.json()) as {
+          result: {
+            status: "queued" | "mined" | "cancelled" | "errored";
+            transactionHash: Hex | null;
+            userOpHash: Hex | null;
+            errorMessage: string | null;
+          };
+        };
+
+        if (
+          queueJSON.result.status === "errored" &&
+          queueJSON.result.errorMessage
+        ) {
+          throw new Error(queueJSON.result.errorMessage);
+        }
+        if (queueJSON.result.transactionHash) {
+          return {
+            transactionHash: queueJSON.result.transactionHash,
+          };
+        }
+        // wait 1s before checking again
+        await new Promise((resolve) => setTimeout(resolve, 1000));
+      }
+      throw new Error("Transaction timed out after 5 minutes");
+    },
+    signMessage: async ({ message }) => {
+      let engineMessage: string | Hex;
+      let isBytes = false;
+      if (typeof message === "string") {
+        engineMessage = message;
+      } else {
+        engineMessage = toHex(message.raw);
+        isBytes = true;
+      }
+
+      const ENGINE_URL = new URL(engineUrl);
+      ENGINE_URL.pathname = "/backend-wallet/sign-message";
+      const engineRes = await fetch(ENGINE_URL, {
+        method: "POST",
+        headers,
+        body: JSON.stringify({
+          message: engineMessage,
+          isBytes,
+          chainId: chain?.id,
+        }),
+      });
+      if (!engineRes.ok) {
+        const body = await engineRes.text();
+        throw new Error(
+          `Engine request failed with status ${engineRes.status} - ${body}`,
+        );
+      }
+      const engineJson = (await engineRes.json()) as {
+        result: Hex;
+      };
+      return engineJson.result;
+    },
+    signTypedData: async (_typedData) => {
+      const ENGINE_URL = new URL(engineUrl);
+      ENGINE_URL.pathname = "/backend-wallet/sign-typed-data";
+      const engineRes = await fetch(ENGINE_URL, {
+        method: "POST",
+        headers,
+        body: JSON.stringify({
+          domain: _typedData.domain,
+          types: _typedData.types,
+          value: _typedData.message,
+        }),
+      });
+      if (!engineRes.ok) {
+        engineRes.body?.cancel();
+        throw new Error(
+          `Engine request failed with status ${engineRes.status}`,
+        );
+      }
+      const engineJson = (await engineRes.json()) as {
+        result: Hex;
+      };
+      return engineJson.result;
+    },
+  };
+}

package/src/wallets/smart/lib/signing.ts

@@ -288,7 +288,7 @@ async function checkFor712Factory({
  * });
  * ```
  *
- * @wallets
+ * @wallet
  */
 export async function deploySmartAccount(args: {
   smartAccount: Account;