fix build

Author: gregfromstl

packages/thirdweb/src/extensions/erc1271/checkContractWalletSignedTypedData.ts

@@ -1,4 +1,4 @@
-import { type TypedData, type TypedDataDefinition, hashTypedData } from "viem";
+import * as ox__TypedData from "ox/TypedData";
 import type { ThirdwebContract } from "../../contract/contract.js";
 import { isHex } from "../../utils/encoding/hex.js";
 import { isValidSignature } from "./__generated__/isValidSignature/read/isValidSignature.js";
@@ -7,11 +7,11 @@ import { isValidSignature } from "./__generated__/isValidSignature/read/isValidS
  * @extension ERC1271
  */
 export type CheckContractWalletSignTypedDataOptions<
-  typedData extends TypedData | Record<string, unknown>,
+  typedData extends ox__TypedData.TypedData | Record<string, unknown>,
   primaryType extends keyof typedData | "EIP712Domain" = keyof typedData,
 > = {
   contract: ThirdwebContract;
-  data: TypedDataDefinition<typedData, primaryType>;
+  data: ox__TypedData.Definition<typedData, primaryType>;
   signature: string;
 };
 const MAGIC_VALUE = "0x1626ba7e";
@@ -42,15 +42,19 @@ const MAGIC_VALUE = "0x1626ba7e";
  * @returns A promise that resolves with a boolean indicating if the signature is valid.
  */
 export async function checkContractWalletSignedTypedData<
-  typedData extends TypedData | Record<string, unknown>,
+  typedData extends ox__TypedData.TypedData | Record<string, unknown>,
   primaryType extends keyof typedData | "EIP712Domain" = keyof typedData,
 >(options: CheckContractWalletSignTypedDataOptions<typedData, primaryType>) {
   if (!isHex(options.signature)) {
     throw new Error("The signature must be a valid hex string.");
   }
   const result = await isValidSignature({
     contract: options.contract,
-    hash: hashTypedData(options.data),
+    hash: ox__TypedData.hashStruct({
+      primaryType: options.data.primaryType,
+      data: options.data.message as Record<string, unknown>,
+      types: options.data.types as ox__TypedData.Definition["types"],
+    }),
     signature: options.signature,
   });
   return result === MAGIC_VALUE;

packages/thirdweb/src/utils/signatures/helpers/parseTypedData.ts

@@ -1,25 +1,29 @@
-import type { TypedData } from "abitype";
-import type { TypedDataDefinition } from "viem";
-import { type Hex, hexToNumber, isHex } from "../../encoding/hex.js";
+import * as ox__Hex from "ox/Hex";
+import type * as ox__TypedData from "ox/TypedData";
+import type { Hex } from "../../encoding/hex.js";
 
-type UnknownDomain = unknown & { chainId?: unknown }; // TODO: create our own typed data types so this is cleaner
-type HexDomain = unknown & { chainId: Hex }; // TODO: create our own typed data types so this is cleaner
+type UnknownDomain = unknown & { chainId?: unknown };
+type HexDomain = unknown & { chainId: Hex };
 
 /**
  * @internal
  */
 export function parseTypedData<
-  typedData extends TypedData | Record<string, unknown> = TypedData,
+  typedData extends
+    | ox__TypedData.TypedData
+    | Record<string, unknown> = ox__TypedData.TypedData,
   primaryType extends keyof typedData | "EIP712Domain" = keyof typedData,
 >(
-  typedData: TypedDataDefinition<typedData, primaryType>,
-): TypedDataDefinition<typedData, primaryType> {
+  typedData: ox__TypedData.Definition<typedData, primaryType>,
+): ox__TypedData.Definition<typedData, primaryType> {
   const domain = typedData.domain as UnknownDomain;
-  if (domain?.chainId !== undefined && isHex(domain.chainId)) {
+  if (domain?.chainId !== undefined && ox__Hex.validate(domain.chainId)) {
     typedData.domain = {
       ...(typedData.domain as HexDomain),
-      chainId: hexToNumber((typedData.domain as unknown as HexDomain).chainId),
-    } as unknown as TypedDataDefinition<typedData, primaryType>["domain"];
+      chainId: ox__Hex.toNumber(
+        (typedData.domain as unknown as HexDomain).chainId,
+      ),
+    } as unknown as ox__TypedData.Definition<typedData, primaryType>["domain"];
   }
   return typedData;
 }

packages/thirdweb/src/wallets/coinbase/coinbaseWebSDK.ts

@@ -1,12 +1,7 @@
 import type { ProviderInterface } from "@coinbase/wallet-sdk";
 import type { Address } from "abitype";
-import {
-  type SignTypedDataParameters,
-  getTypesForEIP712Domain,
-  isHex,
-  serializeTypedData,
-  validateTypedData,
-} from "viem";
+import * as ox__Hex from "ox/Hex";
+import * as ox__TypedData from "ox/TypedData";
 import type { Account, Wallet } from "../interfaces/wallet.js";
 import type { SendTransactionOption } from "../interfaces/wallet.js";
 import type { AppMetadata, DisconnectFn, SwitchChainFn } from "../types.js";
@@ -338,29 +333,30 @@ function createAccount({
         method: "personal_sign",
         params: [messageToSign, account.address],
       });
-      if (!isHex(res)) {
+      if (!ox__Hex.validate(res)) {
         throw new Error("Invalid signature returned");
       }
       return res;
     },
-    async signTypedData(_typedData) {
+    async signTypedData(typedData) {
       if (!account.address) {
         throw new Error("Provider not setup");
       }
-      const typedData = parseTypedData(_typedData);
-      const { domain, message, primaryType } =
-        typedData as unknown as SignTypedDataParameters;
+
+      const { domain, message, primaryType } = parseTypedData(
+        typedData,
+      ) as ox__TypedData.Definition;
 
       const types = {
-        EIP712Domain: getTypesForEIP712Domain({ domain }),
+        EIP712Domain: ox__TypedData.extractEip712DomainTypes(domain),
         ...typedData.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 });
+      ox__TypedData.validate({ domain, message, primaryType, types });
 
-      const stringifiedData = serializeTypedData({
+      const stringifiedData = ox__TypedData.serialize({
         domain: domain ?? {},
         message,
         primaryType,
@@ -371,7 +367,7 @@ function createAccount({
         method: "eth_signTypedData_v4",
         params: [account.address, stringifiedData],
       });
-      if (!isHex(res)) {
+      if (!ox__Hex.validate(res)) {
         throw new Error("Invalid signed payload returned");
       }
       return res;

packages/thirdweb/src/wallets/in-app/core/actions/sign-typed-data.enclave.ts

@@ -1,21 +1,20 @@
-import type { TypedData } from "abitype";
-import type { TypedDataDefinition } from "viem";
+import type * as ox__TypedData from "ox/TypedData";
 import type { ThirdwebClient } from "../../../../client/client.js";
 import { getThirdwebBaseUrl } from "../../../../utils/domains.js";
 import { getClientFetch } from "../../../../utils/fetch.js";
 import { stringify } from "../../../../utils/json.js";
 import type { ClientScopedStorage } from "../authentication/client-scoped-storage.js";
 
 export async function signTypedData<
-  const typedData extends TypedData | Record<string, unknown>,
+  const typedData extends ox__TypedData.TypedData | Record<string, unknown>,
   primaryType extends keyof typedData | "EIP712Domain" = keyof typedData,
 >({
   client,
   payload,
   storage,
 }: {
   client: ThirdwebClient;
-  payload: TypedDataDefinition<typedData, primaryType>;
+  payload: ox__TypedData.Definition<typedData, primaryType>;
   storage: ClientScopedStorage;
 }) {
   const authToken = await storage.getAuthCookie();

packages/thirdweb/src/wallets/interfaces/wallet.ts

@@ -1,11 +1,6 @@
 import type { Address } from "abitype";
-import type {
-  Hex,
-  SignableMessage,
-  TransactionSerializable,
-  TypedData,
-  TypedDataDefinition,
-} from "viem";
+import type * as ox__TypedData from "ox/TypedData";
+import type { Hex, SignableMessage, TransactionSerializable } from "viem";
 import type { Chain } from "../../chains/types.js";
 import type {
   EIP712TransactionOptions,
@@ -191,10 +186,10 @@ export type Account = {
    * ```
    */
   signTypedData: <
-    const typedData extends TypedData | Record<string, unknown>,
+    const typedData extends ox__TypedData.TypedData | Record<string, unknown>,
     primaryType extends keyof typedData | "EIP712Domain" = keyof typedData,
   >(
-    _typedData: TypedDataDefinition<typedData, primaryType>,
+    _typedData: ox__TypedData.Definition<typedData, primaryType>,
   ) => Promise<Hex>;
 
   // OPTIONAL

packages/thirdweb/src/wallets/private-key.ts

@@ -1,10 +1,6 @@
 import { secp256k1 } from "@noble/curves/secp256k1";
-import type {
-  SignableMessage,
-  TransactionSerializable,
-  TypedData,
-  TypedDataDefinition,
-} from "viem";
+import type * as ox__TypedData from "ox/TypedData";
+import type { SignableMessage, TransactionSerializable } from "viem";
 import { publicKeyToAddress } from "viem/utils";
 import { getCachedChain } from "../chains/utils.js";
 import type { ThirdwebClient } from "../client/client.js";
@@ -99,10 +95,10 @@ export function privateKeyToAccount(
       });
     },
     signTypedData: async <
-      const typedData extends TypedData | Record<string, unknown>,
+      const typedData extends ox__TypedData.TypedData | Record<string, unknown>,
       primaryType extends keyof typedData | "EIP712Domain" = keyof typedData,
     >(
-      _typedData: TypedDataDefinition<typedData, primaryType>,
+      _typedData: ox__TypedData.Definition<typedData, primaryType>,
     ) => {
       return signTypedData({
         ..._typedData,

packages/thirdweb/src/wallets/smart/index.ts

@@ -1,11 +1,5 @@
-import {
-  type SignableMessage,
-  type TypedData,
-  type TypedDataDefinition,
-  type TypedDataDomain,
-  hashTypedData,
-  maxUint96,
-} from "viem";
+import * as ox__TypedData from "ox/TypedData";
+import { type SignableMessage, maxUint96 } from "viem";
 import type { Chain } from "../../chains/types.js";
 import { getCachedChain } from "../../chains/utils.js";
 import type { ThirdwebClient } from "../../client/client.js";
@@ -140,7 +134,6 @@ export async function connectSmartWallet(
     chain: chain,
   });
 
-  // TODO: listen for chainChanged event on the personal wallet and emit the disconnect event on the smart wallet
   const accountAddress = await predictAddress({
     factoryContract,
     adminAddress: personalAccount.address,
@@ -334,9 +327,9 @@ async function createSmartAccount(
       );
     },
     async signTypedData<
-      const typedData extends TypedData | Record<string, unknown>,
+      const typedData extends ox__TypedData.TypedData | Record<string, unknown>,
       primaryType extends keyof typedData | "EIP712Domain" = keyof typedData,
-    >(_typedData: TypedDataDefinition<typedData, primaryType>) {
+    >(_typedData: ox__TypedData.Definition<typedData, primaryType>) {
       const typedData = parseTypedData(_typedData);
       const [
         { isContractDeployed },
@@ -353,7 +346,7 @@ async function createSmartAccount(
       ]);
       const isSelfVerifyingContract =
         (
-          typedData.domain as TypedDataDomain
+          typedData.domain as ox__TypedData.Domain
         )?.verifyingContract?.toLowerCase() ===
         accountContract.address?.toLowerCase();
 
@@ -376,7 +369,11 @@ async function createSmartAccount(
         });
       }
 
-      const originalMsgHash = hashTypedData(typedData);
+      const originalMsgHash = ox__TypedData.hashStruct({
+        ...typedData,
+        types: typedData.types as ox__TypedData.Definition["types"],
+        data: typedData.message as Record<string, unknown>,
+      });
       // check if the account contract supports EIP721 domain separator based signing
       let factorySupports712 = false;
       try {
@@ -554,9 +551,9 @@ function createZkSyncAccount(args: {
       return connectionOptions.personalAccount.signMessage({ message });
     },
     async signTypedData<
-      const typedData extends TypedData | Record<string, unknown>,
+      const typedData extends ox__TypedData.TypedData | Record<string, unknown>,
       primaryType extends keyof typedData | "EIP712Domain" = keyof typedData,
-    >(_typedData: TypedDataDefinition<typedData, primaryType>) {
+    >(_typedData: ox__TypedData.Definition<typedData, primaryType>) {
       const typedData = parseTypedData(_typedData);
       return connectionOptions.personalAccount.signTypedData(typedData);
     },