thirdweb 5.66.0-nightly-880c3453ee8fc0fabbde0afb752a17894cd579a0-20241106000325 → 5.67.0-nightly-734707e28b829262a1b40f7db8c005d2adeaeaf9-20241107000509

package/src/react/web/ui/SiteEmbed.tsx

@@ -17,14 +17,14 @@ import { useActiveWallet } from "../../core/hooks/wallets/useActiveWallet.js";
  *
  * @param {Object} props - The props to pass to the iframe
  * @param {String} props.src - The URL of the site to embed
- * @param {ThirdwebClient} props.client - The client to use for the embedded site
- * @param {Ecosystem} [props.ecosystem] - The ecosystem to use for the embedded site
+ * @param {ThirdwebClient} props.client - The current site's thirdweb client
+ * @param {Ecosystem} [props.ecosystem] - The ecosystem to use for the wallet connection in the embedded site
  *
  * @example
  * ```tsx
  * import { SiteEmbed } from "thirdweb/react";
  *
- * <SiteEmbed src="https://thirdweb.com" clientId="thirdweb-client-id" />
+ * <SiteEmbed src="https://thirdweb.com" client={thirdwebClient} ecosystem={{ id: "ecosystem.thirdweb" }} />
  * ```
  */
 export function SiteEmbed({

package/src/react/web/ui/SiteLink.test.tsx

@@ -0,0 +1,48 @@
+import { describe, expect, it } from "vitest";
+import { render, waitFor } from "../../../../test/src/react-render.js";
+import { TEST_CLIENT } from "../../../../test/src/test-clients.js";
+import { SiteLink } from "./SiteLink.js";
+
+describe("SiteLink", () => {
+  it("renders anchor with correct href", () => {
+    const testUrl = "https://example.com/";
+    const { container } = render(
+      <SiteLink href={testUrl} client={TEST_CLIENT}>
+        Test Link
+      </SiteLink>,
+    );
+
+    const anchor = container.querySelector("a");
+    expect(anchor).toBeTruthy();
+    expect(anchor?.href).toBe(testUrl);
+    expect(anchor?.textContent).toBe("Test Link");
+  });
+
+  it("throws error if clientId is not provided", () => {
+    const testUrl = "https://example.com/";
+    expect(() =>
+      render(
+        // biome-ignore lint/suspicious/noExplicitAny: testing invalid input
+        <SiteLink href={testUrl} client={{} as any}>
+          Test Link
+        </SiteLink>,
+      ),
+    ).toThrow("The SiteLink client must have a clientId");
+  });
+
+  it("adds wallet params to url when wallet is connected", async () => {
+    const testUrl = "https://example.com/";
+    const { container } = render(
+      <SiteLink href={testUrl} client={TEST_CLIENT}>
+        Test Link
+      </SiteLink>,
+      {
+        setConnectedWallet: true,
+      },
+    );
+
+    const anchor = container.querySelector("a");
+    expect(anchor).toBeTruthy();
+    await waitFor(() => expect(anchor?.href).toContain("walletId="));
+  });
+});

package/src/react/web/ui/SiteLink.tsx

@@ -0,0 +1,86 @@
+"use client";
+import { useQuery } from "@tanstack/react-query";
+import type { ThirdwebClient } from "../../../client/client.js";
+import { getLastAuthProvider } from "../../../react/core/utils/storage.js";
+import { webLocalStorage } from "../../../utils/storage/webStorage.js";
+import { isEcosystemWallet } from "../../../wallets/ecosystem/is-ecosystem-wallet.js";
+import { ClientScopedStorage } from "../../../wallets/in-app/core/authentication/client-scoped-storage.js";
+import type { Ecosystem } from "../../../wallets/in-app/core/wallet/types.js";
+import { useActiveWallet } from "../../core/hooks/wallets/useActiveWallet.js";
+
+/**
+ * Creates a link to another thirdweb-supported site with wallet connection parameters.
+ *
+ * @note The target site must support the connected wallet (ecosystem or in-app).
+ *
+ * @param {Object} props - The props to pass to the anchor tag
+ * @param {String} props.href - The URL of the site to link to
+ * @param {ThirdwebClient} props.client - The current site's thirdweb client
+ * @param {Ecosystem} [props.ecosystem] - The ecosystem to use for the wallet connection in the target site
+ * @param {React.ReactNode} props.children - The content to render inside the link
+ *
+ * @example
+ * ```tsx
+ * import { SiteLink } from "thirdweb/react";
+ *
+ * <SiteLink href="https://thirdweb.com" client={thirdwebClient} ecosystem={{ id: "ecosystem.thirdweb" }}>
+ *   Visit Site
+ * </SiteLink>
+ * ```
+ */
+export function SiteLink({
+  href,
+  client,
+  ecosystem,
+  children,
+  ...props
+}: {
+  href: string;
+  client: ThirdwebClient;
+  ecosystem?: Ecosystem;
+  children: React.ReactNode;
+} & Omit<React.AnchorHTMLAttributes<HTMLAnchorElement>, "href">) {
+  if (!client.clientId) {
+    throw new Error("The SiteLink client must have a clientId");
+  }
+
+  const activeWallet = useActiveWallet();
+  const walletId = activeWallet?.id;
+
+  const {
+    data: { authProvider, authCookie } = {},
+  } = useQuery({
+    queryKey: ["site-link", walletId, href, client.clientId, ecosystem],
+    enabled:
+      activeWallet && (isEcosystemWallet(activeWallet) || walletId === "inApp"),
+    queryFn: async () => {
+      const storage = new ClientScopedStorage({
+        storage: webLocalStorage,
+        clientId: client.clientId,
+        ecosystem,
+      });
+
+      const authProvider = await getLastAuthProvider(webLocalStorage);
+      const authCookie = await storage.getAuthCookie();
+
+      return { authProvider, authCookie };
+    },
+  });
+
+  const url = new URL(href);
+  if (walletId) {
+    url.searchParams.set("walletId", walletId);
+  }
+  if (authProvider) {
+    url.searchParams.set("authProvider", authProvider);
+  }
+  if (authCookie) {
+    url.searchParams.set("authCookie", authCookie);
+  }
+
+  return (
+    <a href={encodeURI(url.toString())} {...props}>
+      {children}
+    </a>
+  );
+}

package/src/react/web/wallets/shared/PassKeyLogin.tsx

@@ -160,7 +160,8 @@ function LoginScreen(props: {
         await setLastAuthProvider("passkey", webLocalStorage);
       }
       done();
-    } catch {
+    } catch (e) {
+      console.error("Failed to login with passkey", e);
       setStatus("error");
     }
   }

package/src/utils/encoding/helpers/assert-size.test.ts

@@ -0,0 +1,47 @@
+import { describe, expect, it } from "vitest";
+import { assertSize } from "./assert-size.js";
+
+describe("assertSize", () => {
+  it("should not throw an error for hex strings within the specified size", () => {
+    expect(() => assertSize("0x1a4", { size: 2 })).not.toThrow();
+    expect(() => assertSize("0x1234", { size: 2 })).not.toThrow();
+  });
+
+  it("should throw an error for hex strings exceeding the specified size", () => {
+    expect(() => assertSize("0x123456", { size: 2 })).toThrow(
+      "Size overflow: 3 > 2",
+    );
+    expect(() => assertSize("0xabcdef", { size: 2 })).toThrow(
+      "Size overflow: 3 > 2",
+    );
+  });
+
+  it("should not throw an error for Uint8Array within the specified size", () => {
+    expect(() =>
+      assertSize(new Uint8Array([1, 2, 3]), { size: 3 }),
+    ).not.toThrow();
+    expect(() => assertSize(new Uint8Array([]), { size: 0 })).not.toThrow();
+  });
+
+  it("should throw an error for Uint8Array exceeding the specified size", () => {
+    expect(() => assertSize(new Uint8Array([1, 2, 3, 4]), { size: 3 })).toThrow(
+      "Size overflow: 4 > 3",
+    );
+  });
+
+  it("should not throw an error for empty hex strings", () => {
+    expect(() => assertSize("0x", { size: 0 })).not.toThrow();
+  });
+
+  it("should handle boundary conditions correctly", () => {
+    expect(() => assertSize("0x12", { size: 1 })).not.toThrow();
+    expect(() => assertSize("0x12", { size: 0 })).toThrow(
+      "Size overflow: 1 > 0",
+    );
+  });
+
+  it("should not throw an error for hex strings exactly at the specified size", () => {
+    expect(() => assertSize("0x12", { size: 1 })).not.toThrow();
+    expect(() => assertSize("0x1234", { size: 2 })).not.toThrow();
+  });
+});

package/src/utils/encoding/helpers/byte-size.test.ts

@@ -0,0 +1,36 @@
+import { describe, expect, it } from "vitest";
+import { byteSize } from "./byte-size.js";
+
+describe("byteSize", () => {
+  it('should calculate the byte size for a valid hex string with "0x" prefix', () => {
+    expect(byteSize("0x1a4")).toBe(2); // "1a4" is 1 byte + 1 nibble = 2 bytes
+    expect(byteSize("0x123456")).toBe(3); // "123456" is 3 bytes
+  });
+
+  it("should return 0 for an empty hex string", () => {
+    expect(byteSize("0x")).toBe(0);
+  });
+
+  it("should calculate the byte size for a Uint8Array", () => {
+    expect(byteSize(new Uint8Array([1, 2, 3]))).toBe(3);
+    expect(byteSize(new Uint8Array([]))).toBe(0);
+  });
+
+  it('should handle a single byte hex string with "0x" prefix', () => {
+    expect(byteSize("0x1")).toBe(1); // "1" is half a byte, treated as 1 byte
+    expect(byteSize("0x12")).toBe(1); // "12" is 1 byte
+  });
+
+  it("should handle longer hex strings", () => {
+    expect(byteSize("0x1234567890abcdef")).toBe(8); // "1234567890abcdef" is 8 bytes
+    expect(byteSize("0xabcdef")).toBe(3); // "abcdef" is 3 bytes
+  });
+
+  it("should return 0 for non-hex string inputs in Uint8Array form", () => {
+    expect(byteSize(new Uint8Array([]))).toBe(0); // Empty Uint8Array
+  });
+
+  it('should handle strings that are not valid hex but start with "0x"', () => {
+    expect(byteSize("0xg")).toBe(1); // Not a valid hex string
+  });
+});

package/src/utils/encoding/helpers/charcode-to-base-16.test.ts

@@ -0,0 +1,39 @@
+import { describe, expect, it } from "vitest";
+import { charCodeToBase16 } from "./charcode-to-base-16.js";
+
+describe("charCodeToBase16", () => {
+  it("should return correct values for digits (0-9)", () => {
+    expect(charCodeToBase16("0".charCodeAt(0))).toBe(0);
+    expect(charCodeToBase16("5".charCodeAt(0))).toBe(5);
+    expect(charCodeToBase16("9".charCodeAt(0))).toBe(9);
+  });
+
+  it("should return correct values for uppercase letters (A-F)", () => {
+    expect(charCodeToBase16("A".charCodeAt(0))).toBe(10);
+    expect(charCodeToBase16("C".charCodeAt(0))).toBe(12);
+    expect(charCodeToBase16("F".charCodeAt(0))).toBe(15);
+  });
+
+  it("should return correct values for lowercase letters (a-f)", () => {
+    expect(charCodeToBase16("a".charCodeAt(0))).toBe(10);
+    expect(charCodeToBase16("c".charCodeAt(0))).toBe(12);
+    expect(charCodeToBase16("f".charCodeAt(0))).toBe(15);
+  });
+
+  // Test cases for invalid inputs
+  it("should return undefined for invalid inputs", () => {
+    expect(charCodeToBase16("G".charCodeAt(0))).toBeUndefined();
+    expect(charCodeToBase16("z".charCodeAt(0))).toBeUndefined();
+    expect(charCodeToBase16(" ".charCodeAt(0))).toBeUndefined();
+    expect(charCodeToBase16("!".charCodeAt(0))).toBeUndefined();
+  });
+
+  it("should handle edge cases correctly", () => {
+    expect(charCodeToBase16("0".charCodeAt(0) - 1)).toBeUndefined(); // Just below '0'
+    expect(charCodeToBase16("9".charCodeAt(0) + 1)).toBeUndefined(); // Just above '9'
+    expect(charCodeToBase16("A".charCodeAt(0) - 1)).toBeUndefined(); // Just below 'A'
+    expect(charCodeToBase16("F".charCodeAt(0) + 1)).toBeUndefined(); // Just above 'F'
+    expect(charCodeToBase16("a".charCodeAt(0) - 1)).toBeUndefined(); // Just below 'a'
+    expect(charCodeToBase16("f".charCodeAt(0) + 1)).toBeUndefined(); // Just above 'f'
+  });
+});

package/src/utils/encoding/helpers/is-hext.test.ts

@@ -0,0 +1,54 @@
+import { describe, expect, it } from "vitest";
+import { isHex } from "./is-hex.js";
+
+describe("isHex", () => {
+  it('should return true for valid hex strings with "0x" prefix in strict mode', () => {
+    expect(isHex("0x1a4", { strict: true })).toBe(true);
+    expect(isHex("0xABCDEF", { strict: true })).toBe(true);
+  });
+
+  it('should return false for hex strings without "0x" prefix in strict mode', () => {
+    expect(isHex("1a4", { strict: true })).toBe(false);
+    expect(isHex("abcdef", { strict: true })).toBe(false);
+  });
+
+  it('should return true for valid hex strings with or without "0x" prefix in non-strict mode', () => {
+    expect(isHex("0x1a4", { strict: false })).toBe(true);
+    expect(isHex("1a4", { strict: false })).toBe(false);
+  });
+
+  it("should return false for invalid hex strings in strict mode", () => {
+    expect(isHex("0x1g4", { strict: true })).toBe(false);
+    expect(isHex("0xZXY", { strict: true })).toBe(false);
+  });
+
+  it("should return false for invalid hex strings in non-strict mode", () => {
+    expect(isHex("0x1g4", { strict: false })).toBe(true);
+    expect(isHex("0xZXY", { strict: false })).toBe(true);
+  });
+
+  it("should return false for non-string inputs", () => {
+    expect(isHex(123, { strict: true })).toBe(false);
+    expect(isHex(null, { strict: true })).toBe(false);
+    expect(isHex(undefined, { strict: true })).toBe(false);
+    expect(isHex({}, { strict: true })).toBe(false);
+  });
+
+  it("should return false for empty strings", () => {
+    expect(isHex("", { strict: true })).toBe(false);
+    expect(isHex("", { strict: false })).toBe(false);
+  });
+
+  it("should return true for valid empty hex prefix in non-strict mode", () => {
+    expect(isHex("0x", { strict: false })).toBe(true);
+  });
+
+  it("should return true for valid empty hex prefix in strict mode", () => {
+    expect(isHex("0x", { strict: true })).toBe(true);
+  });
+
+  it("should use strict mode by default", () => {
+    expect(isHex("0x1a4")).toBe(true);
+    expect(isHex("1a4")).toBe(false);
+  });
+});

package/src/utils/encoding/to-bytes.test.ts

@@ -0,0 +1,233 @@
+import { describe, expect, it } from "vitest";
+import { numberToHex } from "./hex.js";
+import {
+  boolToBytes,
+  hexToBytes,
+  numberToBytes,
+  padBytes,
+  stringToBytes,
+  toBytes,
+} from "./to-bytes.js";
+
+describe("to-bytes.js", () => {
+  describe("padBytes", () => {
+    it("should pad bytes to the left by default to the specified size", () => {
+      const result = padBytes(new Uint8Array([1, 2, 3]), { size: 5 });
+      expect(result).toEqual(new Uint8Array([0, 0, 1, 2, 3]));
+    });
+
+    it('should pad bytes to the right if dir is "right"', () => {
+      const result = padBytes(new Uint8Array([1, 2, 3]), {
+        dir: "right",
+        size: 5,
+      });
+      expect(result).toEqual(new Uint8Array([1, 2, 3, 0, 0]));
+    });
+
+    it("should not pad if the byte array is already the specified size", () => {
+      const result = padBytes(new Uint8Array([1, 2, 3, 4, 5]), { size: 5 });
+      expect(result).toEqual(new Uint8Array([1, 2, 3, 4, 5]));
+    });
+
+    it("should throw an error if the byte array exceeds the specified size", () => {
+      expect(() =>
+        padBytes(new Uint8Array([1, 2, 3, 4, 5, 6]), { size: 5 }),
+      ).toThrow("Size overflow: 6 > 5");
+    });
+
+    it("should return the same byte array if size is null", () => {
+      const bytes = new Uint8Array([1, 2, 3]);
+      const result = padBytes(bytes, { size: null });
+      expect(result).toEqual(bytes);
+    });
+
+    it("should pad to the default size of 32 if size is not specified", () => {
+      const result = padBytes(new Uint8Array([1, 2, 3]));
+      expect(result).toStrictEqual(
+        new Uint8Array([
+          0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+          0, 0, 0, 0, 0, 0, 1, 2, 3,
+        ]),
+      );
+    });
+
+    it("should handle an empty byte array and pad to the specified size", () => {
+      const result = padBytes(new Uint8Array([]), { size: 3 });
+      expect(result).toEqual(new Uint8Array([0, 0, 0]));
+    });
+  });
+
+  describe("toBytes", () => {
+    it("should convert a number to bytes", () => {
+      expect(toBytes(123)).toEqual(new Uint8Array([123]));
+    });
+
+    it("should convert a bigint to bytes", () => {
+      expect(toBytes(BigInt(123))).toEqual(new Uint8Array([123]));
+    });
+
+    it("should convert a boolean to bytes", () => {
+      expect(toBytes(true)).toEqual(new Uint8Array([1]));
+      expect(toBytes(false)).toEqual(new Uint8Array([0]));
+    });
+
+    it("should convert a hex string to bytes", () => {
+      expect(toBytes("0x1a")).toEqual(new Uint8Array([26])); // 0x1a = 26 in decimal
+      expect(toBytes("0xabcd")).toEqual(new Uint8Array([171, 205]));
+    });
+
+    it("should convert a regular string to bytes", () => {
+      expect(toBytes("abc")).toEqual(new Uint8Array([97, 98, 99])); // ASCII values for 'a', 'b', 'c'
+    });
+
+    it("should handle empty hex string", () => {
+      expect(toBytes("0x")).toEqual(new Uint8Array([]));
+    });
+
+    it("should handle empty string", () => {
+      expect(toBytes("")).toEqual(new Uint8Array([]));
+    });
+  });
+
+  describe("boolToBytes", () => {
+    it("should convert true to a Uint8Array with a value of 1", () => {
+      expect(boolToBytes(true)).toEqual(new Uint8Array([1]));
+    });
+
+    it("should convert false to a Uint8Array with a value of 0", () => {
+      expect(boolToBytes(false)).toEqual(new Uint8Array([0]));
+    });
+
+    it("should pad the byte array to the specified size with zeros on the left when size is provided", () => {
+      expect(boolToBytes(true, { size: 4 })).toEqual(
+        new Uint8Array([0, 0, 0, 1]),
+      );
+      expect(boolToBytes(false, { size: 4 })).toEqual(
+        new Uint8Array([0, 0, 0, 0]),
+      );
+    });
+
+    it("should throw an error if the specified size is less than the byte size", () => {
+      expect(() => boolToBytes(true, { size: 0 })).toThrow(
+        "Size overflow: 1 > 0",
+      );
+    });
+
+    it("should not pad if no size is provided", () => {
+      expect(boolToBytes(true)).toEqual(new Uint8Array([1]));
+      expect(boolToBytes(false)).toEqual(new Uint8Array([0]));
+    });
+
+    it("should handle size of 1 correctly", () => {
+      expect(boolToBytes(true, { size: 1 })).toEqual(new Uint8Array([1]));
+      expect(boolToBytes(false, { size: 1 })).toEqual(new Uint8Array([0]));
+    });
+  });
+
+  describe("hexToBytes", () => {
+    it("should convert a valid hex string to Uint8Array", () => {
+      expect(hexToBytes("0x1a4")).toEqual(new Uint8Array([1, 164]));
+      expect(hexToBytes("0xabcdef")).toEqual(new Uint8Array([171, 205, 239]));
+    });
+
+    it("should handle odd-length hex strings by prepending a zero", () => {
+      expect(hexToBytes("0xabc")).toEqual(new Uint8Array([10, 188]));
+    });
+
+    it("should throw an error for invalid hex strings", () => {
+      expect(() => hexToBytes("0x1g")).toThrow(
+        'Invalid byte sequence ("1g" in "1g").',
+      );
+      expect(() => hexToBytes("0xzz")).toThrow(
+        'Invalid byte sequence ("zz" in "zz").',
+      );
+    });
+
+    it("should pad the hex string to the specified size by adding extra bytes", () => {
+      expect(hexToBytes("0x1a", { size: 4 })).toEqual(
+        new Uint8Array([26, 0, 0, 0]),
+      );
+    });
+
+    it("should throw an error if the hex string exceeds the specified size", () => {
+      expect(() => hexToBytes("0x123456", { size: 2 })).toThrow(
+        "Size overflow",
+      );
+    });
+
+    it("should correctly convert hex strings with even lengths without additional padding", () => {
+      expect(hexToBytes("0x1234")).toEqual(new Uint8Array([18, 52]));
+    });
+  });
+
+  describe("numberToBytes", () => {
+    it("should convert a number to a Uint8Array", () => {
+      const result = numberToBytes(420);
+      expect(result).toEqual(new Uint8Array([1, 164]));
+    });
+
+    it("should convert a bigint to a Uint8Array", () => {
+      const result = numberToBytes(BigInt(420));
+      expect(result).toEqual(new Uint8Array([1, 164]));
+    });
+
+    it("should handle zero correctly", () => {
+      const result = numberToBytes(0);
+      expect(result).toEqual(new Uint8Array([0]));
+    });
+
+    it("should handle large numbers correctly", () => {
+      const largeNumber = BigInt("12345678901234567890");
+      const result = numberToBytes(largeNumber);
+      expect(result).toEqual(hexToBytes(numberToHex(largeNumber)));
+    });
+
+    it("should apply options correctly when converting numbers", () => {
+      const opts = { size: 4 };
+      const result = numberToBytes(420, opts);
+      expect(result).toEqual(hexToBytes(numberToHex(420, opts)));
+    });
+  });
+
+  describe("stringToBytes", () => {
+    it("should convert a string to a Uint8Array of bytes", () => {
+      const result = stringToBytes("Hello, world!");
+      expect(result).toEqual(
+        new Uint8Array([
+          72, 101, 108, 108, 111, 44, 32, 119, 111, 114, 108, 100, 33,
+        ]),
+      );
+    });
+
+    it("should handle an empty string", () => {
+      const result = stringToBytes("");
+      expect(result).toEqual(new Uint8Array([]));
+    });
+
+    it("should pad the byte array to the specified size with zeros on the right", () => {
+      const result = stringToBytes("Hi", { size: 5 });
+      expect(result).toEqual(new Uint8Array([72, 105, 0, 0, 0]));
+    });
+
+    it("should throw an error if the byte array exceeds the specified size", () => {
+      expect(() => stringToBytes("Hello", { size: 3 })).toThrow(
+        "Size overflow: 5 > 3",
+      );
+    });
+
+    it("should not pad if no size is provided", () => {
+      const result = stringToBytes("Test");
+      expect(result).toEqual(new Uint8Array([84, 101, 115, 116]));
+    });
+
+    it("should handle unicode characters correctly", () => {
+      const result = stringToBytes("こんにちは");
+      expect(result).toEqual(
+        new Uint8Array([
+          227, 129, 147, 227, 130, 147, 227, 129, 171, 227, 129, 161, 227, 129,
+          175,
+        ]),
+      );
+    });
+  });
+});

package/src/utils/encoding/to-bytes.ts

@@ -9,7 +9,13 @@ type PadOptions = {
   size?: number | null;
 };
 
-function padBytes(bytes: Uint8Array, { dir, size = 32 }: PadOptions = {}) {
+/**
+ * @internal Exported for test
+ */
+export function padBytes(
+  bytes: Uint8Array,
+  { dir, size = 32 }: PadOptions = {},
+) {
   if (size === null) {
     return bytes;
   }

package/src/version.ts

@@ -1 +1 @@
-export const version = "5.66.0-nightly-880c3453ee8fc0fabbde0afb752a17894cd579a0-20241106000325";
+export const version = "5.67.0-nightly-734707e28b829262a1b40f7db8c005d2adeaeaf9-20241107000509";

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

@@ -9,13 +9,13 @@ import type { Ecosystem } from "../wallet/types.js";
  * @internal
  */
 export async function generateWallet({
-  authToken,
   client,
   ecosystem,
+  authToken,
 }: {
   client: ThirdwebClient;
-  ecosystem: Ecosystem;
   authToken: string;
+  ecosystem?: Ecosystem;
 }) {
   const clientFetch = getClientFetch(client, ecosystem);
   const response = await clientFetch(

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

@@ -139,8 +139,8 @@ export class EnclaveWallet implements IWebWallet {
         chain: getCachedChain(tx.chainId),
       });
       const transaction: Record<string, Hex | number | undefined> = {
-        to: (tx.to as Hex) ?? undefined,
-        data: tx.data ? toHex(tx.data) : undefined,
+        to: tx.to ? getAddress(tx.to) : undefined,
+        data: tx.data,
         value: tx.value ? toHex(tx.value) : undefined,
         gas: tx.gas ? toHex(tx.gas + tx.gas / BigInt(10)) : undefined, // Add a 10% buffer to gas
         nonce: tx.nonce

package/src/wallets/in-app/native/native-connector.ts

@@ -80,27 +80,26 @@ export class InAppNativeConnector implements InAppConnector {
     }
     let wallet = user.wallets[0];
 
-    // TODO (enclaves): Migration to enclave wallet for in-app wallets as well
-    if (
-      authResult &&
-      this.storage.ecosystem &&
-      wallet &&
-      wallet.type === "sharded"
-    ) {
-      const { migrateToEnclaveWallet } = await import(
-        "./helpers/wallet/migration.js"
-      );
-      wallet = await migrateToEnclaveWallet({
-        client: this.client,
-        storage: this.storage,
-        storedToken: authResult.storedToken,
-        encryptionKey,
-      });
+    if (authResult && wallet && wallet.type === "sharded") {
+      try {
+        const { migrateToEnclaveWallet } = await import(
+          "./helpers/wallet/migration.js"
+        );
+        wallet = await migrateToEnclaveWallet({
+          client: this.client,
+          storage: this.storage,
+          storedToken: authResult.storedToken,
+          encryptionKey,
+        });
+      } catch {
+        console.warn(
+          "Failed to migrate from sharded to enclave wallet, continuing with sharded wallet",
+        );
+      }
     }
 
-    if (authResult && this.ecosystem && !wallet) {
-      // new ecosystem user, generate enclave wallet
-      // TODO (enclaves): same flow for in-app wallets
+    if (authResult && !wallet) {
+      // new user, generate enclave wallet
       const { generateWallet } = await import(
         "../core/actions/generate-wallet.enclave.js"
       );