thirdweb 5.83.2-nightly-332536bdee05b6fb3b36d33761381826279b48f6-20250113000321 → 5.84.0

package/src/wallets/connection/autoConnectCore.ts

@@ -0,0 +1,184 @@
+import type { Chain } from "../../chains/types.js";
+import type { ThirdwebClient } from "../../client/client.js";
+import type { AsyncStorage } from "../../utils/storage/AsyncStorage.js";
+import { timeoutPromise } from "../../utils/timeoutPromise.js";
+import { isEcosystemWallet } from "../ecosystem/is-ecosystem-wallet.js";
+import { ClientScopedStorage } from "../in-app/core/authentication/client-scoped-storage.js";
+import type {
+  AuthArgsType,
+  AuthStoredTokenWithCookieReturnType,
+} from "../in-app/core/authentication/types.js";
+import { getUrlToken } from "../in-app/web/lib/get-url-token.js";
+import type { Wallet } from "../interfaces/wallet.js";
+import {
+  type ConnectionManager,
+  getLastConnectedChain,
+  getStoredActiveWalletId,
+  getStoredConnectedWalletIds,
+} from "../manager/index.js";
+import type { WalletId } from "../wallet-types.js";
+import type { AutoConnectProps } from "./types.js";
+
+/**
+ * @internal
+ */
+export const autoConnectCore = async ({
+  storage,
+  props,
+  createWalletFn,
+  manager,
+  connectOverride,
+  getInstalledWallets,
+  setLastAuthProvider,
+}: {
+  storage: AsyncStorage;
+  props: AutoConnectProps & { wallets: Wallet[] };
+  createWalletFn: (id: WalletId) => Wallet;
+  manager: ConnectionManager;
+  connectOverride?: (
+    walletOrFn: Wallet | (() => Promise<Wallet>),
+  ) => Promise<Wallet | null>;
+  getInstalledWallets?: () => Wallet[];
+  setLastAuthProvider?: (
+    authProvider: AuthArgsType["strategy"],
+    storage: AsyncStorage,
+  ) => Promise<void>;
+}): Promise<boolean> => {
+  const { wallets, onConnect } = props;
+  const timeout = props.timeout ?? 15000;
+
+  let autoConnected = false;
+  manager.isAutoConnecting.setValue(true);
+
+  let [lastConnectedWalletIds, lastActiveWalletId] = await Promise.all([
+    getStoredConnectedWalletIds(storage),
+    getStoredActiveWalletId(storage),
+  ]);
+
+  const { authResult, walletId, authProvider, authCookie } = getUrlToken();
+  const wallet = wallets.find((w) => w.id === walletId);
+
+  // If an auth cookie is found and this site supports the wallet, we'll set the auth cookie in the client storage
+  if (authCookie && wallet) {
+    const clientStorage = new ClientScopedStorage({
+      storage,
+      clientId: props.client.clientId,
+      ecosystem: isEcosystemWallet(wallet)
+        ? {
+            id: wallet.id,
+            partnerId: wallet.getConfig()?.partnerId,
+          }
+        : undefined,
+    });
+    await clientStorage.saveAuthCookie(authCookie);
+  }
+
+  if (walletId) {
+    lastActiveWalletId = walletId;
+    lastConnectedWalletIds = lastConnectedWalletIds?.includes(walletId)
+      ? lastConnectedWalletIds
+      : [walletId, ...(lastConnectedWalletIds || [])];
+  }
+  if (authProvider) {
+    await setLastAuthProvider?.(authProvider, storage);
+  }
+
+  // if no wallets were last connected or we didn't receive an auth token
+  if (!lastConnectedWalletIds) {
+    return autoConnected;
+  }
+
+  // this flow can actually be used for a first connection in the case of a redirect
+  // in that case, we default to the passed chain to connect to
+  const lastConnectedChain =
+    (await getLastConnectedChain(storage)) || props.chain;
+  const availableWallets = [...wallets, ...(getInstalledWallets?.() ?? [])];
+  const activeWallet =
+    lastActiveWalletId &&
+    (availableWallets.find((w) => w.id === lastActiveWalletId) ||
+      createWalletFn(lastActiveWalletId));
+
+  if (activeWallet) {
+    manager.activeWalletConnectionStatusStore.setValue("connecting"); // only set connecting status if we are connecting the last active EOA
+    await timeoutPromise(
+      handleWalletConnection({
+        wallet: activeWallet,
+        client: props.client,
+        lastConnectedChain,
+        authResult,
+      }),
+      {
+        ms: timeout,
+        message: `AutoConnect timeout: ${timeout}ms limit exceeded.`,
+      },
+    ).catch((err) => {
+      console.warn(err.message);
+      if (props.onTimeout) {
+        props.onTimeout();
+      }
+    });
+
+    try {
+      // connected wallet could be activeWallet or smart wallet
+      const connectedWallet = await (connectOverride
+        ? connectOverride(activeWallet)
+        : manager.connect(activeWallet, {
+            client: props.client,
+            accountAbstraction: props.accountAbstraction,
+          }));
+      if (connectedWallet) {
+        autoConnected = true;
+        try {
+          onConnect?.(connectedWallet);
+        } catch {
+          // ignore
+        }
+      } else {
+        manager.activeWalletConnectionStatusStore.setValue("disconnected");
+      }
+    } catch (e) {
+      if (e instanceof Error) {
+        console.warn("Error auto connecting wallet:", e.message);
+      }
+      manager.activeWalletConnectionStatusStore.setValue("disconnected");
+    }
+  } else {
+    manager.activeWalletConnectionStatusStore.setValue("disconnected");
+  }
+
+  // then connect wallets that were last connected but were not set as active
+  const otherWallets = availableWallets.filter(
+    (w) => w.id !== lastActiveWalletId && lastConnectedWalletIds.includes(w.id),
+  );
+  for (const wallet of otherWallets) {
+    try {
+      await handleWalletConnection({
+        wallet,
+        client: props.client,
+        lastConnectedChain,
+        authResult,
+      });
+      manager.addConnectedWallet(wallet);
+    } catch {
+      // no-op
+    }
+  }
+  manager.isAutoConnecting.setValue(false);
+  return autoConnected; // useQuery needs a return value
+};
+
+/**
+ * @internal
+ */
+export async function handleWalletConnection(props: {
+  wallet: Wallet;
+  client: ThirdwebClient;
+  authResult: AuthStoredTokenWithCookieReturnType | undefined;
+  lastConnectedChain: Chain | undefined;
+}) {
+  return props.wallet.autoConnect({
+    client: props.client,
+    chain: props.lastConnectedChain,
+    authResult: props.authResult,
+  });
+}

package/src/{react/core/hooks → wallets}/connection/types.ts

@@ -1,8 +1,8 @@
-import type { Chain } from "../../../../chains/types.js";
-import type { ThirdwebClient } from "../../../../client/client.js";
-import type { Wallet } from "../../../../wallets/interfaces/wallet.js";
-import type { SmartWalletOptions } from "../../../../wallets/smart/types.js";
-import type { AppMetadata } from "../../../../wallets/types.js";
+import type { Chain } from "../../chains/types.js";
+import type { ThirdwebClient } from "../../client/client.js";
+import type { Wallet } from "../../wallets/interfaces/wallet.js";
+import type { SmartWalletOptions } from "../../wallets/smart/types.js";
+import type { AppMetadata } from "../../wallets/types.js";
 
 export type AutoConnectProps = {
   /**

package/src/{react/web/wallets → wallets}/defaultWallets.ts

@@ -1,13 +1,8 @@
-import type { Chain } from "../../../chains/types.js";
-import {
-  COINBASE,
-  METAMASK,
-  RAINBOW,
-  ZERION,
-} from "../../../wallets/constants.js";
-import { createWallet } from "../../../wallets/create-wallet.js";
-import type { Wallet } from "../../../wallets/interfaces/wallet.js";
-import type { AppMetadata } from "../../../wallets/types.js";
+import type { Chain } from "../chains/types.js";
+import { COINBASE, METAMASK, RAINBOW, ZERION } from "./constants.js";
+import { createWallet } from "./create-wallet.js";
+import type { Wallet } from "./interfaces/wallet.js";
+import type { AppMetadata } from "./types.js";
 
 /**
  * @internal

package/src/wallets/engine/engine-account.test.ts

@@ -0,0 +1,69 @@
+import { describe, expect, it } from "vitest";
+import { TEST_CLIENT } from "../../../test/src/test-clients.js";
+import { TEST_ACCOUNT_B } from "../../../test/src/test-wallets.js";
+import { typedData } from "../../../test/src/typed-data.js";
+import { sepolia } from "../../chains/chain-definitions/sepolia.js";
+import { getContract } from "../../contract/contract.js";
+import { claimTo } from "../../extensions/erc1155/drops/write/claimTo.js";
+import { sendTransaction } from "../../transaction/actions/send-transaction.js";
+import { engineAccount } from "./index.js";
+
+describe.runIf(
+  process.env.TW_SECRET_KEY &&
+    process.env.ENGINE_URL &&
+    process.env.ENGINE_AUTH_TOKEN &&
+    process.env.ENGINE_WALLET_ADDRESS,
+)("Engine", () => {
+  const engineAcc = engineAccount({
+    engineUrl: process.env.ENGINE_URL as string,
+    authToken: process.env.ENGINE_AUTH_TOKEN as string,
+    walletAddress: process.env.ENGINE_WALLET_ADDRESS as string,
+    chain: sepolia,
+  });
+
+  it("should sign a message", async () => {
+    const signature = await engineAcc.signMessage({
+      message: "hello",
+    });
+    expect(signature).toBeDefined();
+  });
+
+  it("should sign typed data", async () => {
+    const signature = await engineAcc.signTypedData({
+      ...typedData.basic,
+    });
+    expect(signature).toBeDefined();
+  });
+
+  it("should send a tx", async () => {
+    const tx = await sendTransaction({
+      account: engineAcc,
+      transaction: {
+        client: TEST_CLIENT,
+        chain: sepolia,
+        to: TEST_ACCOUNT_B.address,
+        value: 0n,
+      },
+    });
+    expect(tx).toBeDefined();
+  });
+
+  it("should send a extension tx", async () => {
+    const nftContract = getContract({
+      client: TEST_CLIENT,
+      chain: sepolia,
+      address: "0xe2cb0eb5147b42095c2FfA6F7ec953bb0bE347D8",
+    });
+    const claimTx = claimTo({
+      contract: nftContract,
+      to: TEST_ACCOUNT_B.address,
+      tokenId: 0n,
+      quantity: 1n,
+    });
+    const tx = await sendTransaction({
+      account: engineAcc,
+      transaction: claimTx,
+    });
+    expect(tx).toBeDefined();
+  });
+});

package/src/wallets/engine/index.ts

@@ -0,0 +1,198 @@
+import type { Chain } from "../../chains/types.js";
+import type { Hex } from "../../utils/encoding/hex.js";
+import { toHex } from "../../utils/encoding/hex.js";
+import type { Account, SendTransactionOption } from "../interfaces/wallet.js";
+
+/**
+ * Options for creating an engine account.
+ */
+export type EngineAccountOptions = {
+  /**
+   * The URL of your engine instance.
+   */
+  engineUrl: string;
+  /**
+   * The auth token to use with the engine instance.
+   */
+  authToken: string;
+  /**
+   * The backend wallet to use for sending transactions inside engine.
+   */
+  walletAddress: string;
+  /**
+   * The chain to use for signing messages and typed data (smart backend wallet only).
+   */
+  chain?: Chain;
+};
+
+/**
+ * Creates an account that uses your engine backend wallet for sending transactions and signing messages.
+ *
+ * @param options - The options for the engine account.
+ * @returns An account that uses your engine backend wallet.
+ *
+ * @beta
+ * @wallet
+ *
+ * @example
+ * ```ts
+ * import { engineAccount } from "thirdweb/wallets/engine";
+ *
+ * const engineAcc = engineAccount({
+ *   engineUrl: "https://engine.thirdweb.com",
+ *   authToken: "your-auth-token",
+ *   walletAddress: "0x...",
+ * });
+ *
+ * // then use the account as you would any other account
+ * const transaction = claimTo({
+ *   contract,
+ *   to: "0x...",
+ *   quantity: 1n,
+ * });
+ * const result = await sendTransaction({ transaction, account: engineAcc });
+ * console.log("Transaction sent:", result.transactionHash);
+ * ```
+ */
+export function engineAccount(options: EngineAccountOptions): Account {
+  const { engineUrl, authToken, walletAddress, chain } = options;
+
+  // these are shared across all methods
+  const headers: HeadersInit = {
+    "x-backend-wallet-address": walletAddress,
+    Authorization: `Bearer ${authToken}`,
+    "Content-Type": "application/json",
+  };
+
+  return {
+    address: walletAddress,
+    sendTransaction: async (transaction: SendTransactionOption) => {
+      const ENGINE_URL = new URL(engineUrl);
+      ENGINE_URL.pathname = `/backend-wallet/${transaction.chainId}/send-transaction`;
+
+      const engineData: Record<string, string | undefined> = {
+        // add to address if we have it (is optional to pass to engine)
+        toAddress: transaction.to || undefined,
+        // engine wants a hex string here so we serialize it
+        data: transaction.data || "0x",
+        // value is always required
+        value: toHex(transaction.value ?? 0n),
+      };
+
+      // TODO: gas overrides etc?
+
+      const engineRes = await fetch(ENGINE_URL, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(engineData),
+      });
+      if (!engineRes.ok) {
+        const body = await engineRes.text();
+        throw new Error(
+          `Engine request failed with status ${engineRes.status} - ${body}`,
+        );
+      }
+      const engineJson = (await engineRes.json()) as {
+        result: {
+          queueId: string;
+        };
+      };
+
+      // wait for the queueId to be processed
+      ENGINE_URL.pathname = `/transaction/status/${engineJson.result.queueId}`;
+      const startTime = Date.now();
+      const TIMEOUT_IN_MS = 5 * 60 * 1000; // 5 minutes in milliseconds
+
+      while (Date.now() - startTime < TIMEOUT_IN_MS) {
+        const queueRes = await fetch(ENGINE_URL, {
+          method: "GET",
+          headers,
+        });
+        if (!queueRes.ok) {
+          const body = await queueRes.text();
+          throw new Error(
+            `Engine request failed with status ${queueRes.status} - ${body}`,
+          );
+        }
+        const queueJSON = (await queueRes.json()) as {
+          result: {
+            status: "queued" | "mined" | "cancelled" | "errored";
+            transactionHash: Hex | null;
+            userOpHash: Hex | null;
+            errorMessage: string | null;
+          };
+        };
+
+        if (
+          queueJSON.result.status === "errored" &&
+          queueJSON.result.errorMessage
+        ) {
+          throw new Error(queueJSON.result.errorMessage);
+        }
+        if (queueJSON.result.transactionHash) {
+          return {
+            transactionHash: queueJSON.result.transactionHash,
+          };
+        }
+        // wait 1s before checking again
+        await new Promise((resolve) => setTimeout(resolve, 1000));
+      }
+      throw new Error("Transaction timed out after 5 minutes");
+    },
+    signMessage: async ({ message }) => {
+      let engineMessage: string | Hex;
+      let isBytes = false;
+      if (typeof message === "string") {
+        engineMessage = message;
+      } else {
+        engineMessage = toHex(message.raw);
+        isBytes = true;
+      }
+
+      const ENGINE_URL = new URL(engineUrl);
+      ENGINE_URL.pathname = "/backend-wallet/sign-message";
+      const engineRes = await fetch(ENGINE_URL, {
+        method: "POST",
+        headers,
+        body: JSON.stringify({
+          message: engineMessage,
+          isBytes,
+          chainId: chain?.id,
+        }),
+      });
+      if (!engineRes.ok) {
+        const body = await engineRes.text();
+        throw new Error(
+          `Engine request failed with status ${engineRes.status} - ${body}`,
+        );
+      }
+      const engineJson = (await engineRes.json()) as {
+        result: Hex;
+      };
+      return engineJson.result;
+    },
+    signTypedData: async (_typedData) => {
+      const ENGINE_URL = new URL(engineUrl);
+      ENGINE_URL.pathname = "/backend-wallet/sign-typed-data";
+      const engineRes = await fetch(ENGINE_URL, {
+        method: "POST",
+        headers,
+        body: JSON.stringify({
+          domain: _typedData.domain,
+          types: _typedData.types,
+          value: _typedData.message,
+        }),
+      });
+      if (!engineRes.ok) {
+        engineRes.body?.cancel();
+        throw new Error(
+          `Engine request failed with status ${engineRes.status}`,
+        );
+      }
+      const engineJson = (await engineRes.json()) as {
+        result: Hex;
+      };
+      return engineJson.result;
+    },
+  };
+}

package/src/wallets/in-app/web/lib/get-url-token.ts

@@ -11,7 +11,7 @@ export function getUrlToken(): {
   authProvider?: AuthOption;
   authCookie?: string;
 } {
-  if (!window?.location) {
+  if (typeof window === "undefined") {
     // Not in web
     return {};
   }

package/src/wallets/smart/lib/signing.ts

@@ -288,7 +288,7 @@ async function checkFor712Factory({
  * });
  * ```
  *
- * @wallets
+ * @wallet
  */
 export async function deploySmartAccount(args: {
   smartAccount: Account;

package/src/wallets/smart/smart-wallet-integration.test.ts

@@ -180,6 +180,7 @@ describe.runIf(process.env.TW_SECRET_KEY).sequential(
         account: smartAccount,
       });
       expect(tx.transactionHash).toHaveLength(66);
+      await sleep(1000);
       const isDeployed = await isContractDeployed(accountContract);
       expect(isDeployed).toEqual(true);
       const balance = await balanceOf({

package/dist/cjs/react/core/hooks/connection/types.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../../../../src/react/core/hooks/connection/types.ts"],"names":[],"mappings":""}

package/dist/cjs/react/core/utils/timeoutPromise.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"timeoutPromise.js","sourceRoot":"","sources":["../../../../../src/react/core/utils/timeoutPromise.ts"],"names":[],"mappings":";;AAIA,wCAoBC;AAxBD;;;GAGG;AACH,SAAgB,cAAc,CAC5B,OAAmB,EACnB,MAAuC;IAEvC,OAAO,IAAI,OAAO,CAAI,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;QACxC,MAAM,SAAS,GAAG,UAAU,CAAC,GAAG,EAAE;YAChC,MAAM,CAAC,IAAI,KAAK,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC;QACpC,CAAC,EAAE,MAAM,CAAC,EAAE,CAAC,CAAC;QAEd,OAAO,CAAC,IAAI,CACV,CAAC,GAAG,EAAE,EAAE;YACN,YAAY,CAAC,SAAS,CAAC,CAAC;YACxB,OAAO,CAAC,GAAG,CAAC,CAAC;QACf,CAAC,EACD,CAAC,GAAG,EAAE,EAAE;YACN,YAAY,CAAC,SAAS,CAAC,CAAC;YACxB,MAAM,CAAC,GAAG,CAAC,CAAC;QACd,CAAC,CACF,CAAC;IACJ,CAAC,CAAC,CAAC;AACL,CAAC"}

package/dist/cjs/react/web/wallets/defaultWallets.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"defaultWallets.js","sourceRoot":"","sources":["../../../../../src/react/web/wallets/defaultWallets.ts"],"names":[],"mappings":";;AAcA,8CAeC;AA5BD,gEAKuC;AACvC,wEAAiE;AAIjE;;GAEG;AACH,SAAgB,iBAAiB,CAAC,OAGjC;IACC,OAAO;QACL,IAAA,+BAAY,EAAC,OAAO,CAAC;QACrB,IAAA,+BAAY,EAAC,uBAAQ,CAAC;QACtB,IAAA,+BAAY,EAAC,uBAAQ,EAAE;YACrB,WAAW,EAAE,OAAO,EAAE,WAAW;YACjC,MAAM,EAAE,OAAO,EAAE,MAAM;SACxB,CAAC;QACF,IAAA,+BAAY,EAAC,sBAAO,CAAC;QACrB,IAAA,+BAAY,EAAC,UAAU,CAAC;QACxB,IAAA,+BAAY,EAAC,qBAAM,CAAC;KACrB,CAAC;AACJ,CAAC"}

package/dist/esm/react/core/hooks/connection/types.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../../../../src/react/core/hooks/connection/types.ts"],"names":[],"mappings":""}

package/dist/esm/react/core/utils/timeoutPromise.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"timeoutPromise.js","sourceRoot":"","sources":["../../../../../src/react/core/utils/timeoutPromise.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,MAAM,UAAU,cAAc,CAC5B,OAAmB,EACnB,MAAuC;IAEvC,OAAO,IAAI,OAAO,CAAI,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;QACxC,MAAM,SAAS,GAAG,UAAU,CAAC,GAAG,EAAE;YAChC,MAAM,CAAC,IAAI,KAAK,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC;QACpC,CAAC,EAAE,MAAM,CAAC,EAAE,CAAC,CAAC;QAEd,OAAO,CAAC,IAAI,CACV,CAAC,GAAG,EAAE,EAAE;YACN,YAAY,CAAC,SAAS,CAAC,CAAC;YACxB,OAAO,CAAC,GAAG,CAAC,CAAC;QACf,CAAC,EACD,CAAC,GAAG,EAAE,EAAE;YACN,YAAY,CAAC,SAAS,CAAC,CAAC;YACxB,MAAM,CAAC,GAAG,CAAC,CAAC;QACd,CAAC,CACF,CAAC;IACJ,CAAC,CAAC,CAAC;AACL,CAAC"}

package/dist/esm/react/web/wallets/defaultWallets.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"defaultWallets.js","sourceRoot":"","sources":["../../../../../src/react/web/wallets/defaultWallets.ts"],"names":[],"mappings":"AACA,OAAO,EACL,QAAQ,EACR,QAAQ,EACR,OAAO,EACP,MAAM,GACP,MAAM,+BAA+B,CAAC;AACvC,OAAO,EAAE,YAAY,EAAE,MAAM,mCAAmC,CAAC;AAIjE;;GAEG;AACH,MAAM,UAAU,iBAAiB,CAAC,OAGjC;IACC,OAAO;QACL,YAAY,CAAC,OAAO,CAAC;QACrB,YAAY,CAAC,QAAQ,CAAC;QACtB,YAAY,CAAC,QAAQ,EAAE;YACrB,WAAW,EAAE,OAAO,EAAE,WAAW;YACjC,MAAM,EAAE,OAAO,EAAE,MAAM;SACxB,CAAC;QACF,YAAY,CAAC,OAAO,CAAC;QACrB,YAAY,CAAC,UAAU,CAAC;QACxB,YAAY,CAAC,MAAM,CAAC;KACrB,CAAC;AACJ,CAAC"}

package/dist/types/react/core/hooks/connection/types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../../src/react/core/hooks/connection/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,6BAA6B,CAAC;AACzD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AACnE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,0CAA0C,CAAC;AACvE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,oCAAoC,CAAC;AAC7E,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,8BAA8B,CAAC;AAEhE,MAAM,MAAM,gBAAgB,GAAG;IAC7B;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IAEnB;;;;;;;;;;;;;;OAcG;IACH,MAAM,EAAE,cAAc,CAAC;IAEvB;;;;;;;;;;;;;OAaG;IACH,WAAW,CAAC,EAAE,WAAW,CAAC;IAE1B;;;;;;;;;;;;;OAaG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IAEjB;;;;;;;;;;;;;OAaG;IACH,kBAAkB,CAAC,EAAE,kBAAkB,CAAC;IAExC;;;;;;;;;;OAUG;IACH,SAAS,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC;IAErC;;OAEG;IACH,KAAK,CAAC,EAAE,KAAK,CAAC;IAEd;;OAEG;IACH,SAAS,CAAC,EAAE,MAAM,IAAI,CAAC;CACxB,CAAC"}

package/dist/types/react/core/utils/timeoutPromise.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"timeoutPromise.d.ts","sourceRoot":"","sources":["../../../../../src/react/core/utils/timeoutPromise.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAC9B,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EACnB,MAAM,EAAE;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,cAkBxC"}

package/dist/types/react/web/wallets/defaultWallets.d.ts

@@ -1,11 +0,0 @@
-import type { Chain } from "../../../chains/types.js";
-import type { Wallet } from "../../../wallets/interfaces/wallet.js";
-import type { AppMetadata } from "../../../wallets/types.js";
-/**
- * @internal
- */
-export declare function getDefaultWallets(options?: {
-    appMetadata?: AppMetadata;
-    chains?: Chain[];
-}): Wallet[];
-//# sourceMappingURL=defaultWallets.d.ts.map

package/dist/types/react/web/wallets/defaultWallets.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"defaultWallets.d.ts","sourceRoot":"","sources":["../../../../../src/react/web/wallets/defaultWallets.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,0BAA0B,CAAC;AAQtD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uCAAuC,CAAC;AACpE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AAE7D;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,CAAC,EAAE;IAC1C,WAAW,CAAC,EAAE,WAAW,CAAC;IAC1B,MAAM,CAAC,EAAE,KAAK,EAAE,CAAC;CAClB,GAAG,MAAM,EAAE,CAYX"}