thirdweb 5.44.1 → 5.45.0-nightly-bbb4f1c53f982b1f9de00fb30efbf2c77f155e96-20240809000532

package/src/extensions/marketplace/english-auctions/english-auctions.test.ts

@@ -26,137 +26,135 @@ import { bidInAuction } from "./write/bidInAuction.js";
 import { buyoutAuction } from "./write/buyoutAuction.js";
 import { createAuction } from "./write/createAuction.js";
 
-describe.runIf(process.env.TW_SECRET_KEY)(
-  "Marketplace: English Auctions",
-  () => {
-    let nftTokenId: bigint;
-    let marketplaceContract: ThirdwebContract;
-    let erc721Contract: ThirdwebContract;
-    beforeAll(async () => {
-      const marketplaceAddress = await deployMarketplaceContract({
-        account: TEST_ACCOUNT_A,
-        chain: ANVIL_CHAIN,
-        client: TEST_CLIENT,
-        params: {
-          name: "TestMarketPlace",
-        },
-      });
-      marketplaceContract = getContract({
-        address: marketplaceAddress,
-        client: TEST_CLIENT,
-        chain: ANVIL_CHAIN,
-      });
+describe.skip("Marketplace: English Auctions", () => {
+  let nftTokenId: bigint;
+  let marketplaceContract: ThirdwebContract;
+  let erc721Contract: ThirdwebContract;
+  beforeAll(async () => {
+    const marketplaceAddress = await deployMarketplaceContract({
+      account: TEST_ACCOUNT_A,
+      chain: ANVIL_CHAIN,
+      client: TEST_CLIENT,
+      params: {
+        name: "TestMarketPlace",
+      },
+    });
+    marketplaceContract = getContract({
+      address: marketplaceAddress,
+      client: TEST_CLIENT,
+      chain: ANVIL_CHAIN,
+    });
 
-      // also deploy an ERC721 contract
-      const erc721Address = await deployERC721Contract({
-        type: "TokenERC721",
-        account: TEST_ACCOUNT_A,
-        chain: ANVIL_CHAIN,
-        client: TEST_CLIENT,
-        params: {
-          name: "TestERC721",
-        },
-      });
+    // also deploy an ERC721 contract
+    const erc721Address = await deployERC721Contract({
+      type: "TokenERC721",
+      account: TEST_ACCOUNT_A,
+      chain: ANVIL_CHAIN,
+      client: TEST_CLIENT,
+      params: {
+        name: "TestERC721",
+      },
+    });
 
-      erc721Contract = getContract({
-        address: erc721Address,
-        client: TEST_CLIENT,
-        chain: ANVIL_CHAIN,
-      });
+    erc721Contract = getContract({
+      address: erc721Address,
+      client: TEST_CLIENT,
+      chain: ANVIL_CHAIN,
+    });
 
-      const mintTransaction = mintTo({
-        contract: erc721Contract,
-        to: TEST_ACCOUNT_A.address,
-        nft: { name: "Test:ERC721:EnglishAuction" },
-      });
-      const receipt = await sendAndConfirmTransaction({
-        transaction: mintTransaction,
-        account: TEST_ACCOUNT_A,
-      });
+    const mintTransaction = mintTo({
+      contract: erc721Contract,
+      to: TEST_ACCOUNT_A.address,
+      nft: { name: "Test:ERC721:EnglishAuction" },
+    });
+    const receipt = await sendAndConfirmTransaction({
+      transaction: mintTransaction,
+      account: TEST_ACCOUNT_A,
+    });
 
-      const mintEvents = parseEventLogs({
-        events: [tokensMintedEvent()],
-        logs: receipt.logs,
-      });
+    const mintEvents = parseEventLogs({
+      events: [tokensMintedEvent()],
+      logs: receipt.logs,
+    });
 
-      expect(mintEvents.length).toBe(1);
-      expect(mintEvents[0]?.args.tokenIdMinted).toBeDefined();
+    expect(mintEvents.length).toBe(1);
+    expect(mintEvents[0]?.args.tokenIdMinted).toBeDefined();
 
-      nftTokenId = mintEvents[0]?.args.tokenIdMinted as bigint;
-      // does a lot of stuff, this may take a while
-    }, 120_000);
+    nftTokenId = mintEvents[0]?.args.tokenIdMinted as bigint;
+    // does a lot of stuff, this may take a while
+  }, 120_000);
 
-    it("should work for basic auctions (Native Currency)", async () => {
-      // auctions should be 0 length to start
-      const auctions = await getAllAuctions({
-        contract: marketplaceContract,
-      });
-      expect(auctions.length).toBe(0);
-      // oh and so should totalAuctions
-      expect(await totalAuctions({ contract: marketplaceContract })).toBe(0n);
+  it("should work for basic auctions (Native Currency)", async () => {
+    // auctions should be 0 length to start
+    const auctions = await getAllAuctions({
+      contract: marketplaceContract,
+    });
+    expect(auctions.length).toBe(0);
+    // oh and so should totalAuctions
+    expect(await totalAuctions({ contract: marketplaceContract })).toBe(0n);
 
-      // approve first
-      const approveTx = approve({
-        contract: erc721Contract,
-        to: marketplaceContract.address,
-        tokenId: nftTokenId,
-      });
+    // approve first
+    const approveTx = approve({
+      contract: erc721Contract,
+      to: marketplaceContract.address,
+      tokenId: nftTokenId,
+    });
 
-      await sendAndConfirmTransaction({
-        transaction: approveTx,
-        account: TEST_ACCOUNT_A,
-      });
+    await sendAndConfirmTransaction({
+      transaction: approveTx,
+      account: TEST_ACCOUNT_A,
+    });
 
-      const transaction = createAuction({
-        contract: marketplaceContract,
-        assetContractAddress: erc721Contract.address,
-        tokenId: nftTokenId,
-        minimumBidAmount: "1",
-        buyoutBidAmount: "10",
-      });
-      const receipt = await sendAndConfirmTransaction({
-        transaction,
-        account: TEST_ACCOUNT_A,
-      });
+    const transaction = createAuction({
+      contract: marketplaceContract,
+      assetContractAddress: erc721Contract.address,
+      tokenId: nftTokenId,
+      minimumBidAmount: "1",
+      buyoutBidAmount: "10",
+    });
+    const receipt = await sendAndConfirmTransaction({
+      transaction,
+      account: TEST_ACCOUNT_A,
+    });
 
-      const listingEvents = parseEventLogs({
-        events: [newAuctionEvent()],
-        logs: receipt.logs,
-      });
+    const listingEvents = parseEventLogs({
+      events: [newAuctionEvent()],
+      logs: receipt.logs,
+    });
 
-      expect(listingEvents.length).toBe(1);
+    expect(listingEvents.length).toBe(1);
 
-      // biome-ignore lint/style/noNonNullAssertion: OK in tests
-      const listingEvent = listingEvents[0]!;
+    // biome-ignore lint/style/noNonNullAssertion: OK in tests
+    const listingEvent = listingEvents[0]!;
 
-      expect(listingEvent.args.auctionCreator).toBe(TEST_ACCOUNT_A.address);
-      expect(listingEvent.args.assetContract).toBe(erc721Contract.address);
+    expect(listingEvent.args.auctionCreator).toBe(TEST_ACCOUNT_A.address);
+    expect(listingEvent.args.assetContract).toBe(erc721Contract.address);
 
-      // at this point auctions should be 1
-      const auctionsAfter = await getAllAuctions({
-        contract: marketplaceContract,
-      });
-      expect(auctionsAfter.length).toBe(1);
-      // valid auctions should also be 1!
-      const validAuctions = await getAllValidAuctions({
-        contract: marketplaceContract,
-      });
-      expect(validAuctions.length).toBe(1);
-      // and totalauctions should be 1
-      expect(await totalAuctions({ contract: marketplaceContract })).toBe(1n);
+    // at this point auctions should be 1
+    const auctionsAfter = await getAllAuctions({
+      contract: marketplaceContract,
+    });
+    expect(auctionsAfter.length).toBe(1);
+    // valid auctions should also be 1!
+    const validAuctions = await getAllValidAuctions({
+      contract: marketplaceContract,
+    });
+    expect(validAuctions.length).toBe(1);
+    // and totalauctions should be 1
+    expect(await totalAuctions({ contract: marketplaceContract })).toBe(1n);
 
-      // explicitly retrieve the listing!
-      const listing = await getAuction({
-        contract: marketplaceContract,
-        auctionId: listingEvent.args.auctionId,
-      });
+    // explicitly retrieve the listing!
+    const listing = await getAuction({
+      contract: marketplaceContract,
+      auctionId: listingEvent.args.auctionId,
+    });
 
-      expect(listing).toBeDefined();
-      expect(listing.status).toBe("ACTIVE");
-      expect(listing.creatorAddress).toBe(TEST_ACCOUNT_A.address);
-      expect(listing.assetContractAddress).toBe(erc721Contract.address);
-      expect(listing.tokenId).toBe(nftTokenId);
-      expect(listing.minimumBidCurrencyValue).toMatchInlineSnapshot(`
+    expect(listing).toBeDefined();
+    expect(listing.status).toBe("ACTIVE");
+    expect(listing.creatorAddress).toBe(TEST_ACCOUNT_A.address);
+    expect(listing.assetContractAddress).toBe(erc721Contract.address);
+    expect(listing.tokenId).toBe(nftTokenId);
+    expect(listing.minimumBidCurrencyValue).toMatchInlineSnapshot(`
     {
       "decimals": 18,
       "displayValue": "1",
@@ -165,7 +163,7 @@ describe.runIf(process.env.TW_SECRET_KEY)(
       "value": 1000000000000000000n,
     }
   `);
-      expect(listing.buyoutCurrencyValue).toMatchInlineSnapshot(`
+    expect(listing.buyoutCurrencyValue).toMatchInlineSnapshot(`
     {
       "decimals": 18,
       "displayValue": "10",
@@ -174,7 +172,7 @@ describe.runIf(process.env.TW_SECRET_KEY)(
       "value": 10000000000000000000n,
     }
   `);
-      expect(listing.asset).toMatchInlineSnapshot(`
+    expect(listing.asset).toMatchInlineSnapshot(`
     {
       "id": 0n,
       "metadata": {
@@ -186,73 +184,71 @@ describe.runIf(process.env.TW_SECRET_KEY)(
     }
   `);
 
-      // check for a winning bid
-      await expect(
-        getWinningBid({
-          contract: marketplaceContract,
-          auctionId: listing.id,
-        }),
-      ).resolves.toBeUndefined();
+    // check for a winning bid
+    await expect(
+      getWinningBid({
+        contract: marketplaceContract,
+        auctionId: listing.id,
+      }),
+    ).resolves.toBeUndefined();
 
-      // invalid bid amount 1: 0 bid (0 is not allowed)
-      await expect(
-        sendAndConfirmTransaction({
-          account: TEST_ACCOUNT_B,
-          transaction: bidInAuction({
-            auctionId: listing.id,
-            contract: marketplaceContract,
-            bidAmount: "0",
-          }),
-        }),
-      ).rejects.toThrowErrorMatchingInlineSnapshot(
-        "[Error: Bid amount is zero]",
-      );
-      // invalid bid amount 2: 11 bid (over buyout)
-      await expect(
-        sendAndConfirmTransaction({
-          account: TEST_ACCOUNT_B,
-          transaction: bidInAuction({
-            auctionId: listing.id,
-            contract: marketplaceContract,
-            bidAmount: "11",
-          }),
+    // invalid bid amount 1: 0 bid (0 is not allowed)
+    await expect(
+      sendAndConfirmTransaction({
+        account: TEST_ACCOUNT_B,
+        transaction: bidInAuction({
+          auctionId: listing.id,
+          contract: marketplaceContract,
+          bidAmount: "0",
         }),
-      ).rejects.toThrowErrorMatchingInlineSnapshot(
-        "[Error: Bid amount is above the buyout amount]",
-      );
-      // invalid bid amount 3: below minimum bid (but not 0)
-      await expect(
-        sendAndConfirmTransaction({
-          account: TEST_ACCOUNT_B,
-          transaction: bidInAuction({
-            auctionId: listing.id,
-            contract: marketplaceContract,
-            bidAmount: "0.5",
-          }),
+      }),
+    ).rejects.toThrowErrorMatchingInlineSnapshot("[Error: Bid amount is zero]");
+    // invalid bid amount 2: 11 bid (over buyout)
+    await expect(
+      sendAndConfirmTransaction({
+        account: TEST_ACCOUNT_B,
+        transaction: bidInAuction({
+          auctionId: listing.id,
+          contract: marketplaceContract,
+          bidAmount: "11",
         }),
-      ).rejects.toThrowErrorMatchingInlineSnapshot(
-        "[Error: Bid amount is below the minimum bid amount]",
-      );
-
-      // valid bid amount: "2"
-      await expect(
-        sendAndConfirmTransaction({
-          account: TEST_ACCOUNT_B,
-          transaction: bidInAuction({
-            auctionId: listing.id,
-            contract: marketplaceContract,
-            bidAmount: "2",
-          }),
+      }),
+    ).rejects.toThrowErrorMatchingInlineSnapshot(
+      "[Error: Bid amount is above the buyout amount]",
+    );
+    // invalid bid amount 3: below minimum bid (but not 0)
+    await expect(
+      sendAndConfirmTransaction({
+        account: TEST_ACCOUNT_B,
+        transaction: bidInAuction({
+          auctionId: listing.id,
+          contract: marketplaceContract,
+          bidAmount: "0.5",
         }),
-      ).resolves.toBeDefined();
+      }),
+    ).rejects.toThrowErrorMatchingInlineSnapshot(
+      "[Error: Bid amount is below the minimum bid amount]",
+    );
 
-      // check for a new winning bid
-      await expect(
-        getWinningBid({
-          contract: marketplaceContract,
+    // valid bid amount: "2"
+    await expect(
+      sendAndConfirmTransaction({
+        account: TEST_ACCOUNT_B,
+        transaction: bidInAuction({
           auctionId: listing.id,
+          contract: marketplaceContract,
+          bidAmount: "2",
         }),
-      ).resolves.toMatchInlineSnapshot(`
+      }),
+    ).resolves.toBeDefined();
+
+    // check for a new winning bid
+    await expect(
+      getWinningBid({
+        contract: marketplaceContract,
+        auctionId: listing.id,
+      }),
+    ).resolves.toMatchInlineSnapshot(`
       {
         "bidAmountWei": 2000000000000000000n,
         "bidderAddress": "0x70997970C51812dc3A010C7d01b50e0d17dc79C8",
@@ -267,54 +263,54 @@ describe.runIf(process.env.TW_SECRET_KEY)(
       }
     `);
 
-      // invalid bid amount, above minimum but below existing winning bid
-      await expect(
-        sendAndConfirmTransaction({
-          account: TEST_ACCOUNT_B,
-          transaction: bidInAuction({
-            auctionId: listing.id,
-            contract: marketplaceContract,
-            bidAmount: "1.5",
-          }),
-        }),
-      ).rejects.toThrowErrorMatchingInlineSnapshot(
-        "[Error: Bid amount is too low to outbid the existing winning bid]",
-      );
-
-      // invalid bid amount, above winning bit but below bid + bidBuffer (default 500bps)
-      await expect(
-        sendAndConfirmTransaction({
-          account: TEST_ACCOUNT_B,
-          transaction: bidInAuction({
-            auctionId: listing.id,
-            contract: marketplaceContract,
-            // 2 * 1.05 = 2.1, so 2.05 is invalid
-            bidAmount: "2.05",
-          }),
+    // invalid bid amount, above minimum but below existing winning bid
+    await expect(
+      sendAndConfirmTransaction({
+        account: TEST_ACCOUNT_B,
+        transaction: bidInAuction({
+          auctionId: listing.id,
+          contract: marketplaceContract,
+          bidAmount: "1.5",
         }),
-      ).rejects.toThrowErrorMatchingInlineSnapshot(
-        "[Error: Bid amount is too low to outbid the existing winning bid]",
-      );
+      }),
+    ).rejects.toThrowErrorMatchingInlineSnapshot(
+      "[Error: Bid amount is too low to outbid the existing winning bid]",
+    );
 
-      // actually outbid the winning bid
-      await expect(
-        sendAndConfirmTransaction({
-          account: TEST_ACCOUNT_B,
-          transaction: bidInAuction({
-            auctionId: listing.id,
-            contract: marketplaceContract,
-            bidAmount: "3",
-          }),
+    // invalid bid amount, above winning bit but below bid + bidBuffer (default 500bps)
+    await expect(
+      sendAndConfirmTransaction({
+        account: TEST_ACCOUNT_B,
+        transaction: bidInAuction({
+          auctionId: listing.id,
+          contract: marketplaceContract,
+          // 2 * 1.05 = 2.1, so 2.05 is invalid
+          bidAmount: "2.05",
         }),
-      ).resolves.toBeDefined();
+      }),
+    ).rejects.toThrowErrorMatchingInlineSnapshot(
+      "[Error: Bid amount is too low to outbid the existing winning bid]",
+    );
 
-      // check for a new winning bid
-      await expect(
-        getWinningBid({
-          contract: marketplaceContract,
+    // actually outbid the winning bid
+    await expect(
+      sendAndConfirmTransaction({
+        account: TEST_ACCOUNT_B,
+        transaction: bidInAuction({
           auctionId: listing.id,
+          contract: marketplaceContract,
+          bidAmount: "3",
         }),
-      ).resolves.toMatchInlineSnapshot(`
+      }),
+    ).resolves.toBeDefined();
+
+    // check for a new winning bid
+    await expect(
+      getWinningBid({
+        contract: marketplaceContract,
+        auctionId: listing.id,
+      }),
+    ).resolves.toMatchInlineSnapshot(`
       {
         "bidAmountWei": 3000000000000000000n,
         "bidderAddress": "0x70997970C51812dc3A010C7d01b50e0d17dc79C8",
@@ -329,24 +325,24 @@ describe.runIf(process.env.TW_SECRET_KEY)(
       }
     `);
 
-      // buyout auction
-      await expect(
-        sendAndConfirmTransaction({
-          account: TEST_ACCOUNT_B,
-          transaction: buyoutAuction({
-            contract: marketplaceContract,
-            auctionId: listing.id,
-          }),
-        }),
-      ).resolves.toBeDefined();
-
-      // check for a new winning bid
-      await expect(
-        getWinningBid({
+    // buyout auction
+    await expect(
+      sendAndConfirmTransaction({
+        account: TEST_ACCOUNT_B,
+        transaction: buyoutAuction({
           contract: marketplaceContract,
           auctionId: listing.id,
         }),
-      ).resolves.toMatchInlineSnapshot(`
+      }),
+    ).resolves.toBeDefined();
+
+    // check for a new winning bid
+    await expect(
+      getWinningBid({
+        contract: marketplaceContract,
+        auctionId: listing.id,
+      }),
+    ).resolves.toMatchInlineSnapshot(`
       {
         "bidAmountWei": 10000000000000000000n,
         "bidderAddress": "0x70997970C51812dc3A010C7d01b50e0d17dc79C8",
@@ -360,6 +356,5 @@ describe.runIf(process.env.TW_SECRET_KEY)(
         },
       }
     `);
-    });
-  },
-);
+  });
+});

package/src/extensions/marketplace/offers/offers.test.ts

@@ -31,7 +31,7 @@ import { getOffer } from "./read/getOffer.js";
 import { acceptOffer } from "./write/acceptOffer.js";
 import { makeOffer } from "./write/makeOffer.js";
 
-describe.runIf(process.env.TW_SECRET_KEY)("Marketplace: Offers", () => {
+describe.skip("Marketplace: Offers", () => {
   let nftTokenId: bigint;
   let marketplaceContract: ThirdwebContract;
   let erc721Contract: ThirdwebContract;

package/src/extensions/prebuilts/deploy-modular-core.test.ts

@@ -11,7 +11,7 @@ import { uninstallPublishedExtension } from "../modular/ModularCore/write/uninst
 import { getInstalledExtensions } from "../modular/__generated__/ModularCore/read/getInstalledExtensions.js";
 import { deployPublishedContract } from "./deploy-published.js";
 
-describe.runIf(process.env.TW_SECRET_KEY)(
+describe.skip(
   "deployModularCore",
   {
     timeout: 120000,

package/src/react/core/hooks/others/useProfiles.ts

@@ -0,0 +1,36 @@
+import { type UseQueryResult, useQuery } from "@tanstack/react-query";
+import type { Profile } from "../../../../wallets/in-app/core/authentication/types.js";
+import { getProfiles } from "../../../../wallets/in-app/core/wallet/profiles.js";
+import type { Wallet } from "../../../../wallets/interfaces/wallet.js";
+import { useActiveWallet } from "../wallets/useActiveWallet.js";
+
+/**
+ * @description Retrieves all linked profiles for the current wallet.
+ *
+ * @returns A React Query result containing the linked profiles for the connected in-app wallet.
+ *
+ * @note This hook will only run if the connected wallet supports multi-auth (in-app wallets).
+ *
+ * @example
+ * ```jsx
+ * import { use } from "thirdweb/react";
+ *
+ * const { data: profiles } = useProfiles();
+ *
+ * console.log("Type:", profiles[0].type); // "discord"
+ * console.log("Email:", profiles[0].email); // "john.doe@example.com"
+ * ```
+ *
+ * @wallet
+ */
+export function useProfiles(): UseQueryResult<Profile[]> {
+  const wallet = useActiveWallet();
+
+  return useQuery({
+    queryKey: ["profiles", wallet?.id],
+    enabled: !!wallet && wallet.id === "inApp",
+    queryFn: async () => {
+      return getProfiles(wallet as Wallet<"inApp">);
+    },
+  });
+}

package/src/react/core/utils/storage.ts

@@ -1,5 +1,5 @@
 import type { AsyncStorage } from "../../../utils/storage/AsyncStorage.js";
-import type { AuthArgsType } from "../../../wallets/in-app/core/authentication/type.js";
+import type { AuthArgsType } from "../../../wallets/in-app/core/authentication/types.js";
 
 const LAST_AUTH_PROVIDER_STORAGE_KEY = "lastAuthProvider";
 

package/src/react/core/utils/{socialIcons.ts → walletIcon.ts}

@@ -55,3 +55,28 @@ export const socialIcons = {
   farcaster: farcasterIconUri,
   telegram: telegramIconUri,
 };
+
+export function getWalletIcon(provider: string) {
+  switch (provider) {
+    case "google":
+      return googleIconUri;
+    case "apple":
+      return appleIconUri;
+    case "facebook":
+      return facebookIconUri;
+    case "phone":
+      return phoneIcon;
+    case "email":
+      return emailIcon;
+    case "passkey":
+      return passkeyIcon;
+    case "discord":
+      return discordIconUri;
+    case "farcaster":
+      return farcasterIconUri;
+    case "telegram":
+      return telegramIconUri;
+    default:
+      return genericWalletIcon;
+  }
+}

package/src/react/native/ui/components/TokenIcon.tsx

@@ -3,7 +3,7 @@ import type { Chain } from "../../../../chains/types.js";
 import type { ThirdwebClient } from "../../../../client/client.js";
 import type { Theme } from "../../../core/design-system/index.js";
 import type { TokenInfo } from "../../../core/utils/defaultTokens.js";
-import { genericTokenIcon } from "../../../core/utils/socialIcons.js";
+import { genericTokenIcon } from "../../../core/utils/walletIcon.js";
 import { ChainIcon } from "./ChainIcon.js";
 import { RNImage } from "./RNImage.js";