thirdweb 5.60.0-nightly-e552fda9e5364ce6e5d36f99eebc7d69b082f3d7-20241001000401 → 5.60.1-nightly-79c50cb311ffef769b7bdba3006ae67ddf257caf-20241002000323

package/src/extensions/erc20/drops/write/claimTo.ts

@@ -20,6 +20,8 @@ export type ClaimToParams = {
  * @param options - The options for the transaction
  * @extension ERC20
  * @example
+ *
+ * ### Basic usage
  * ```ts
  * import { claimTo } from "thirdweb/extensions/erc20";
  * import { sendTransaction } from "thirdweb";
@@ -32,6 +34,17 @@ export type ClaimToParams = {
  *
  * await sendTransaction({ transaction, account });
  * ```
+ *
+ * ### For Drops with allowlists
+ * You need to specify the claimer address as the `from` param to avoid any issue with the allowlist
+ * ```ts
+ * const transaction = claimTo({
+ *   contract,
+ *   to: "0x...",
+ *   quantity: 100n,
+ *   from: "0x...", // address of the one claiming
+ * });
+ * ```
  * @throws If no claim condition is set
  * @returns A promise that resolves with the submitted transaction hash.
  */

package/src/extensions/erc721/drops/write/claimTo.ts

@@ -23,6 +23,8 @@ export type ClaimToParams = {
  * @param options - The options for the transaction
  * @extension ERC721
  * @example
+ *
+ * ### Basic usage
  * ```ts
  * import { claimTo } from "thirdweb/extensions/erc721";
  * import { sendTransaction } from "thirdweb";
@@ -35,6 +37,17 @@ export type ClaimToParams = {
  *
  * await sendTransaction({ transaction, account });
  * ```
+ *
+ * ### For Drops with allowlists
+ * You need to specify the claimer address as the `from` param to avoid any issue with the allowlist
+ * ```ts
+ * const transaction = claimTo({
+ *   contract,
+ *   to: "0x...",
+ *   quantity: 1n,
+ *   from: "0x...", // address of the one claiming
+ * });
+ * ```
  * @throws If no claim condition is set
  * @returns A promise that resolves with the submitted transaction hash.
  */

package/src/extensions/pack/createNewPack.test.ts

@@ -26,182 +26,191 @@ const account = TEST_ACCOUNT_A;
 const client = TEST_CLIENT;
 const chain = ANVIL_CHAIN;
 
-describe.runIf(process.env.TW_SECRET_KEY)("createPack", () => {
-  it("should create a Pack and open it to receive rewards", async () => {
-    const packAddress = await deployPackContract({
-      account,
-      client,
-      chain,
-      params: {
-        name: "pack-contract",
-      },
-    });
-
-    const packContract = getContract({
-      address: packAddress,
-      chain,
-      client,
-    });
-
-    const erc20Address = await deployERC20Contract({
-      client: TEST_CLIENT,
-      chain: ANVIL_CHAIN,
-      account: TEST_ACCOUNT_A,
-      type: "TokenERC20",
-      params: {
-        name: "Token",
-        contractURI: TEST_CONTRACT_URI,
-      },
-    });
-
-    const erc20Contract = getContract({ address: erc20Address, chain, client });
-
-    const erc721Address = await deployERC721Contract({
-      client: TEST_CLIENT,
-      chain: ANVIL_CHAIN,
-      account: TEST_ACCOUNT_A,
-      type: "TokenERC721",
-      params: {
-        name: "NFTCollection",
-        contractURI: TEST_CONTRACT_URI,
-      },
-    });
-
-    const erc721Contract = getContract({
-      address: erc721Address,
-      chain,
-      client,
-    });
-    // Mint some ERC20 tokens
-    await sendAndConfirmTransaction({
-      transaction: mintToERC20({
-        contract: erc20Contract,
-        to: account.address,
-        amount: "100",
-      }),
-      account,
-    });
-
-    // Set allowance for Pack contract
-    await sendAndConfirmTransaction({
-      transaction: approve({
-        contract: erc20Contract,
-        amount: "1000000000000000",
-        spender: packContract.address,
-      }),
-      account,
-    });
+// TODO Make this test works!
+describe.skip("createNewPack", () => {
+  describe.runIf(process.env.TW_SECRET_KEY)("createPack", () => {
+    it("should create a Pack and open it to receive rewards", async () => {
+      const packAddress = await deployPackContract({
+        account,
+        client,
+        chain,
+        params: {
+          name: "pack-contract",
+        },
+      });
 
-    // Mint some ERC721 tokens
-    await sendAndConfirmTransaction({
-      transaction: mintToERC721({
-        contract: erc721Contract,
-        to: account.address,
-        nft: { name: "token #0" },
-      }),
-      account,
-    });
+      const packContract = getContract({
+        address: packAddress,
+        chain,
+        client,
+      });
+
+      const erc20Address = await deployERC20Contract({
+        client: TEST_CLIENT,
+        chain: ANVIL_CHAIN,
+        account: TEST_ACCOUNT_A,
+        type: "TokenERC20",
+        params: {
+          name: "Token",
+          contractURI: TEST_CONTRACT_URI,
+        },
+      });
 
-    // set erc721 approval
-    await sendAndConfirmTransaction({
-      transaction: setApprovalForAll({
-        contract: erc721Contract,
-        approved: true,
-        operator: packContract.address,
-      }),
-      account,
-    });
+      const erc20Contract = getContract({
+        address: erc20Address,
+        chain,
+        client,
+      });
+
+      const erc721Address = await deployERC721Contract({
+        client: TEST_CLIENT,
+        chain: ANVIL_CHAIN,
+        account: TEST_ACCOUNT_A,
+        type: "TokenERC721",
+        params: {
+          name: "NFTCollection",
+          contractURI: TEST_CONTRACT_URI,
+        },
+      });
 
-    // Create pack
-    await sendAndConfirmTransaction({
-      transaction: createNewPack({
-        contract: packContract,
-        erc20Rewards: [
+      const erc721Contract = getContract({
+        address: erc721Address,
+        chain,
+        client,
+      });
+      // Mint some ERC20 tokens
+      await sendAndConfirmTransaction({
+        transaction: mintToERC20({
+          contract: erc20Contract,
+          to: account.address,
+          amount: "100",
+        }),
+        account,
+      });
+
+      // Set allowance for Pack contract
+      await sendAndConfirmTransaction({
+        transaction: approve({
+          contract: erc20Contract,
+          amount: "1000000000000000",
+          spender: packContract.address,
+        }),
+        account,
+      });
+
+      // Mint some ERC721 tokens
+      await sendAndConfirmTransaction({
+        transaction: mintToERC721({
+          contract: erc721Contract,
+          to: account.address,
+          nft: { name: "token #0" },
+        }),
+        account,
+      });
+
+      // set erc721 approval
+      await sendAndConfirmTransaction({
+        transaction: setApprovalForAll({
+          contract: erc721Contract,
+          approved: true,
+          operator: packContract.address,
+        }),
+        account,
+      });
+
+      // Create pack
+      await sendAndConfirmTransaction({
+        transaction: createNewPack({
+          contract: packContract,
+          erc20Rewards: [
+            {
+              contractAddress: erc20Contract.address,
+              totalRewards: 1,
+              quantityPerReward: 1,
+            },
+          ],
+          erc721Rewards: [
+            { contractAddress: erc721Contract.address, tokenId: 0n },
+          ],
+          client,
+          packMetadata: {
+            name: "Pack #0",
+          },
+          recipient: account.address,
+          tokenOwner: account.address,
+          openStartTimestamp: new Date(),
+          amountDistributedPerOpen: 1n,
+        }),
+        account,
+      });
+
+      // Read the info of the new Pack
+      const [
+        packContent,
+        tokenCountOfBundle,
+        bundleUri,
+        erc20BalanceAfterCreatePack,
+        erc721BalanceAfterCreatePack,
+      ] = await Promise.all([
+        getPackContents({ contract: packContract, packId: 0n }),
+        getTokenCountOfBundle({ contract: packContract, bundleId: 0n }),
+        getUriOfBundle({ contract: packContract, bundleId: 0n }),
+        balanceOfERC20({ contract: erc20Contract, address: account.address }),
+        balanceOfERC721({ contract: erc721Contract, owner: account.address }),
+      ]);
+
+      // After this, the account should have 99 ERC20 tokens, and 0 (zero) ERC721 token
+      expect(erc20BalanceAfterCreatePack).toBe(99n * 10n ** 18n);
+      expect(erc721BalanceAfterCreatePack).toBe(0n);
+
+      // Make sure the content is correct
+      expect(packContent).toStrictEqual([
+        [
           {
-            contractAddress: erc20Contract.address,
-            totalRewards: 1,
-            quantityPerReward: 1,
+            assetContract: erc20Contract.address,
+            tokenType: 0,
+            tokenId: 0n,
+            totalAmount: 1000000000000000000n,
+          },
+          {
+            assetContract: erc721Contract.address,
+            tokenType: 1,
+            tokenId: 0n,
+            totalAmount: 1n,
           },
         ],
-        erc721Rewards: [
-          { contractAddress: erc721Contract.address, tokenId: 0n },
-        ],
-        client,
-        packMetadata: {
-          name: "Pack #0",
-        },
-        recipient: account.address,
-        tokenOwner: account.address,
-        openStartTimestamp: new Date(),
-        amountDistributedPerOpen: 1n,
-      }),
-      account,
-    });
-
-    // Read the info of the new Pack
-    const [
-      packContent,
-      tokenCountOfBundle,
-      bundleUri,
-      erc20BalanceAfterCreatePack,
-      erc721BalanceAfterCreatePack,
-    ] = await Promise.all([
-      getPackContents({ contract: packContract, packId: 0n }),
-      getTokenCountOfBundle({ contract: packContract, bundleId: 0n }),
-      getUriOfBundle({ contract: packContract, bundleId: 0n }),
-      balanceOfERC20({ contract: erc20Contract, address: account.address }),
-      balanceOfERC721({ contract: erc721Contract, owner: account.address }),
-    ]);
-
-    // After this, the account should have 99 ERC20 tokens, and 0 (zero) ERC721 token
-    expect(erc20BalanceAfterCreatePack).toBe(99n * 10n ** 18n);
-    expect(erc721BalanceAfterCreatePack).toBe(0n);
-
-    // Make sure the content is correct
-    expect(packContent).toStrictEqual([
-      [
-        {
-          assetContract: erc20Contract.address,
-          tokenType: 0,
-          tokenId: 0n,
-          totalAmount: 1000000000000000000n,
-        },
-        {
-          assetContract: erc721Contract.address,
-          tokenType: 1,
-          tokenId: 0n,
-          totalAmount: 1n,
-        },
-      ],
-      [1000000000000000000n, 1n],
-    ]);
-    expect(tokenCountOfBundle).toBe(2n);
-
-    // Make sure the Pack metadata is correct
-    expect(bundleUri).toBeDefined();
-    const metadata = await (await download({ client, uri: bundleUri })).json();
-    expect(metadata?.name).toBe("Pack #0");
-
-    // Make sure you can open the Pack, since the open-date was set to "now"
-    await sendAndConfirmTransaction({
-      account,
-      transaction: openPack({
-        contract: packContract,
-        packId: 0n,
-        amountToOpen: 1n,
-      }),
+        [1000000000000000000n, 1n],
+      ]);
+      expect(tokenCountOfBundle).toBe(2n);
+
+      // Make sure the Pack metadata is correct
+      expect(bundleUri).toBeDefined();
+      const metadata = await (
+        await download({ client, uri: bundleUri })
+      ).json();
+      expect(metadata?.name).toBe("Pack #0");
+
+      // Make sure you can open the Pack, since the open-date was set to "now"
+      await sendAndConfirmTransaction({
+        account,
+        transaction: openPack({
+          contract: packContract,
+          packId: 0n,
+          amountToOpen: 1n,
+        }),
+      });
+
+      const [erc20Balance, erc721Owner] = await Promise.all([
+        balanceOfERC20({ contract: erc20Contract, address: account.address }),
+        ownerOf({ contract: erc721Contract, tokenId: 0n }),
+      ]);
+
+      // Since opening a Pack gives "random" rewards, in this case we can check if
+      // the recipient received either 1. <one ERC20 token>, or 2. <one ERC721 token>
+      expect(
+        erc20Balance === 100n * 10n ** 18n ||
+          erc721Owner.toLowerCase() === account.address.toLowerCase(),
+      ).toBe(true);
     });
-
-    const [erc20Balance, erc721Owner] = await Promise.all([
-      balanceOfERC20({ contract: erc20Contract, address: account.address }),
-      ownerOf({ contract: erc721Contract, tokenId: 0n }),
-    ]);
-
-    // Since opening a Pack gives "random" rewards, in this case we can check if
-    // the recipient received either 1. <one ERC20 token>, or 2. <one ERC721 token>
-    expect(
-      erc20Balance === 100n * 10n ** 18n ||
-        erc721Owner.toLowerCase() === account.address.toLowerCase(),
-    ).toBe(true);
   });
 });

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

@@ -267,7 +267,7 @@ async function directDeploy(options: {
   const { account, client, chain, compilerMetadata, contractParams, salt } =
     options;
 
-  if (isZkSyncChain(chain)) {
+  if (await isZkSyncChain(chain)) {
     return zkDeployContract({
       account,
       client,

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

@@ -43,6 +43,8 @@ export async function getRequiredTransactions(
     modules = [],
   } = options;
 
+  const isZkSync = await isZkSyncChain(chain);
+
   if (deployMetadata?.deployType === "autoFactory") {
     const results: (
       | DeployTransactionResult
@@ -53,7 +55,7 @@ export async function getRequiredTransactions(
         chain,
         client,
       }).then((c) =>
-        c || isZkSyncChain(chain)
+        c || isZkSync
           ? null
           : ({ type: "infra", contractId: "Create2Factory" } as const),
       ),
@@ -62,7 +64,7 @@ export async function getRequiredTransactions(
         client,
         contractId: "Forwarder",
       }).then((c) =>
-        c || isZkSyncChain(chain)
+        c || isZkSync
           ? null
           : ({ type: "infra", contractId: "Forwarder" } as const),
       ),
@@ -78,7 +80,7 @@ export async function getRequiredTransactions(
           }),
         },
       }).then((c) =>
-        c || isZkSyncChain(chain)
+        c || isZkSync
           ? null
           : ({ type: "infra", contractId: "TWCloneFactory" } as const),
       ),

package/src/react/web/ui/ConnectWallet/screens/Buy/BuyScreen.tsx

@@ -357,6 +357,7 @@ function BuyScreenContent(props: BuyScreenContentProps) {
         tokenAmount={tokenAmount}
         receiverAddress={receiverAddress}
         transactionMode={props.payOptions.mode === "transaction"}
+        payOptions={payOptions}
         isEmbed={props.isEmbed}
         onDone={onDone}
         onTryAgain={() => {

package/src/react/web/ui/ConnectWallet/screens/Buy/swap/TransferConfirmationScreen.tsx

@@ -11,6 +11,7 @@ import { sendTransaction } from "../../../../../../../transaction/actions/send-t
 import { prepareTransaction } from "../../../../../../../transaction/prepare-transaction.js";
 import { toWei } from "../../../../../../../utils/units.js";
 import { iconSize } from "../../../../../../core/design-system/index.js";
+import type { PayUIOptions } from "../../../../../../core/hooks/connection/ConnectButtonProps.js";
 import { useChainSymbol } from "../../../../../../core/hooks/others/useChainQuery.js";
 import { Spacer } from "../../../../components/Spacer.js";
 import { Spinner } from "../../../../components/Spinner.js";
@@ -26,7 +27,7 @@ import { TokenInfoRow } from "../pay-transactions/TokenInfoRow.js";
 import type { PayerInfo } from "../types.js";
 import { ConnectorLine } from "./ConfirmationScreen.js";
 
-type TrasnferConfirmationScreenProps = {
+type TransferConfirmationScreenProps = {
   title: string;
   onBack?: () => void;
   setTransactionHash: (txHash: string) => void;
@@ -38,10 +39,11 @@ type TrasnferConfirmationScreenProps = {
   token: ERC20OrNativeToken;
   tokenAmount: string;
   transactionMode?: boolean;
+  payOptions?: PayUIOptions;
 };
 
 export function TransferConfirmationScreen(
-  props: TrasnferConfirmationScreenProps,
+  props: TransferConfirmationScreenProps,
 ) {
   const {
     title,
@@ -55,6 +57,7 @@ export function TransferConfirmationScreen(
     tokenAmount,
     transactionMode,
     setTransactionHash,
+    payOptions,
   } = props;
   const [step, setStep] = useState<"approve" | "transfer" | "execute">(
     "transfer",
@@ -242,7 +245,7 @@ export function TransferConfirmationScreen(
                     ? NATIVE_TOKEN_ADDRESS
                     : token.address,
                   amount: tokenAmount,
-                  purchaseData: undefined, // TODO (pay): add purchase data
+                  purchaseData: payOptions?.purchaseData,
                 });
 
                 if (transferResponse.approval) {

package/src/react/web/ui/ConnectWallet/screens/Buy/swap/TransferFlow.tsx

@@ -2,12 +2,13 @@ import { useState } from "react";
 import type { Chain } from "../../../../../../../chains/types.js";
 import type { ThirdwebClient } from "../../../../../../../client/client.js";
 import type { BuyWithCryptoStatus } from "../../../../../../../pay/buyWithCrypto/getStatus.js";
+import type { PayUIOptions } from "../../../../../../core/hooks/connection/ConnectButtonProps.js";
 import type { ERC20OrNativeToken } from "../../nativeToken.js";
 import type { PayerInfo } from "../types.js";
 import { SwapStatusScreen } from "./SwapStatusScreen.js";
 import { TransferConfirmationScreen } from "./TransferConfirmationScreen.js";
 
-type TrasnferFlowProps = {
+type TransferFlowProps = {
   title: string;
   onBack?: () => void;
   payer: PayerInfo;
@@ -21,9 +22,10 @@ type TrasnferFlowProps = {
   token: ERC20OrNativeToken;
   tokenAmount: string;
   transactionMode?: boolean;
+  payOptions?: PayUIOptions;
 };
 
-export function TransferFlow(props: TrasnferFlowProps) {
+export function TransferFlow(props: TransferFlowProps) {
   const [transferTxHash, setTransferTxHash] = useState<string | undefined>();
 
   if (transferTxHash) {

package/src/utils/any-evm/zksync/isZkSyncChain.ts

@@ -1,12 +1,44 @@
 import type { Chain } from "../../../chains/types.js";
+import { withCache } from "../../promise/withCache.js";
 
-export function isZkSyncChain(chain: Chain) {
-  return (
-    chain.id === 324 ||
-    chain.id === 300 ||
-    chain.id === 302 ||
-    chain.id === 11124 ||
-    chain.id === 282 || // cronos zkevm testnet
-    chain.id === 388 // cronos zkevm mainnet
+export async function isZkSyncChain(chain: Chain) {
+  if (chain.id === 1337 || chain.id === 31337) {
+    return false;
+  }
+
+  const stack = await getChainStack(chain.id).catch(() => {
+    // fall back to checking against these zksync chain-ids
+    if (
+      chain.id === 324 ||
+      chain.id === 300 ||
+      chain.id === 302 ||
+      chain.id === 11124 ||
+      chain.id === 282 || // cronos zkevm testnet
+      chain.id === 388 // cronos zkevm mainnet
+    ) {
+      return "zksync-stack";
+    }
+
+    return "";
+  });
+
+  return stack === "zksync-stack";
+}
+
+async function getChainStack(chainId: number): Promise<string> {
+  return withCache(
+    async () => {
+      const res = await fetch(`https://${chainId}.rpc.thirdweb.com/stack`);
+
+      if (!res.ok) {
+        res.body?.cancel();
+        throw new Error(`Error fetching stack for ${chainId}`);
+      }
+
+      const data = await res.json();
+
+      return data.stack;
+    },
+    { cacheKey: `stack:${chainId}`, cacheTime: 24 * 60 * 60 * 1000 },
   );
 }

package/src/version.ts

@@ -1 +1 @@
-export const version = "5.60.0-nightly-e552fda9e5364ce6e5d36f99eebc7d69b082f3d7-20241001000401";
+export const version = "5.60.1-nightly-79c50cb311ffef769b7bdba3006ae67ddf257caf-20241002000323";

package/src/wallets/coinbase/coinbaseWebSDK.ts

@@ -3,6 +3,7 @@ import type { Address } from "abitype";
 import {
   type SignTypedDataParameters,
   getTypesForEIP712Domain,
+  isHex,
   serializeTypedData,
   validateTypedData,
 } from "viem";
@@ -314,10 +315,14 @@ function createAccount(provider: ProviderInterface, _address: string) {
         return message.raw;
       })();
 
-      return await provider.request({
+      const res = await provider.request({
         method: "personal_sign",
         params: [messageToSign, account.address],
       });
+      if (!isHex(res)) {
+        throw new Error("Invalid signature returned");
+      }
+      return res;
     },
     async signTypedData(_typedData) {
       if (!account.address) {
@@ -343,10 +348,14 @@ function createAccount(provider: ProviderInterface, _address: string) {
         types,
       });
 
-      return await provider.request({
+      const res = await provider.request({
         method: "eth_signTypedData_v4",
         params: [account.address, stringifiedData],
       });
+      if (!isHex(res)) {
+        throw new Error("Invalid signed payload returned");
+      }
+      return res;
     },
     onTransactionRequested: async () => {
       // make sure to show the coinbase popup BEFORE doing any transaction preprocessing

package/src/wallets/smart/index.ts

@@ -104,7 +104,7 @@ export async function connectSmartWallet(
   const sponsorGas =
     "gasless" in options ? options.gasless : options.sponsorGas;
 
-  if (isZkSyncChain(chain)) {
+  if (await isZkSyncChain(chain)) {
     return [
       createZkSyncAccount({
         creationOptions,