thirdweb 5.34.4-nightly-b67519aecba8dba28dc87faea72e16d0ce6a4ab8-20240715000324 → 5.35.0-nightly-aadbd33e9d696bd7dd77561fa3f3a0a0fa7747f5-20240716082511

package/src/transaction/extract-error.ts

@@ -48,20 +48,20 @@ class TransactionError<abi extends Abi> extends Error {
   public chainId: number | undefined;
 
   constructor(reason: string, contract?: ThirdwebContract<abi>) {
-    super();
-    this.name = "TransactionError";
-    this.contractAddress = contract?.address;
-    this.chainId = contract?.chain?.id;
+    let message = reason;
     if (__DEV__ && contract) {
       // show more infor in dev
-      this.message = [
+      message = [
         reason,
         "",
-        `contract: ${this.contractAddress}`,
-        `chainId: ${this.chainId}`,
+        `contract: ${contract.address}`,
+        `chainId: ${contract.chain?.id}`,
       ].join("\n");
-    } else {
-      this.message = reason;
     }
+    super(message);
+    this.name = "TransactionError";
+    this.contractAddress = contract?.address;
+    this.chainId = contract?.chain?.id;
+    this.message = message;
   }
 }

package/src/utils/extensions/airdrop/fetch-proofs-erc1155.ts

@@ -10,6 +10,40 @@ import type {
   ShardedMerkleTreeInfo,
 } from "./types.js";
 
+/*
+ * Retrieves the claim merkle proof for the provided address.
+ * @param {Object} options
+ * @param {@link ThirdwebContract} contract - The ERC1155 airdrop contract
+ * @param {string} recipient - The address of the drop recipient
+ * @param {string} merkleRoot - The merkle root, found on the active claim condition
+ *
+ * @returns {Promise<ClaimProofERC20 | null>} A promise that resolves to the proof or null if the recipient is not in the allowlist
+ *
+ * @example
+ * ```ts
+ * import { fetchProofsERCC1155 } from "thirdweb/extensions/airdrop";
+ * import { getContract, defineChain } from "thirdweb";
+ *
+ * const TOKEN = getContracct({
+ *  client,
+ *  chain: defineChain(1),
+ *  address: "0x..."
+ * });
+ *
+ * const merkleRoot = await tokenMerkleRoot({
+ *  contract: TOKEN,
+ *  tokenAddress: TOKEN.address
+ * });
+ *
+ * const proof = await fetchProofsERC1155({
+ *  contract: TOKEN,
+ *  recipient: "0x...",
+ *  merkleRoot
+ * });
+ * ```
+ *
+ * @extension AIRDROP
+ */
 export async function fetchProofsERC1155(options: {
   contract: ThirdwebContract;
   recipient: string;

package/src/utils/extensions/airdrop/fetch-proofs-erc20.ts

@@ -11,7 +11,41 @@ import type {
   ShardedMerkleTreeInfo,
 } from "./types.js";
 
-export async function fetchProofsrERC20(options: {
+/*
+ * Retrieves the claim merkle proof for the provided address.
+ * @param {Object} options
+ * @param {@link ThirdwebContract} contract - The ERC20 airdrop contract
+ * @param {string} recipient - The address of the drop recipient
+ * @param {string} merkleRoot - The merkle root, found on the active claim condition
+ *
+ * @returns {Promise<ClaimProofERC20 | null>} A promise that resolves to the proof or null if the recipient is not in the allowlist
+ *
+ * @example
+ * ```ts
+ * import { fetchProofsERCC20 } from "thirdweb/extensions/airdrop";
+ * import { getContract, defineChain } from "thirdweb";
+ *
+ * const TOKEN = getContracct({
+ *  client,
+ *  chain: defineChain(1),
+ *  address: "0x..."
+ * });
+ *
+ * const merkleRoot = await tokenMerkleRoot({
+ *  contract: TOKEN,
+ *  tokenAddress: TOKEN.address
+ * });
+ *
+ * const proof = await fetchProofsERC20({
+ *  contract: TOKEN,
+ *  recipient: "0x...",
+ *  merkleRoot
+ * });
+ * ```
+ *
+ * @extension AIRDROP
+ */
+export async function fetchProofsERC20(options: {
   contract: ThirdwebContract;
   recipient: string;
   merkleRoot: string;

package/src/utils/extensions/airdrop/fetch-proofs-erc721.ts

@@ -10,6 +10,40 @@ import type {
   ShardedMerkleTreeInfo,
 } from "./types.js";
 
+/*
+ * Retrieves the claim merkle proof for the provided address.
+ * @param {Object} options
+ * @param {@link ThirdwebContract} contract - The ERC721 airdrop contract
+ * @param {string} recipient - The address of the drop recipient
+ * @param {string} merkleRoot - The merkle root, found on the active claim condition
+ *
+ * @returns {Promise<ClaimProofERC721 | null>} A promise that resolves to the proof or null if the recipient is not in the allowlist
+ *
+ * @example
+ * ```ts
+ * import { fetchProofsERC721 } from "thirdweb/extensions/airdrop";
+ * import { getContract, defineChain } from "thirdweb";
+ *
+ * const NFT = getContracct({
+ *  client,
+ *  chain: defineChain(1),
+ *  address: "0x..."
+ * });
+ *
+ * const merkleRoot = await tokenMerkleRoot({
+ *  contract: NFT,
+ *  tokenAddress: NFT.address
+ * });
+ *
+ * const proof = await fetchProofsERC721({
+ *  contract: NFT,
+ *  recipient: "0x...",
+ *  merkleRoot
+ * });
+ * ```
+ *
+ * @extension AIRDROP
+ */
 export async function fetchProofsERC721(options: {
   contract: ThirdwebContract;
   recipient: string;

package/src/version.ts

@@ -1 +1 @@
-export const version = "5.34.4-nightly-b67519aecba8dba28dc87faea72e16d0ce6a4ab8-20240715000324";
+export const version = "5.35.0-nightly-aadbd33e9d696bd7dd77561fa3f3a0a0fa7747f5-20240716082511";

package/src/wallets/coinbase/coinbaseMobileSDK.ts

@@ -1,5 +1,6 @@
-import { configure } from "@coinbase/wallet-mobile-sdk";
+import { configure, handleResponse } from "@coinbase/wallet-mobile-sdk";
 import type { ProviderInterface } from "@coinbase/wallet-sdk";
+import { Linking } from "react-native";
 import type { Chain } from "../../chains/types.js";
 import type { COINBASE } from "../constants.js";
 import type { CreateWalletArgs } from "../wallet-types.js";
@@ -13,11 +14,26 @@ export async function getCoinbaseMobileProvider(
   options?: CreateWalletArgs<typeof COINBASE>[1],
 ): Promise<ProviderInterface> {
   if (!_provider) {
+    const callbackURL = new URL(
+      options?.mobileConfig?.callbackURL || "https://thirdweb.com/wsegue",
+    );
     const mobileProvider: ProviderInterface = (await initMobileProvider({
       chain: options?.chains ? options.chains[0] : undefined,
       ...options?.mobileConfig,
     })) as unknown as ProviderInterface;
     _provider = mobileProvider;
+    Linking.addEventListener("url", ({ url }) => {
+      const incomingUrl = new URL(url);
+      if (
+        callbackURL &&
+        incomingUrl.host === callbackURL.host &&
+        incomingUrl.protocol === callbackURL.protocol &&
+        incomingUrl.hostname === callbackURL.hostname
+      ) {
+        // @ts-expect-error - Passing a URL object to handleResponse crashes the function
+        handleResponse(url);
+      }
+    });
     return mobileProvider;
   }
   return _provider;

package/src/wallets/in-app/web/lib/in-app-account.ts

@@ -307,23 +307,27 @@ export class IFrameWallet {
           parsedTypedData.types.EIP712Domain = undefined;
         }
         const domain = parsedTypedData.domain as TypedDataDefinition["domain"];
-        const chainId = domain?.chainId || 1;
+        const chainId = domain?.chainId;
+        const domainData = {
+          verifyingContract: domain?.verifyingContract,
+          name: domain?.name,
+          version: domain?.version,
+        };
+        // chain id can't be included if it wasn't explicitly specified
+        if (chainId) {
+          (domainData as Record<string, unknown>).chainId = chainId;
+        }
 
         const { signedTypedData } =
           await querier.call<SignedTypedDataReturnType>({
             procedureName: "signTypedDataV4",
             params: {
-              domain: {
-                chainId: chainId,
-                verifyingContract: domain?.verifyingContract,
-                name: domain?.name,
-                version: domain?.version,
-              },
+              domain: domainData,
               types:
                 parsedTypedData.types as SignerProcedureTypes["signTypedDataV4"]["types"],
               message:
                 parsedTypedData.message as SignerProcedureTypes["signTypedDataV4"]["message"],
-              chainId,
+              chainId: chainId || 1,
               partnerId,
               rpcEndpoint: `https://${chainId}.rpc.thirdweb.com`, // TODO (ew) shouldnt be needed
             },