Merge branch 'main' into Joe---AA-Supported-Chains

Author: Joe-Thirdweb

.changeset/fresh-gorillas-sip.md

@@ -0,0 +1,5 @@
+---
+"thirdweb": patch
+---
+
+Compute addresses with ref contracts

apps/dashboard/src/app/login/LoginPage.tsx

@@ -19,6 +19,7 @@ import {
 } from "thirdweb/react";
 import { createWallet, inAppWallet } from "thirdweb/wallets";
 import { ClientOnly } from "../../components/ClientOnly/ClientOnly";
+import { isVercel } from "../../lib/vercel-utils";
 import { ThirdwebMiniLogo } from "../components/ThirdwebMiniLogo";
 import { getSDKTheme } from "../components/sdk-component-theme";
 import { doLogin, doLogout, getLoginPayload, isLoggedIn } from "./auth-actions";
@@ -246,14 +247,17 @@ function CustomConnectEmbed(props: {
 }) {
   const { theme } = useTheme();
   const client = useThirdwebClient();
-  const [turnstileToken, setTurnstileToken] = useState("");
+  const [turnstileToken, setTurnstileToken] = useState<string | undefined>(
+    undefined,
+  );
+  const [alwaysShowTurnstile, setAlwaysShowTurnstile] = useState(false);
 
   return (
     <div className="flex flex-col items-center gap-4">
       <Turnstile
         options={{
           // only show if interaction is required
-          appearance: "interaction-only",
+          appearance: alwaysShowTurnstile ? "always" : "interaction-only",
           // match the theme of the rest of the app
           theme: theme === "light" ? "light" : "dark",
         }}
@@ -265,6 +269,11 @@ function CustomConnectEmbed(props: {
           auth={{
             getLoginPayload,
             doLogin: async (params) => {
+              if (isVercel() && !turnstileToken) {
+                setAlwaysShowTurnstile(true);
+                throw new Error("Please complete the captcha.");
+              }
+
               try {
                 const result = await doLogin(params, turnstileToken);
                 if (result.error) {

apps/dashboard/src/app/login/auth-actions.ts

@@ -40,7 +40,7 @@ export async function getLoginPayload(
 
 export async function doLogin(
   payload: VerifyLoginPayloadParams,
-  turnstileToken: string,
+  turnstileToken: string | undefined,
 ) {
   if (!THIRDWEB_API_SECRET) {
     throw new Error("API_SERVER_SECRET is not set");

apps/dashboard/src/app/nebula-app/(app)/components/ChatPageContent.tsx

@@ -96,6 +96,7 @@ export function ChatPageContent(props: {
   const setContextFilters = useCallback((v: NebulaContext | undefined) => {
     _setContextFilters(v);
     setHasUserUpdatedContextFilters(true);
+    saveLastUsedChainIds(v?.chainIds || undefined);
   }, []);
 
   const isNewSession = !props.session;
@@ -118,7 +119,21 @@ export function ChatPageContent(props: {
             walletAddress: null,
           };
 
+      // Only set wallet address from connected wallet
       updatedContextFilters.walletAddress = address || null;
+
+      // if we have last used chains in storage, continue using them
+      try {
+        const lastUsedChainIds = getLastUsedChainIds();
+        if (lastUsedChainIds) {
+          updatedContextFilters.chainIds = lastUsedChainIds;
+          return updatedContextFilters;
+        }
+      } catch {
+        // ignore local storage errors
+      }
+
+      // else - use the active chain
       updatedContextFilters.chainIds = activeChain
         ? [activeChain.id.toString()]
         : [];
@@ -493,3 +508,31 @@ function WalletDisconnectedDialog(props: {
     </Dialog>
   );
 }
+
+const NEBULA_LAST_USED_CHAIN_IDS_KEY = "nebula-last-used-chain-ids";
+
+function saveLastUsedChainIds(chainIds: string[] | undefined) {
+  try {
+    if (chainIds && chainIds.length > 0) {
+      localStorage.setItem(
+        NEBULA_LAST_USED_CHAIN_IDS_KEY,
+        JSON.stringify(chainIds),
+      );
+    } else {
+      localStorage.removeItem(NEBULA_LAST_USED_CHAIN_IDS_KEY);
+    }
+  } catch {
+    // ignore local storage errors
+  }
+}
+
+function getLastUsedChainIds(): string[] | null {
+  try {
+    const lastUsedChainIdsStr = localStorage.getItem(
+      NEBULA_LAST_USED_CHAIN_IDS_KEY,
+    );
+    return lastUsedChainIdsStr ? JSON.parse(lastUsedChainIdsStr) : null;
+  } catch {
+    return null;
+  }
+}

apps/portal/src/components/Document/Code.tsx

@@ -68,7 +68,7 @@ export async function CodeBlock(props: {
     <div className={cn("group/code relative mb-5", props.containerClassName)}>
       <code
         className={cn(
-          "relative block rounded-lg border bg-card font-mono text-sm leading-relaxed",
+          "relative block whitespace-pre rounded-lg border bg-card font-mono text-sm leading-relaxed",
           props.className,
         )}
         lang={lang}

packages/thirdweb/src/extensions/prebuilts/compute-ref-deployments.ts

@@ -0,0 +1,161 @@
+import type { Chain } from "../../chains/types.js";
+import type { ThirdwebClient } from "../../client/client.js";
+import { encodeAbiParameters } from "../../utils/abi/encodeAbiParameters.js";
+import { computePublishedContractAddress } from "../../utils/any-evm/compute-published-contract-address.js";
+import type { ImplementationConstructorParam } from "./process-ref-deployments.js";
+
+type ComputeRefDeploymentsOptions = {
+  client: ThirdwebClient;
+  chain: Chain;
+  paramValue: string | ImplementationConstructorParam;
+};
+
+/**
+ * Computes addresses for published contract references in constructor params.
+ * @returns Param value after processing references.
+ * @internal
+ */
+export async function computeRefDeployments(
+  options: ComputeRefDeploymentsOptions,
+): Promise<string | string[]> {
+  const { client, chain, paramValue } = options;
+
+  if (typeof paramValue === "object") {
+    if (
+      "defaultValue" in paramValue &&
+      paramValue.defaultValue &&
+      paramValue.defaultValue.length > 0
+    ) {
+      return paramValue.defaultValue;
+    }
+
+    if ("dynamicValue" in paramValue && paramValue.dynamicValue) {
+      const dynamicValue = paramValue.dynamicValue;
+      const contracts = dynamicValue.refContracts;
+
+      if (dynamicValue.type === "address") {
+        if (!contracts || contracts.length === 0 || !contracts[0]?.contractId) {
+          throw new Error("Invalid or empty param value");
+        }
+        const salt =
+          contracts[0]?.salt && contracts[0]?.salt.length > 0
+            ? contracts[0]?.salt
+            : "";
+
+        const addr = await computePublishedContractAddress({
+          client,
+          chain,
+          contractId: contracts[0]?.contractId,
+          publisher: contracts[0]?.publisherAddress,
+          version: contracts[0]?.version,
+          salt,
+        });
+
+        return addr;
+      }
+
+      if (dynamicValue.type === "address[]") {
+        if (!contracts || contracts.length === 0) {
+          throw new Error("Invalid or empty param value");
+        }
+        const addressArray: string[] = [];
+
+        for (const c of contracts) {
+          const salt = c?.salt && c?.salt.length > 0 ? c?.salt : "";
+
+          addressArray.push(
+            await computePublishedContractAddress({
+              client,
+              chain,
+              contractId: c.contractId,
+              publisher: c.publisherAddress,
+              version: c.version,
+              salt,
+            }),
+          );
+        }
+
+        return addressArray;
+      }
+
+      if (dynamicValue.type === "bytes") {
+        if (!dynamicValue.paramsToEncode) {
+          throw new Error("Invalid or empty param value");
+        }
+        const paramsToEncode = dynamicValue.paramsToEncode[0];
+
+        if (paramsToEncode) {
+          const types: string[] = [];
+          const values: (string | string[])[] = [];
+          for (const v of paramsToEncode) {
+            types.push(v.type);
+
+            if (v.defaultValue) {
+              values.push(v.defaultValue);
+            } else if (v.dynamicValue) {
+              values.push(
+                await computeRefDeployments({
+                  client,
+                  chain,
+                  paramValue: v,
+                }),
+              );
+            }
+          }
+
+          return encodeAbiParameters(
+            types.map((t) => {
+              return { type: t };
+            }),
+            values,
+          );
+        }
+      }
+
+      if (dynamicValue.type === "bytes[]") {
+        if (!dynamicValue.paramsToEncode) {
+          throw new Error("Invalid or empty param value");
+        }
+        const bytesArray: string[] = [];
+        const paramArray = dynamicValue.paramsToEncode;
+
+        for (const a of paramArray) {
+          const paramsToEncode = a;
+
+          if (paramsToEncode) {
+            const types: string[] = [];
+            const values: (string | string[])[] = [];
+            for (const v of paramsToEncode) {
+              types.push(v.type);
+
+              if (v.defaultValue) {
+                values.push(v.defaultValue);
+              } else if (v.dynamicValue) {
+                values.push(
+                  await computeRefDeployments({
+                    client,
+                    chain,
+                    paramValue: v,
+                  }),
+                );
+              }
+            }
+
+            bytesArray.push(
+              encodeAbiParameters(
+                types.map((t) => {
+                  return { type: t };
+                }),
+                values,
+              ),
+            );
+          }
+        }
+
+        return bytesArray;
+      }
+    }
+  }
+
+  return paramValue as string;
+}