thirdweb 5.74.0 → 5.75.0

package/src/utils/signatures/signature-to-hex.ts

@@ -1,6 +1,6 @@
-import { secp256k1 } from "@noble/curves/secp256k1";
-import type { Signature } from "viem";
-import { type Hex, hexToBigInt } from "../encoding/hex.js";
+import * as ox__Hex from "ox/Hex";
+import * as ox__Signature from "ox/Signature";
+import type { Hex } from "../encoding/hex.js";
 
 /**
  * Converts a signature to a hex string.
@@ -25,15 +25,31 @@ import { type Hex, hexToBigInt } from "../encoding/hex.js";
  * ```
  * @utils
  */
-export function signatureToHex(signature: Signature): Hex {
+export function signatureToHex(signature: {
+  r: Hex;
+  s: Hex;
+  v?: bigint | number | Hex | undefined;
+  yParity?: bigint | number | Hex | undefined;
+}): Hex {
   const { r, s, v, yParity } = signature;
-  const yParity_ = (() => {
-    if (yParity === 0 || yParity === 1) return yParity;
-    if (v && (v === 27n || v === 28n || v >= 35n)) return v % 2n === 0n ? 1 : 0;
-    throw new Error("Invalid `v` or `yParity` value");
-  })();
-  return `0x${new secp256k1.Signature(
-    hexToBigInt(r),
-    hexToBigInt(s),
-  ).toCompactHex()}${yParity_ === 0 ? "1b" : "1c"}`;
+  return ox__Signature.toHex(
+    ox__Signature.from(
+      typeof yParity !== "undefined"
+        ? {
+            r,
+            s,
+            yParity: !ox__Hex.validate(yParity)
+              ? ox__Hex.fromNumber(yParity)
+              : yParity,
+          }
+        : {
+            r,
+            s,
+            v:
+              !ox__Hex.validate(v) && typeof v !== "undefined"
+                ? ox__Hex.fromNumber(v)
+                : v,
+          },
+    ),
+  );
 }

package/src/utils/types.ts

@@ -1,3 +1,5 @@
+import type * as ox__Bytes from "ox/Bytes";
+import type * as ox__Hex from "ox/Hex";
 import type { Chain } from "../chains/types.js";
 import type { ThirdwebClient } from "../client/client.js";
 import type { Account } from "../wallets/interfaces/wallet.js";
@@ -17,3 +19,18 @@ export type ClientAndChain = {
 export type ClientAndChainAndAccount = Prettify<
   ClientAndChain & { account: Account }
 >;
+
+/**
+ * A message that can be signed, either as in plaintext or as a raw hex string.
+ */
+export type SignableMessage =
+  | string
+  | {
+      /** Raw data representation of the message. */
+      raw: ox__Hex.Hex | ox__Bytes.Bytes;
+    };
+
+/**
+ * @internal
+ */
+export const maxUint96 = 2n ** 96n - 1n;

package/src/version.ts

@@ -1 +1 @@
-export const version = "5.74.0";
+export const version = "5.75.0";

package/src/wallets/coinbase/coinbase-mobile.test.ts

@@ -0,0 +1,69 @@
+import type { ProviderInterface } from "@coinbase/wallet-sdk";
+import { beforeEach, describe, expect, test, vi } from "vitest";
+import { getCoinbaseMobileProvider } from "./coinbase-mobile.js";
+import type { CoinbaseWalletCreationOptions } from "./coinbase-web.js";
+
+// Mock dependencies
+vi.mock("expo-linking", () => ({
+  addEventListener: vi.fn(),
+}));
+
+vi.mock("@mobile-wallet-protocol/client", () => ({
+  EIP1193Provider: class {
+    constructor() {
+      // biome-ignore lint/correctness/noConstructorReturn: Inside tests
+      return {
+        request: vi.fn(),
+      };
+    }
+  },
+  Wallets: {
+    CoinbaseSmartWallet: {},
+  },
+  handleResponse: vi.fn(),
+}));
+
+vi.mock("@coinbase/wallet-mobile-sdk", () => ({
+  configure: vi.fn(),
+  handleResponse: vi.fn(),
+}));
+
+vi.mock("@coinbase/wallet-mobile-sdk/build/WalletMobileSDKEVMProvider", () => ({
+  WalletMobileSDKEVMProvider: class {
+    constructor() {
+      // biome-ignore lint/correctness/noConstructorReturn: Inside tests
+      return {
+        request: vi.fn(),
+      };
+    }
+  },
+}));
+
+describe("Coinbase Mobile", () => {
+  let provider: undefined | ProviderInterface;
+
+  beforeEach(() => {
+    provider = undefined;
+  });
+
+  test("getCoinbaseMobileProvider initializes smart wallet provider", async () => {
+    const options: CoinbaseWalletCreationOptions = {
+      walletConfig: { options: "smartWalletOnly" },
+      mobileConfig: { callbackURL: "https://example.com" },
+    };
+
+    provider = await getCoinbaseMobileProvider(options);
+    expect(provider).toBeDefined();
+    expect(provider.request).toBeInstanceOf(Function);
+  });
+
+  test("getCoinbaseMobileProvider initializes coinbase app provider", async () => {
+    const options: CoinbaseWalletCreationOptions = {
+      mobileConfig: { callbackURL: "https://example.com" },
+    };
+
+    provider = await getCoinbaseMobileProvider(options);
+    expect(provider).toBeDefined();
+    expect(provider.request).toBeInstanceOf(Function);
+  });
+});

package/src/wallets/coinbase/{coinbaseMobileSDK.ts → coinbase-mobile.ts}

@@ -1,5 +1,5 @@
 import type { ProviderInterface } from "@coinbase/wallet-sdk";
-import type { CoinbaseWalletCreationOptions } from "./coinbaseWebSDK.js";
+import type { CoinbaseWalletCreationOptions } from "./coinbase-web.js";
 
 let _provider: ProviderInterface | undefined;
 

package/src/wallets/coinbase/coinbase-wallet.ts

@@ -67,7 +67,7 @@ export function coinbaseWalletSDK(args: {
     getAccount: () => account,
     autoConnect: async (options) => {
       const { autoConnectCoinbaseWalletSDK } = await import(
-        "./coinbaseWebSDK.js"
+        "./coinbase-web.js"
       );
       const provider = await args.providerFactory();
       const [connectedAccount, connectedChain, doDisconnect, doSwitchChain] =
@@ -87,7 +87,7 @@ export function coinbaseWalletSDK(args: {
       return account;
     },
     connect: async (options) => {
-      const { connectCoinbaseWalletSDK } = await import("./coinbaseWebSDK.js");
+      const { connectCoinbaseWalletSDK } = await import("./coinbase-web.js");
       const provider = await args.providerFactory();
       const [connectedAccount, connectedChain, doDisconnect, doSwitchChain] =
         await connectCoinbaseWalletSDK(options, emitter, provider);

package/src/wallets/coinbase/coinbase-web.test.ts

@@ -0,0 +1,176 @@
+import type { ProviderInterface } from "@coinbase/wallet-sdk";
+import * as ox__Hex from "ox/Hex";
+import * as ox__TypedData from "ox/TypedData";
+import { beforeEach, describe, expect, test, vi } from "vitest";
+import { COINBASE } from "../constants.js";
+import type { Wallet } from "../interfaces/wallet.js";
+import {
+  autoConnectCoinbaseWalletSDK,
+  connectCoinbaseWalletSDK,
+  getCoinbaseWebProvider,
+  isCoinbaseSDKWallet,
+} from "./coinbase-web.js";
+
+// Mock dependencies
+vi.mock("@coinbase/wallet-sdk", () => ({
+  default: class {
+    makeWeb3Provider() {
+      return {
+        request: vi.fn(),
+        on: vi.fn(),
+        removeListener: vi.fn(),
+        disconnect: vi.fn(),
+      };
+    }
+  },
+}));
+
+vi.mock("../../utils/address.js", () => ({
+  getAddress: vi.fn((address) => address),
+}));
+
+vi.mock("../../chains/utils.js", () => ({
+  getCachedChain: vi.fn((chainId) => ({ id: chainId })),
+  getChainMetadata: vi.fn(async (_chain) => ({
+    name: "Test Chain",
+    nativeCurrency: { name: "Test Coin", symbol: "TC", decimals: 18 },
+    explorers: [{ url: "https://explorer.test" }],
+  })),
+}));
+
+vi.mock("../../utils/normalizeChainId.js", () => ({
+  normalizeChainId: vi.fn((chainId) => Number(chainId)),
+}));
+
+vi.mock("ox/Hex", async () => {
+  const actualModule = await vi.importActual("ox/Hex");
+  return {
+    ...actualModule,
+    validate: vi.fn(() => true),
+    toNumber: vi.fn((hex) => Number.parseInt(hex, 16)),
+  };
+});
+
+vi.mock("ox/TypedData", () => ({
+  extractEip712DomainTypes: vi.fn(() => []),
+  validate: vi.fn(),
+  serialize: vi.fn(() => "serializedData"),
+}));
+
+describe("Coinbase Web", () => {
+  let provider: ProviderInterface;
+
+  beforeEach(async () => {
+    provider = await getCoinbaseWebProvider();
+  });
+
+  test("getCoinbaseWebProvider initializes provider", async () => {
+    expect(provider).toBeDefined();
+    expect(provider.request).toBeInstanceOf(Function);
+  });
+
+  test("isCoinbaseSDKWallet returns true for Coinbase wallet", () => {
+    const wallet: Wallet = { id: COINBASE } as Wallet;
+    expect(isCoinbaseSDKWallet(wallet)).toBe(true);
+  });
+
+  test("isCoinbaseSDKWallet returns false for non-Coinbase wallet", () => {
+    const wallet: Wallet = { id: "other" } as unknown as Wallet;
+    expect(isCoinbaseSDKWallet(wallet)).toBe(false);
+  });
+
+  test("connectCoinbaseWalletSDK connects to the wallet", async () => {
+    provider.request = vi
+      .fn()
+      .mockResolvedValueOnce(["0x123"])
+      .mockResolvedValueOnce("0x1");
+    const emitter = { emit: vi.fn() };
+    const options = { client: {} };
+
+    const [account, chain] = await connectCoinbaseWalletSDK(
+      // biome-ignore lint/suspicious/noExplicitAny: Inside tests
+      options as any,
+      // biome-ignore lint/suspicious/noExplicitAny: Inside tests
+      emitter as any,
+      provider,
+    );
+
+    expect(account.address).toBe("0x123");
+    expect(chain.id).toBe(1);
+  });
+
+  test("autoConnectCoinbaseWalletSDK auto-connects to the wallet", async () => {
+    provider.request = vi
+      .fn()
+      .mockResolvedValueOnce(["0x123"])
+      .mockResolvedValueOnce("0x1");
+    const emitter = { emit: vi.fn() };
+    const options = { client: {} };
+
+    const [account, chain] = await autoConnectCoinbaseWalletSDK(
+      // biome-ignore lint/suspicious/noExplicitAny: Inside tests
+      options as any,
+      // biome-ignore lint/suspicious/noExplicitAny: Inside tests
+      emitter as any,
+      provider,
+    );
+
+    expect(account.address).toBe("0x123");
+    expect(chain.id).toBe(1);
+  });
+
+  test("signMessage uses ox__Hex for validation", async () => {
+    const account = {
+      address: "0x123",
+      signMessage: async ({ message }: { message: string }) => {
+        const messageToSign = `0x${ox__Hex.fromString(message)}`;
+        const res = await provider.request({
+          method: "personal_sign",
+          params: [messageToSign, account.address],
+        });
+        expect(ox__Hex.validate(res)).toBe(true);
+        return res;
+      },
+    };
+
+    provider.request = vi.fn().mockResolvedValue("0xsignature");
+    const signature = await account.signMessage({ message: "hello" });
+    expect(signature).toBe("0xsignature");
+  });
+
+  test("signTypedData uses ox__TypedData for serialization", async () => {
+    const account = {
+      address: "0x123",
+      // biome-ignore lint/suspicious/noExplicitAny: Inside tests
+      signTypedData: async (typedData: any) => {
+        const { domain, message, primaryType } = typedData;
+        const types = {
+          EIP712Domain: ox__TypedData.extractEip712DomainTypes(domain),
+          ...typedData.types,
+        };
+        ox__TypedData.validate({ domain, message, primaryType, types });
+        const stringifiedData = ox__TypedData.serialize({
+          domain: domain ?? {},
+          message,
+          primaryType,
+          types,
+        });
+        const res = await provider.request({
+          method: "eth_signTypedData_v4",
+          params: [account.address, stringifiedData],
+        });
+        expect(ox__Hex.validate(res)).toBe(true);
+        return res;
+      },
+    };
+
+    provider.request = vi.fn().mockResolvedValue("0xsignature");
+    const signature = await account.signTypedData({
+      domain: {},
+      message: {},
+      primaryType: "EIP712Domain",
+      types: {},
+    });
+    expect(signature).toBe("0xsignature");
+  });
+});

package/src/wallets/coinbase/{coinbaseWebSDK.ts → coinbase-web.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";
@@ -25,7 +20,7 @@ import {
   stringToHex,
   uint8ArrayToHex,
 } from "../../utils/encoding/hex.js";
-import { parseTypedData } from "../../utils/signatures/helpers/parseTypedData.js";
+import { parseTypedData } from "../../utils/signatures/helpers/parse-typed-data.js";
 import { COINBASE } from "../constants.js";
 import type {
   GetCallsStatusResponse,
@@ -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;

package/src/wallets/create-wallet.ts

@@ -17,7 +17,7 @@ import { webLocalStorage } from "../utils/storage/webStorage.js";
 import { isMobile } from "../utils/web/isMobile.js";
 import { openWindow } from "../utils/web/openWindow.js";
 import { coinbaseWalletSDK } from "./coinbase/coinbase-wallet.js";
-import { getCoinbaseWebProvider } from "./coinbase/coinbaseWebSDK.js";
+import { getCoinbaseWebProvider } from "./coinbase/coinbase-web.js";
 import { COINBASE } from "./constants.js";
 import { isEcosystemWallet } from "./ecosystem/is-ecosystem-wallet.js";
 import { ecosystemWallet } from "./in-app/web/ecosystem.js";

package/src/wallets/eip5792/get-calls-status.ts

@@ -1,5 +1,5 @@
 import type { ThirdwebClient } from "../../client/client.js";
-import { isCoinbaseSDKWallet } from "../coinbase/coinbaseWebSDK.js";
+import { isCoinbaseSDKWallet } from "../coinbase/coinbase-web.js";
 import { isInAppWallet } from "../in-app/core/wallet/index.js";
 import { getInjectedProvider } from "../injected/index.js";
 import type { Wallet } from "../interfaces/wallet.js";
@@ -64,7 +64,7 @@ export async function getCallsStatus({
 
   if (isCoinbaseSDKWallet(wallet)) {
     const { coinbaseSDKWalletGetCallsStatus } = await import(
-      "../coinbase/coinbaseWebSDK.js"
+      "../coinbase/coinbase-web.js"
     );
     return coinbaseSDKWalletGetCallsStatus({ wallet, bundleId });
   }

package/src/wallets/eip5792/get-capabilities.ts

@@ -1,5 +1,5 @@
 import type { Prettify } from "../../utils/type-utils.js";
-import { isCoinbaseSDKWallet } from "../coinbase/coinbaseWebSDK.js";
+import { isCoinbaseSDKWallet } from "../coinbase/coinbase-web.js";
 import { isInAppWallet } from "../in-app/core/wallet/index.js";
 import { getInjectedProvider } from "../injected/index.js";
 import type { Wallet } from "../interfaces/wallet.js";
@@ -62,7 +62,7 @@ export async function getCapabilities<const ID extends WalletId = WalletId>({
 
   if (isCoinbaseSDKWallet(wallet)) {
     const { coinbaseSDKWalletGetCapabilities } = await import(
-      "../coinbase/coinbaseWebSDK.js"
+      "../coinbase/coinbase-web.js"
     );
     return coinbaseSDKWalletGetCapabilities({ wallet });
   }

package/src/wallets/eip5792/send-calls.ts

@@ -11,7 +11,7 @@ import {
   resolvePromisedValue,
 } from "../../utils/promise/resolve-promised-value.js";
 import type { OneOf } from "../../utils/type-utils.js";
-import { isCoinbaseSDKWallet } from "../coinbase/coinbaseWebSDK.js";
+import { isCoinbaseSDKWallet } from "../coinbase/coinbase-web.js";
 import { isInAppWallet } from "../in-app/core/wallet/index.js";
 import { getInjectedProvider } from "../injected/index.js";
 import type { Wallet } from "../interfaces/wallet.js";
@@ -181,7 +181,7 @@ export async function sendCalls<const ID extends WalletId>(
 
   if (isCoinbaseSDKWallet(wallet)) {
     const { coinbaseSDKWalletSendCalls } = await import(
-      "../coinbase/coinbaseWebSDK.js"
+      "../coinbase/coinbase-web.js"
     );
     return coinbaseSDKWalletSendCalls({
       wallet,

package/src/wallets/eip5792/show-calls-status.ts

@@ -1,4 +1,4 @@
-import { isCoinbaseSDKWallet } from "../coinbase/coinbaseWebSDK.js";
+import { isCoinbaseSDKWallet } from "../coinbase/coinbase-web.js";
 import { isInAppWallet } from "../in-app/core/wallet/index.js";
 import { getInjectedProvider } from "../injected/index.js";
 import type { Wallet } from "../interfaces/wallet.js";
@@ -51,7 +51,7 @@ export async function showCallsStatus({
 
   if (isCoinbaseSDKWallet(wallet)) {
     const { coinbaseSDKWalletShowCallsStatus } = await import(
-      "../coinbase/coinbaseWebSDK.js"
+      "../coinbase/coinbase-web.js"
     );
     await coinbaseSDKWalletShowCallsStatus({ wallet, bundleId });
     return;

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

@@ -1,5 +1,4 @@
-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";
@@ -7,7 +6,7 @@ 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,
@@ -15,7 +14,7 @@ export async function signTypedData<
   storage,
 }: {
   client: ThirdwebClient;
-  payload: TypedDataDefinition<typedData, primaryType>;
+  payload: ox__TypedData.Definition<typedData, primaryType>;
   storage: ClientScopedStorage;
 }) {
   const authToken = await storage.getAuthCookie();

package/src/wallets/in-app/core/wallet/enclave-wallet.ts

@@ -6,7 +6,7 @@ import { eth_sendRawTransaction } from "../../../../rpc/actions/eth_sendRawTrans
 import { getRpcClient } from "../../../../rpc/rpc.js";
 import { getAddress } from "../../../../utils/address.js";
 import { type Hex, toHex } from "../../../../utils/encoding/hex.js";
-import { parseTypedData } from "../../../../utils/signatures/helpers/parseTypedData.js";
+import { parseTypedData } from "../../../../utils/signatures/helpers/parse-typed-data.js";
 import type { Prettify } from "../../../../utils/type-utils.js";
 import type {
   Account,

package/src/wallets/in-app/web/lib/iframe-wallet.ts

@@ -8,7 +8,7 @@ import { getRpcClient } from "../../../../rpc/rpc.js";
 import { getAddress } from "../../../../utils/address.js";
 import { getThirdwebDomains } from "../../../../utils/domains.js";
 import { type Hex, hexToString } from "../../../../utils/encoding/hex.js";
-import { parseTypedData } from "../../../../utils/signatures/helpers/parseTypedData.js";
+import { parseTypedData } from "../../../../utils/signatures/helpers/parse-typed-data.js";
 import type { Prettify } from "../../../../utils/type-utils.js";
 import type {
   Account,
@@ -316,7 +316,7 @@ export class IFrameWallet implements IWebWallet {
                 parsedTypedData.types as SignerProcedureTypes["signTypedDataV4"]["types"],
               message:
                 parsedTypedData.message as SignerProcedureTypes["signTypedDataV4"]["message"],
-              chainId: chainId || 1,
+              chainId: Number.parseInt(BigInt(chainId || 1).toString()),
               partnerId,
               rpcEndpoint: `https://${chainId}.${RPC_URL}`, // TODO (ew) shouldnt be needed
             },

package/src/wallets/injected/index.ts

@@ -16,7 +16,7 @@ import {
   stringToHex,
   uint8ArrayToHex,
 } from "../../utils/encoding/hex.js";
-import { parseTypedData } from "../../utils/signatures/helpers/parseTypedData.js";
+import { parseTypedData } from "../../utils/signatures/helpers/parse-typed-data.js";
 import type { InjectedSupportedWalletIds } from "../__generated__/wallet-ids.js";
 import type { Account, SendTransactionOption } from "../interfaces/wallet.js";
 import type { DisconnectFn, SwitchChainFn } from "../types.js";

package/src/wallets/interfaces/wallet.ts

@@ -1,16 +1,12 @@
 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 } from "viem";
 import type { Chain } from "../../chains/types.js";
 import type {
   EIP712TransactionOptions,
   PreparedTransaction,
 } from "../../transaction/prepare-transaction.js";
+import type { SerializableTransaction } from "../../transaction/serialize-transaction.js";
 import type { SendTransactionResult } from "../../transaction/types.js";
 import type { WalletEmitter } from "../wallet-emitter.js";
 import type {
@@ -20,7 +16,7 @@ import type {
   WalletId,
 } from "../wallet-types.js";
 
-export type SendTransactionOption = TransactionSerializable & {
+export type SendTransactionOption = SerializableTransaction & {
   chainId: number;
   eip712?: EIP712TransactionOptions;
 };
@@ -191,10 +187,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
@@ -222,7 +218,7 @@ export type Account = {
    * }
    * ```
    */
-  signTransaction?: (tx: TransactionSerializable) => Promise<Hex>;
+  signTransaction?: (tx: SerializableTransaction) => Promise<Hex>;
   /**
    * Send the given array of transactions to the blockchain in a single batch
    *

package/src/wallets/native/create-wallet.ts

@@ -6,8 +6,8 @@ import type { Chain } from "../../chains/types.js";
 import { getCachedChainIfExists } from "../../chains/utils.js";
 import { nativeLocalStorage } from "../../utils/storage/nativeStorage.js";
 import type { WCSupportedWalletIds } from "../__generated__/wallet-ids.js";
+import { getCoinbaseMobileProvider } from "../coinbase/coinbase-mobile.js";
 import { coinbaseWalletSDK } from "../coinbase/coinbase-wallet.js";
-import { getCoinbaseMobileProvider } from "../coinbase/coinbaseMobileSDK.js";
 import { COINBASE } from "../constants.js";
 import { isEcosystemWallet } from "../ecosystem/is-ecosystem-wallet.js";
 import { ecosystemWallet } from "../in-app/native/ecosystem.js";