thirdweb 5.34.0-nightly-f6ff5a78fc2d65f0f250b154f1405210ca57ce0a-20240707000358 → 5.34.0-nightly-325416ea19905901f30e795cbf93cb8a085be02f-20240708203622

package/src/react/web/ui/ConnectWallet/screens/Buy/main/useUISelectionStates.ts

@@ -1,7 +1,6 @@
 import { useState } from "react";
 import { polygon } from "../../../../../../../chains/chain-definitions/polygon.js";
 import type { Chain } from "../../../../../../../chains/types.js";
-import { formatNumber } from "../../../../../../../utils/formatNumber.js";
 import { toEther } from "../../../../../../../utils/units.js";
 import type { PayUIOptions } from "../../../../../../core/hooks/connection/ConnectButtonProps.js";
 import { useActiveWalletChain } from "../../../../../hooks/wallets/useActiveWalletChain.js";
@@ -24,11 +23,7 @@ export function useUISelectionStates(options: {
   // buy token amount ---------------------------------------------------------
   const initialTokenAmount =
     payOptions.prefillBuy?.amount ||
-    (buyForTx
-      ? String(
-          formatNumber(Number(toEther(buyForTx.cost - buyForTx.balance)), 4),
-        )
-      : "");
+    (buyForTx ? String(toEther(buyForTx.cost - buyForTx.balance)) : "");
 
   const [tokenAmount, setTokenAmount] = useState<string>(initialTokenAmount);
   const deferredTokenAmount = useDebouncedValue(tokenAmount, 300);

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

@@ -84,7 +84,7 @@ export function SwapConfirmationScreen(props: {
       <ConfirmItem label="Pay">
         <RenderTokenInfo
           chain={props.fromChain}
-          amount={String(formatNumber(Number(props.fromAmount), 4))}
+          amount={String(formatNumber(Number(props.fromAmount), 6))}
           symbol={props.fromTokenSymbol || ""}
           token={props.fromToken}
           client={props.client}
@@ -95,7 +95,7 @@ export function SwapConfirmationScreen(props: {
       <ConfirmItem label="Receive">
         <RenderTokenInfo
           chain={props.toChain}
-          amount={String(formatNumber(Number(props.toAmount), 4))}
+          amount={String(formatNumber(Number(props.toAmount), 6))}
           symbol={props.toTokenSymbol}
           token={props.toToken}
           client={props.client}

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

@@ -21,7 +21,7 @@ export function SwapFees(props: {
       }}
     >
       {props.quote.processingFees.map((fee) => {
-        const feeAmount = formatNumber(Number(fee.amount), 4);
+        const feeAmount = formatNumber(Number(fee.amount), 6);
         return (
           <Container
             key={`${fee.token.chainId}_${fee.token.tokenAddress}_${feeAmount}`}
@@ -61,14 +61,14 @@ export function FiatFees(props: {
           Amount
         </Text>
         <Text color="primaryText" inline>
-          {formatNumber(Number(props.quote.fromCurrency.amount), 4)}{" "}
+          {formatNumber(Number(props.quote.fromCurrency.amount), 2)}{" "}
           {props.quote.fromCurrency.currencySymbol}
         </Text>
       </div>
 
       {/* Processing Fees */}
       {props.quote.processingFees.map((fee, i) => {
-        const feeAmount = formatNumber(Number(fee.amount), 4);
+        const feeAmount = formatNumber(Number(fee.amount), 6);
 
         return (
           <div
@@ -106,7 +106,7 @@ export function FiatFees(props: {
           Total
         </Text>
         <Text color="primaryText" inline>
-          {formatNumber(Number(props.quote.fromCurrencyWithFees.amount), 4)}{" "}
+          {formatNumber(Number(props.quote.fromCurrencyWithFees.amount), 6)}{" "}
           {props.quote.fromCurrencyWithFees.currencySymbol}
         </Text>
       </div>

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

@@ -118,7 +118,7 @@ export function PayWithCrypto(props: {
             color={props.value ? "primaryText" : "secondaryText"}
             style={{}}
           >
-            {formatNumber(Number(props.value), 4) || "--"}
+            {formatNumber(Number(props.value), 6) || "--"}
           </Text>
         )}
 

package/src/react/web/ui/ConnectWallet/screens/Buy/tx-history/BuyTxHistoryButton.tsx

@@ -79,7 +79,7 @@ export function BuyTxHistoryButton(props: {
                     ? props.txInfo.status.quote.toAmount
                     : props.txInfo.status.quote.estimatedToTokenAmount,
                 ),
-                4,
+                6,
               )}{" "}
               {props.txInfo.status.quote.toToken.symbol}
             </Text>{" "}

package/src/react/web/ui/ConnectWallet/screens/Buy/tx-history/TokenInfoRow.tsx

@@ -46,7 +46,7 @@ export function TokenInfoRow(props: {
             client={props.client}
           />
           <Text color="primaryText">
-            {formatNumber(Number(props.tokenAmount), 4)} {props.tokenSymbol}
+            {formatNumber(Number(props.tokenAmount), 6)} {props.tokenSymbol}
           </Text>
         </Container>
         <Text size="sm">{name}</Text>

package/src/utils/hashing/hashTypedData.test.ts

@@ -0,0 +1,207 @@
+import { expect, test } from "vitest";
+
+import { pad } from "viem";
+import { typedData } from "../../../test/src/typed-data.js";
+import { toHex } from "../encoding/hex.js";
+import { hashTypedData } from "./hashTypedData.js";
+
+test("default", () => {
+  expect(
+    hashTypedData({
+      ...typedData.basic,
+      primaryType: "Mail",
+    }),
+  ).toMatchInlineSnapshot(
+    '"0x448f54762ef8ecccdc4d19bb7d467161383cd4b271617a8cee05c790eb745d74"',
+  );
+});
+
+test("complex", () => {
+  expect(
+    hashTypedData({
+      ...typedData.complex,
+      primaryType: "Mail",
+    }),
+  ).toMatchInlineSnapshot(
+    '"0x9a74cb859ad30835ffb2da406423233c212cf6dd78e6c2c98b0c9289568954ae"',
+  );
+});
+
+test("no domain", () => {
+  expect(
+    hashTypedData({
+      ...typedData.complex,
+      domain: undefined,
+      primaryType: "Mail",
+    }),
+  ).toMatchInlineSnapshot(
+    '"0x14ed1dbbfecbe5de3919f7ea47daafdf3a29dfbb60dd88d85509f79773d503a5"',
+  );
+  expect(
+    hashTypedData({
+      ...typedData.complex,
+      domain: {},
+      primaryType: "Mail",
+    }),
+  ).toMatchInlineSnapshot(
+    '"0x14ed1dbbfecbe5de3919f7ea47daafdf3a29dfbb60dd88d85509f79773d503a5"',
+  );
+});
+
+test("domain: empty name", () => {
+  expect(
+    hashTypedData({
+      ...typedData.complex,
+      domain: { name: "" },
+      primaryType: "Mail",
+    }),
+  ).toMatchInlineSnapshot(
+    '"0xc3f4f9ebd774352940f60aebbc83fcee20d0b17eb42bd1b20c91a748001ecb53"',
+  );
+});
+
+test("minimal valid typed message", () => {
+  const hash = hashTypedData({
+    types: {
+      EIP712Domain: [],
+    },
+    primaryType: "EIP712Domain",
+    domain: {},
+  });
+
+  expect(hash).toMatchInlineSnapshot(
+    '"0x8d4a3f4082945b7879e2b55f181c31a77c8c0a464b70669458abbaaf99de4c38"',
+  );
+});
+
+test("typed message with a domain separator that uses all fields.", () => {
+  const hash = hashTypedData({
+    types: {
+      EIP712Domain: [
+        {
+          name: "name",
+          type: "string",
+        },
+        {
+          name: "version",
+          type: "string",
+        },
+        {
+          name: "chainId",
+          type: "uint256",
+        },
+        {
+          name: "verifyingContract",
+          type: "address",
+        },
+        {
+          name: "salt",
+          type: "bytes32",
+        },
+      ],
+    },
+    primaryType: "EIP712Domain",
+    domain: {
+      name: "example.metamask.io",
+      version: "1",
+      chainId: 1n,
+      verifyingContract: "0x0000000000000000000000000000000000000000",
+      salt: pad(toHex(new Uint8Array([1, 2, 3])), { dir: "right" }),
+    },
+  });
+
+  expect(hash).toMatchInlineSnapshot(
+    '"0x54ffed5209a17ac210ef3823740b3852ee9cd518b84ee39f0a3fa7f2f9b4205b"',
+  );
+});
+
+test("typed message with only custom domain separator fields", () => {
+  const hash = hashTypedData({
+    types: {
+      EIP712Domain: [
+        {
+          name: "customName",
+          type: "string",
+        },
+        {
+          name: "customVersion",
+          type: "string",
+        },
+        {
+          name: "customChainId",
+          type: "uint256",
+        },
+        {
+          name: "customVerifyingContract",
+          type: "address",
+        },
+        {
+          name: "customSalt",
+          type: "bytes32",
+        },
+        {
+          name: "extraField",
+          type: "string",
+        },
+      ],
+    },
+    primaryType: "EIP712Domain",
+    domain: {
+      customName: "example.metamask.io",
+      customVersion: "1",
+      customChainId: 1n,
+      customVerifyingContract: "0x0000000000000000000000000000000000000000",
+      customSalt: pad(toHex(new Uint8Array([1, 2, 3])), { dir: "right" }),
+      extraField: "stuff",
+    },
+  });
+
+  expect(hash).toMatchInlineSnapshot(
+    '"0x3efa3ef0305f56ba5bba62000500e29fe82c5314bca2f958c64e31b2498560f8"',
+  );
+});
+
+test("typed message with data", () => {
+  const hash = hashTypedData({
+    types: {
+      EIP712Domain: [
+        {
+          name: "name",
+          type: "string",
+        },
+        {
+          name: "version",
+          type: "string",
+        },
+        {
+          name: "chainId",
+          type: "uint256",
+        },
+        {
+          name: "verifyingContract",
+          type: "address",
+        },
+        {
+          name: "salt",
+          type: "bytes32",
+        },
+      ],
+      Message: [{ name: "data", type: "string" }],
+    },
+    primaryType: "Message",
+    domain: {
+      name: "example.metamask.io",
+      version: "1",
+      chainId: 1n,
+      verifyingContract: "0x0000000000000000000000000000000000000000",
+      salt: pad(toHex(new Uint8Array([1, 2, 3])), { dir: "right" }),
+    },
+    message: {
+      data: "Hello!",
+    },
+  });
+
+  expect(hash).toMatchInlineSnapshot(
+    '"0xd2669f23b7849020ad41bcbff5b51372793f91320e0f901641945568ed7322be"',
+  );
+});

package/src/utils/hashing/hashTypedData.ts

@@ -0,0 +1,210 @@
+import {
+  type AbiParameter,
+  type TypedData,
+  type TypedDataDefinition,
+  concat,
+  getTypesForEIP712Domain,
+  hashDomain,
+  validateTypedData,
+} from "viem";
+import { encodeAbiParameters } from "../abi/encodeAbiParameters.js";
+import { type Hex, toHex } from "../encoding/hex.js";
+import { keccak256 } from "./keccak256.js";
+
+type MessageTypeProperty = {
+  name: string;
+  type: string;
+};
+
+export type HashTypedDataParams<
+  typedData extends TypedData | Record<string, unknown> = TypedData,
+  primaryType extends keyof typedData | "EIP712Domain" = keyof typedData,
+> = TypedDataDefinition<typedData, primaryType>;
+
+/**
+ * @internal
+ */
+export function hashTypedData<
+  const typedData extends TypedData | Record<string, unknown>,
+  primaryType extends keyof typedData | "EIP712Domain",
+>(parameters: HashTypedDataParams<typedData, primaryType>): Hex {
+  const {
+    domain = {},
+    message,
+    primaryType,
+  } = parameters as HashTypedDataParams;
+  const types = {
+    EIP712Domain: getTypesForEIP712Domain({ domain }),
+    ...parameters.types,
+  };
+
+  // Need to do a runtime validation check on addresses, byte ranges, integer ranges, etc
+  // as we can't statically check this with TypeScript.
+  validateTypedData({
+    domain,
+    message,
+    primaryType,
+    types,
+  });
+
+  const parts: Hex[] = ["0x1901"];
+  if (domain)
+    parts.push(
+      hashDomain({
+        domain,
+        types: types as Record<string, MessageTypeProperty[]>,
+      }),
+    );
+
+  if (primaryType !== "EIP712Domain") {
+    const hashedStruct = (() => {
+      const encoded = encodeData({
+        data: message,
+        primaryType,
+        types: types as Record<string, MessageTypeProperty[]>,
+      });
+      return keccak256(encoded);
+    })();
+
+    parts.push(hashedStruct);
+  }
+
+  return keccak256(concat(parts));
+}
+
+function encodeData({
+  data,
+  primaryType,
+  types,
+}: {
+  data: Record<string, unknown>;
+  primaryType: string;
+  types: Record<string, MessageTypeProperty[]>;
+}) {
+  const encodedTypes: AbiParameter[] = [{ type: "bytes32" }];
+  const encodedValues: unknown[] = [hashType({ primaryType, types })];
+
+  if (!types[primaryType]) throw new Error("Invalid types");
+  for (const field of types[primaryType]) {
+    const [type, value] = encodeField({
+      types,
+      name: field.name,
+      type: field.type,
+      value: data[field.name],
+    });
+    encodedTypes.push(type);
+    encodedValues.push(value);
+  }
+
+  return encodeAbiParameters(encodedTypes, encodedValues);
+}
+
+function hashType({
+  primaryType,
+  types,
+}: {
+  primaryType: string;
+  types: Record<string, MessageTypeProperty[]>;
+}) {
+  const encodedHashType = toHex(encodeType({ primaryType, types }));
+  return keccak256(encodedHashType);
+}
+
+export function encodeType({
+  primaryType,
+  types,
+}: {
+  primaryType: string;
+  types: Record<string, MessageTypeProperty[]>;
+}) {
+  let result = "";
+  const unsortedDeps = findTypeDependencies({ primaryType, types });
+  unsortedDeps.delete(primaryType);
+
+  const deps = [primaryType, ...Array.from(unsortedDeps).sort()];
+  for (const type of deps) {
+    if (!types[type]) throw new Error("Invalid types");
+    result += `${type}(${types[type]
+      .map(({ name, type: t }) => `${t} ${name}`)
+      .join(",")})`;
+  }
+
+  return result;
+}
+
+function findTypeDependencies(
+  {
+    primaryType: primaryType_,
+    types,
+  }: {
+    primaryType: string;
+    types: Record<string, MessageTypeProperty[]>;
+  },
+  results: Set<string> = new Set(),
+): Set<string> {
+  const match = primaryType_.match(/^\w*/u);
+  const primaryType = match?.[0] as string;
+  if (results.has(primaryType) || types[primaryType] === undefined) {
+    return results;
+  }
+
+  results.add(primaryType);
+
+  for (const field of types[primaryType]) {
+    findTypeDependencies({ primaryType: field.type, types }, results);
+  }
+  return results;
+}
+
+function encodeField({
+  types,
+  name,
+  type,
+  value,
+}: {
+  types: Record<string, MessageTypeProperty[]>;
+  name: string;
+  type: string;
+  // biome-ignore lint/suspicious/noExplicitAny: Can't anticipate types of nested values
+  value: any;
+  // biome-ignore lint/suspicious/noExplicitAny: Can't anticipate types of nested values
+}): [type: AbiParameter, value: any] {
+  if (types[type] !== undefined) {
+    return [
+      { type: "bytes32" },
+      keccak256(encodeData({ data: value, primaryType: type, types })),
+    ];
+  }
+
+  if (type === "bytes") {
+    const prepend = value.length % 2 ? "0" : "";
+    value = `0x${prepend + value.slice(2)}`;
+    return [{ type: "bytes32" }, keccak256(value)];
+  }
+
+  if (type === "string") return [{ type: "bytes32" }, keccak256(toHex(value))];
+
+  if (type.lastIndexOf("]") === type.length - 1) {
+    const parsedType = type.slice(0, type.lastIndexOf("["));
+    // biome-ignore lint/suspicious/noExplicitAny: Can't anticipate types of nested values
+    const typeValuePairs = (value as [AbiParameter, any][]).map((item) =>
+      encodeField({
+        name,
+        type: parsedType,
+        types,
+        value: item,
+      }),
+    );
+    return [
+      { type: "bytes32" },
+      keccak256(
+        encodeAbiParameters(
+          typeValuePairs.map(([t]) => t),
+          typeValuePairs.map(([, v]) => v),
+        ),
+      ),
+    ];
+  }
+
+  return [{ type }, value];
+}

package/src/utils/jwt/decode-jwt.ts

@@ -15,7 +15,7 @@ import type { JWTPayload } from "./types.js";
  * const { payload, signature } = decodeJWT(jwt);
  * ```
  */
-export function deccodeJWT(jwt: string) {
+export function decodeJWT(jwt: string) {
   const [encodedHeader, encodedPayload, encodedSignature] = jwt.split(".");
 
   if (encodedHeader !== PRECOMPILED_B64_ENCODED_JWT_HEADER) {

package/src/utils/jwt/refresh-jwt.ts

@@ -1,5 +1,5 @@
 import type { Account } from "../../wallets/interfaces/wallet.js";
-import { deccodeJWT } from "./decode-jwt.js";
+import { decodeJWT } from "./decode-jwt.js";
 import { encodeJWT } from "./encode-jwt.js";
 
 const DEFAULT_EXPIRATION_TIME = 60 * 60 * 24;
@@ -27,7 +27,7 @@ export type RefreshJWTParams = {
  */
 export async function refreshJWT(options: RefreshJWTParams): Promise<string> {
   const { account, jwt, expirationTime = DEFAULT_EXPIRATION_TIME } = options;
-  const payload = deccodeJWT(jwt).payload;
+  const payload = decodeJWT(jwt).payload;
   return encodeJWT({
     payload: {
       iss: payload.iss,

package/src/version.ts

@@ -1 +1 @@
-export const version = "5.34.0-nightly-f6ff5a78fc2d65f0f250b154f1405210ca57ce0a-20240707000358";
+export const version = "5.34.0-nightly-325416ea19905901f30e795cbf93cb8a085be02f-20240708203622";