thirdweb 5.76.0 → 5.77.0-nightly-a0fabb205916a7b06938fafbea5d80d9506d342e-20241212000351

package/src/react/web/ui/prebuilt/Token/symbol.tsx

@@ -3,11 +3,14 @@
 import { type UseQueryOptions, useQuery } from "@tanstack/react-query";
 import type React from "react";
 import type { JSX } from "react";
+import type { Chain } from "../../../../../chains/types.js";
 import { getChainMetadata } from "../../../../../chains/utils.js";
+import type { ThirdwebClient } from "../../../../../client/client.js";
 import { NATIVE_TOKEN_ADDRESS } from "../../../../../constants/addresses.js";
 import { getContract } from "../../../../../contract/contract.js";
 import { getContractMetadata } from "../../../../../extensions/common/read/getContractMetadata.js";
 import { symbol } from "../../../../../extensions/common/read/symbol.js";
+import { getFunctionId } from "../../../../../utils/function-id.js";
 import { useTokenContext } from "./provider.js";
 
 /**
@@ -154,36 +157,9 @@ export function TokenSymbol({
 }: TokenSymbolProps) {
   const { address, client, chain } = useTokenContext();
   const symbolQuery = useQuery({
-    queryKey: ["_internal_token_symbol_", chain.id, address] as const,
-    queryFn: async () => {
-      if (typeof symbolResolver === "string") {
-        return symbolResolver;
-      }
-      if (typeof symbolResolver === "function") {
-        return symbolResolver();
-      }
-      if (address.toLowerCase() === NATIVE_TOKEN_ADDRESS.toLowerCase()) {
-        // Don't wanna use `getChainSymbol` because it has some side effect (it catches error and defaults to "ETH")
-        return getChainMetadata(chain).then(
-          (data) => data.nativeCurrency.symbol,
-        );
-      }
-
-      // Try to fetch the symbol from both the `symbol` function and the contract metadata
-      // then prioritize the `symbol()`
-      const contract = getContract({ address, client, chain });
-      const [_symbol, contractMetadata] = await Promise.all([
-        symbol({ contract }),
-        getContractMetadata({ contract }),
-      ]);
-      if (!_symbol && !contractMetadata.symbol) {
-        throw new Error(
-          "Failed to resolve symbol from both symbol() and contract metadata",
-        );
-      }
-
-      return _symbol || contractMetadata.symbol;
-    },
+    queryKey: getQueryKeys({ chainId: chain.id, address, symbolResolver }),
+    queryFn: async () =>
+      fetchTokenSymbol({ symbolResolver, address, chain, client }),
     ...queryOptions,
   });
 
@@ -195,7 +171,72 @@ export function TokenSymbol({
     return fallbackComponent || null;
   }
 
-  const displayValue = formatFn ? formatFn(symbolQuery.data) : symbolQuery.data;
+  if (formatFn && typeof formatFn === "function") {
+    return <span {...restProps}>{formatFn(symbolQuery.data)}</span>;
+  }
+
+  return <span {...restProps}>{symbolQuery.data}</span>;
+}
 
-  return <span {...restProps}>{displayValue}</span>;
+/**
+ * @internal Exported for tests only
+ */
+export async function fetchTokenSymbol(props: {
+  address: string;
+  client: ThirdwebClient;
+  chain: Chain;
+  symbolResolver?: string | (() => string) | (() => Promise<string>);
+}): Promise<string> {
+  const { symbolResolver, address, client, chain } = props;
+  if (typeof symbolResolver === "string") {
+    return symbolResolver;
+  }
+  if (typeof symbolResolver === "function") {
+    return symbolResolver();
+  }
+  if (address.toLowerCase() === NATIVE_TOKEN_ADDRESS.toLowerCase()) {
+    // Don't wanna use `getChainSymbol` because it has some side effect (it catches error and defaults to "ETH")
+    return getChainMetadata(chain).then((data) => data.nativeCurrency.symbol);
+  }
+
+  // Try to fetch the symbol from both the `symbol` function and the contract metadata
+  // then prioritize its result
+  const contract = getContract({ address, client, chain });
+  const [_symbol, contractMetadata] = await Promise.all([
+    symbol({ contract }).catch(() => undefined),
+    getContractMetadata({ contract }).catch(() => undefined),
+  ]);
+  if (typeof _symbol === "string") {
+    return _symbol;
+  }
+  if (typeof contractMetadata?.symbol === "string") {
+    return contractMetadata.symbol;
+  }
+  throw new Error(
+    "Failed to resolve symbol from both symbol() and contract metadata",
+  );
+}
+
+/**
+ * @internal
+ */
+export function getQueryKeys(props: {
+  chainId: number;
+  address: string;
+  symbolResolver?: string | (() => string) | (() => Promise<string>);
+}) {
+  const { chainId, address, symbolResolver } = props;
+  return [
+    "_internal_token_symbol_",
+    chainId,
+    address,
+    {
+      resolver:
+        typeof symbolResolver === "string"
+          ? symbolResolver
+          : typeof symbolResolver === "function"
+            ? getFunctionId(symbolResolver)
+            : undefined,
+    },
+  ] as const;
 }

package/src/react/web/ui/types.ts

@@ -7,4 +7,5 @@ export type LocaleId =
   | "tl_PH"
   | "vi_VN"
   | "de_DE"
-  | "fr_FR";
+  | "fr_FR"
+  | "pt_BR";

package/src/react/web/utils/storage.test.ts

@@ -0,0 +1,34 @@
+import { describe, expect, it, vi } from "vitest";
+import { webLocalStorage } from "../../../utils/storage/webStorage.js";
+import { LAST_AUTH_PROVIDER_STORAGE_KEY } from "../../core/utils/storage.js";
+import { getLastAuthProvider } from "./storage.js";
+
+vi.mock("../../../utils/storage/webStorage.js", () => ({
+  webLocalStorage: {
+    getItem: vi.fn().mockResolvedValueOnce("mockStrategy"),
+  },
+}));
+
+describe("getLastAuthProvider", () => {
+  it("should return the last authentication provider strategy if it exists", async () => {
+    const mockStrategy = "mockStrategy";
+    webLocalStorage.getItem = vi.fn().mockResolvedValueOnce(mockStrategy);
+
+    const result = await getLastAuthProvider();
+    expect(result).toBe(mockStrategy);
+  });
+
+  it("should return null if no authentication provider strategy is found", async () => {
+    webLocalStorage.getItem = vi.fn().mockResolvedValueOnce(null);
+
+    const result = await getLastAuthProvider();
+    expect(result).toBeNull();
+  });
+
+  it("should call webLocalStorage.getItem with the correct key", async () => {
+    await getLastAuthProvider();
+    expect(webLocalStorage.getItem).toHaveBeenCalledWith(
+      LAST_AUTH_PROVIDER_STORAGE_KEY,
+    );
+  });
+});

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

@@ -0,0 +1,23 @@
+import { webLocalStorage } from "../../../utils/storage/webStorage.js";
+import { getLastAuthProvider as getLastAuthProviderCore } from "../../core/utils/storage.js";
+
+/**
+ * Retrieves the last authentication provider used from local storage.
+ *
+ * This function is designed to work only in a browser environment.
+ *
+ * @returns {Promise<AuthArgsType["strategy"] | null>} A promise that resolves to the last
+ * authentication provider strategy used, or `null` if none is found.
+ *
+ * @example
+ * ```typescript
+ * import { getLastAuthProvider } from "thirdweb/react";
+ *
+ * const lastAuthProvider = await getLastAuthProvider();
+ * ```
+ *
+ * @utils
+ */
+export async function getLastAuthProvider() {
+  return getLastAuthProviderCore(webLocalStorage);
+}

package/src/react/web/wallets/injected/locale/br.ts

@@ -0,0 +1,27 @@
+import type { InjectedWalletLocale } from "./types.js";
+
+/**
+ * @internal
+ */
+const injectedWalletLocalePtBr = (wallet: string): InjectedWalletLocale => ({
+  connectionScreen: {
+    inProgress: "Aguardando Confirmação",
+    failed: "Falha na conexão",
+    instruction: `Aceite a solicitação de conexão no ${wallet}`,
+    retry: "Tentar novamente",
+  },
+  getStartedScreen: {
+    instruction: `Escaneie o código QR para baixar o aplicativo ${wallet}`,
+  },
+  scanScreen: {
+    instruction: `Escaneie o código QR com o aplicativo ${wallet} para conectar`,
+  },
+  getStartedLink: `Não tem o ${wallet}?`,
+  download: {
+    chrome: "Baixar extensão para Chrome",
+    android: "Baixar no Google Play",
+    iOS: "Baixar na App Store",
+  },
+});
+
+export default injectedWalletLocalePtBr;

package/src/react/web/wallets/injected/locale/getInjectedWalletLocale.ts

@@ -22,6 +22,9 @@ export async function getInjectedWalletLocale(
       return (await import("./kr.js")).default;
     case "fr_FR":
       return (await import("./fr.js")).default;
+    case "pt_BR": {
+      return (await import("./br.js")).default;
+    }
     default:
       return (await import("./en.js")).default;
   }

package/src/react/web/wallets/shared/locale/br.ts

@@ -0,0 +1,62 @@
+import type { InAppWalletLocale } from "./types.js";
+
+export default {
+  signInWithGoogle: "Google",
+  signInWithFacebook: "Facebook",
+  signInWithApple: "Apple",
+  signInWithDiscord: "Discord",
+  emailPlaceholder: "Endereço de e-mail",
+  submitEmail: "Continuar",
+  signIn: "Entrar",
+  or: "ou",
+  emailRequired: "Endereço de e-mail é obrigatório",
+  invalidEmail: "Endereço de e-mail inválido",
+  maxAccountsExceeded:
+    "Número máximo de contas excedido. Por favor, notifique o desenvolvedor do aplicativo.",
+  socialLoginScreen: {
+    title: "Entrar",
+    instruction: "Faça login na sua conta no pop-up",
+    failed: "Falha ao entrar",
+    retry: "Tentar novamente",
+  },
+  emailLoginScreen: {
+    title: "Entrar",
+    enterCodeSendTo: "Digite o código de verificação enviado para",
+    newDeviceDetected: "Novo dispositivo detectado",
+    enterRecoveryCode:
+      "Digite o código de recuperação enviado por e-mail quando você se cadastrou",
+    invalidCode: "Código de verificação inválido",
+    invalidCodeOrRecoveryCode:
+      "Código de verificação ou código de recuperação inválido",
+    verify: "Verificar",
+    failedToSendCode: "Falha ao enviar código de verificação",
+    sendingCode: "Enviando código de verificação",
+    resendCode: "Reenviar código de verificação",
+  },
+  createPassword: {
+    title: "Criar senha",
+    instruction:
+      "Defina uma senha para sua conta. Você precisará dessa senha ao conectar-se de um novo dispositivo.",
+    saveInstruction: "Certifique-se de salvá-la",
+    inputPlaceholder: "Digite sua senha",
+    confirmation: "Eu salvei minha senha",
+    submitButton: "Definir senha",
+    failedToSetPassword: "Falha ao definir senha",
+  },
+  enterPassword: {
+    title: "Digite a senha",
+    instruction: "Digite a senha da sua conta",
+    inputPlaceholder: "Digite sua senha",
+    submitButton: "Verificar",
+    wrongPassword: "Senha incorreta",
+  },
+  signInWithEmail: "Entrar com e-mail",
+  invalidPhone: "Número de telefone inválido",
+  phonePlaceholder: "Número de telefone",
+  signInWithPhone: "Entrar com número de telefone",
+  phoneRequired: "Número de telefone é obrigatório",
+  passkey: "Chave de acesso",
+  signInWithWallet: "Entrar com carteira",
+  linkWallet: "Vincular uma carteira",
+  loginAsGuest: "Continuar como convidado",
+} satisfies InAppWalletLocale;

package/src/react/web/wallets/shared/locale/getConnectLocale.ts

@@ -22,6 +22,9 @@ export async function getInAppWalletLocale(
       return (await import("./kr.js")).default;
     case "fr_FR":
       return (await import("./fr.js")).default;
+    case "pt_BR": {
+      return (await import("./br.js")).default;
+    }
     default:
       return (await import("./en.js")).default;
   }

package/src/react/web/wallets/smartWallet/locale/br.ts

@@ -0,0 +1,13 @@
+import type { SmartWalletLocale } from "./types.js";
+
+const smartWalletLocalePtBr: SmartWalletLocale = {
+  connecting: "Conectando à Conta Inteligente",
+  failedToConnect: "Falha ao conectar à Conta Inteligente",
+  wrongNetworkScreen: {
+    title: "Rede Incorreta",
+    subtitle: "Sua carteira não está conectada à rede requerida",
+    failedToSwitch: "Falha ao mudar de rede",
+  },
+};
+
+export default smartWalletLocalePtBr;

package/src/react/web/wallets/smartWallet/locale/getSmartWalletLocale.ts

@@ -22,6 +22,9 @@ export async function getSmartWalletLocale(
       return (await import("./kr.js")).default;
     case "fr_FR":
       return (await import("./fr.js")).default;
+    case "pt_BR": {
+      return (await import("./br.js")).default;
+    }
     default:
       return (await import("./en.js")).default;
   }

package/src/utils/any-evm/deploy-metadata.ts

@@ -159,6 +159,27 @@ type ParsedCompilerMetadata = {
   zk_version?: string;
 };
 
+export type DynamicParams = {
+  type: "address" | "address[]" | "bytes" | "bytes[]";
+
+  // use for address types
+  refContracts?: Array<{
+    contractId: string;
+    publisherAddress: string;
+    version: string;
+    salt?: string;
+  }>;
+
+  // use for bytes
+  paramsToEncode?: Array<
+    Array<{
+      type: string;
+      defaultValue?: string;
+      dynamicValue?: DynamicParams; // can have address type which may need ref
+    }>
+  >;
+};
+
 export type CompilerMetadata = Prettify<
   RawCompilerMetadata & ParsedCompilerMetadata
 >;
@@ -220,6 +241,14 @@ export type ExtendedMetadata = {
       description?: string;
       defaultValue?: string;
       hidden?: boolean;
+      dynamicValue?: DynamicParams;
+    }
+  >;
+  implConstructorParams?: Record<
+    string,
+    {
+      defaultValue?: string;
+      dynamicValue?: DynamicParams;
     }
   >;
   compositeAbi?: Abi;

package/src/version.ts

@@ -1 +1 @@
-export const version = "5.76.0";
+export const version = "5.77.0-nightly-a0fabb205916a7b06938fafbea5d80d9506d342e-20241212000351";

package/src/wallets/manager/index.ts

@@ -230,11 +230,15 @@ export function createConnectionManager(storage: AsyncStorage) {
 
   // save last connected wallet ids to storage
   effect(
-    () => {
+    async () => {
+      const prevAccounts = (await getStoredConnectedWalletIds(storage)) || [];
       const accounts = connectedWallets.getValue();
       const ids = accounts.map((acc) => acc?.id).filter((c) => !!c) as string[];
 
-      storage.setItem(CONNECTED_WALLET_IDS, stringify(ids));
+      storage.setItem(
+        CONNECTED_WALLET_IDS,
+        stringify(Array.from(new Set([...prevAccounts, ...ids]))),
+      );
     },
     [connectedWallets],
     false,