@dynamic-labs-sdk/legacy-embedded-wallet-upgrade 0.0.0 → 1.21.2

package/README.md

@@ -0,0 +1,103 @@
+# @dynamic-labs-sdk/legacy-embedded-wallet-upgrade
+
+Helpers to upgrade a user's legacy Dynamic embedded wallets to Dynamic WaaS. Wraps the URL contract, the redirect round-trip, the iframe/WebView completion handshake, and the session refresh behind a small set of functions, so you only call functions — you never assemble the flow yourself.
+
+The core entry point is framework-agnostic (no React). React hooks live in a separate `/react` subpath so non-React consumers never load them.
+
+## Installation
+
+```bash
+npm install @dynamic-labs-sdk/legacy-embedded-wallet-upgrade @dynamic-labs-sdk/client
+```
+
+## Detecting wallets that require an upgrade
+
+```ts
+import {
+  getWalletsRequiringUpgrade,
+  hasWalletsRequiringUpgrade,
+} from '@dynamic-labs-sdk/legacy-embedded-wallet-upgrade';
+
+if (hasWalletsRequiringUpgrade()) {
+  const wallets = getWalletsRequiringUpgrade();
+  // show an upgrade entry point for these wallets
+}
+```
+
+## Redirect path
+
+Navigate the top-level window to the hosted upgrade app, then consume the result when it returns. The environment id is read from the client and the return URL defaults to the current page, so both calls are zero-arg.
+
+```ts
+import {
+  startUpgradeRedirect,
+  consumeUpgradeRedirect,
+} from '@dynamic-labs-sdk/legacy-embedded-wallet-upgrade';
+
+// on the "Upgrade via redirect" button
+startUpgradeRedirect();
+
+// once, on app load — reads and strips the status param, refreshes the
+// session on success, and returns the outcome (null if we didn't just return)
+const result = await consumeUpgradeRedirect();
+if (result?.status === 'error') {
+  showErrorToast();
+}
+```
+
+## Iframe path
+
+The package renders no UI of its own — you own the container (e.g. a bottom sheet). `openUpgradeIframe` appends the iframe into your container, listens for the origin-checked completion message, refreshes the session on success, and resolves.
+
+```ts
+import { openUpgradeIframe } from '@dynamic-labs-sdk/legacy-embedded-wallet-upgrade';
+
+const session = openUpgradeIframe({ container: sheetBodyElement });
+const { status } = await session.completed;
+closeSheet();
+
+// if the user dismisses the sheet first:
+session.close();
+```
+
+### React Native / custom mounts
+
+Use the DOM-agnostic primitives when you mount the upgrade app yourself (e.g. a React Native `WebView`):
+
+```ts
+import {
+  buildUpgradeUrl,
+  subscribeToUpgradeCompletion,
+} from '@dynamic-labs-sdk/legacy-embedded-wallet-upgrade';
+
+const src = buildUpgradeUrl();
+const unsubscribe = subscribeToUpgradeCompletion({
+  onComplete: ({ status }) => handleOutcome(status),
+});
+```
+
+## React
+
+React hooks are exported from the `/react` subpath, with `react` as an optional peer dependency:
+
+```tsx
+import {
+  useWalletsRequiringUpgrade,
+  useHasWalletsRequiringUpgrade,
+  useUpgradeRedirectResult,
+  useUpgradeIframe,
+} from '@dynamic-labs-sdk/legacy-embedded-wallet-upgrade/react';
+
+const needsUpgrade = useHasWalletsRequiringUpgrade();
+
+useUpgradeRedirectResult({ onComplete: ({ status }) => handleOutcome(status) });
+
+const { upgradeUrl } = useUpgradeIframe({
+  active: isSheetOpen,
+  onComplete: ({ status }) => closeSheet(status),
+});
+```
+
+## Multiple clients
+
+Every function accepts the Dynamic client as an optional second argument and defaults to `getDefaultClient()`; pass it explicitly only when you use more than one client.

package/dist/buildUpgradeUrl/buildUpgradeUrl.d.ts

@@ -0,0 +1,44 @@
+type BuildUpgradeUrlParams = {
+    /**
+     * Base URL of the hosted upgrade app. Defaults to the production upgrade app;
+     * override it to target a local or preview build (e.g. during QA).
+     */
+    baseUrl?: string;
+    /**
+     * Absolute https URL the upgrade app returns to (redirect flow) or
+     * postMessages (iframe flow) on completion. Defaults to the current page
+     * (`window.location.href`). The upgrade app rejects any non-https URL.
+     */
+    redirectUrl?: string;
+};
+/**
+ * Builds the URL that drives the hosted upgrade app for the client's Dynamic
+ * environment and a return target.
+ *
+ * This is the low-level primitive behind every upgrade path: the redirect flow
+ * navigates the top-level window to it, the iframe flow loads it as the iframe
+ * `src`, and a React Native WebView can load it directly. The environment id is
+ * read from the client, and `redirectUrl` defaults to the current page, so the
+ * common call is zero-arg. Prefer {@link startUpgradeRedirect} or
+ * {@link openUpgradeIframe} unless you are mounting the upgrade app yourself.
+ *
+ * @example
+ * ```ts
+ * const src = buildUpgradeUrl();
+ * // or target a local upgrade app during QA:
+ * const localSrc = buildUpgradeUrl({ baseUrl: 'https://localhost:3000' });
+ * ```
+ * @param [params] - Options for the generated URL.
+ * @param [params.redirectUrl] - Absolute https return URL; defaults to `window.location.href`.
+ * @param [params.baseUrl] - Upgrade app base URL; defaults to the production app.
+ * @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
+ * @returns The fully-qualified upgrade app URL to load.
+ * @throws {InvalidUpgradeRedirectUrlError} When `redirectUrl` is not an absolute https URL.
+ * @throws {InvalidUpgradeBaseUrlError} When `baseUrl` is not an absolute https URL.
+ * @throws {UnavailableInServerSideError} When called during SSR without an explicit `redirectUrl`.
+ * @see startUpgradeRedirect
+ * @see openUpgradeIframe
+ */
+export declare const buildUpgradeUrl: ({ redirectUrl, baseUrl }?: BuildUpgradeUrlParams, client?: import("@dynamic-labs-sdk/client").DynamicClient) => string;
+export {};
+//# sourceMappingURL=buildUpgradeUrl.d.ts.map

package/dist/buildUpgradeUrl/buildUpgradeUrl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"buildUpgradeUrl.d.ts","sourceRoot":"","sources":["../../src/buildUpgradeUrl/buildUpgradeUrl.ts"],"names":[],"mappings":"AAkBA,KAAK,qBAAqB,GAAG;IAC3B;;;OAGG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;;;;OAIG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,eAAO,MAAM,eAAe,8BACuB,qBAAqB,gEAErE,MAqCF,CAAC"}

package/dist/buildUpgradeUrl/index.d.ts

@@ -0,0 +1,2 @@
+export { buildUpgradeUrl } from './buildUpgradeUrl';
+//# sourceMappingURL=index.d.ts.map

package/dist/buildUpgradeUrl/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/buildUpgradeUrl/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC"}

package/dist/errors/InvalidUpgradeBaseUrlError.d.ts

@@ -0,0 +1,5 @@
+import { BaseError } from '@dynamic-labs-sdk/client';
+export declare class InvalidUpgradeBaseUrlError extends BaseError {
+    constructor(baseUrl: string);
+}
+//# sourceMappingURL=InvalidUpgradeBaseUrlError.d.ts.map

package/dist/errors/InvalidUpgradeBaseUrlError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"InvalidUpgradeBaseUrlError.d.ts","sourceRoot":"","sources":["../../src/errors/InvalidUpgradeBaseUrlError.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAC;AAErD,qBAAa,0BAA2B,SAAQ,SAAS;gBAE3C,OAAO,EAAE,MAAM;CAS5B"}

package/dist/errors/InvalidUpgradeRedirectUrlError.d.ts

@@ -0,0 +1,5 @@
+import { BaseError } from '@dynamic-labs-sdk/client';
+export declare class InvalidUpgradeRedirectUrlError extends BaseError {
+    constructor(redirectUrl: string);
+}
+//# sourceMappingURL=InvalidUpgradeRedirectUrlError.d.ts.map

package/dist/errors/InvalidUpgradeRedirectUrlError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"InvalidUpgradeRedirectUrlError.d.ts","sourceRoot":"","sources":["../../src/errors/InvalidUpgradeRedirectUrlError.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAC;AAErD,qBAAa,8BAA+B,SAAQ,SAAS;gBAE/C,WAAW,EAAE,MAAM;CAShC"}

package/dist/exports/index.d.ts

@@ -0,0 +1,4 @@
+export { buildUpgradeUrl } from '../buildUpgradeUrl';
+export { getWalletsRequiringUpgrade } from '../getWalletsRequiringUpgrade';
+export { hasWalletsRequiringUpgrade } from '../hasWalletsRequiringUpgrade';
+//# sourceMappingURL=index.d.ts.map

package/dist/exports/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/exports/index.ts"],"names":[],"mappings":"AASA,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AACrD,OAAO,EAAE,0BAA0B,EAAE,MAAM,+BAA+B,CAAC;AAC3E,OAAO,EAAE,0BAA0B,EAAE,MAAM,+BAA+B,CAAC"}

package/dist/getWalletsRequiringUpgrade/getWalletsRequiringUpgrade.d.ts

@@ -0,0 +1,26 @@
+import { type WalletAccount } from '@dynamic-labs-sdk/client';
+/**
+ * Returns the current session's wallet accounts that are legacy Dynamic
+ * embedded wallets requiring an upgrade to Dynamic WaaS.
+ *
+ * These are earlier-generation Dynamic embedded wallets that predate Dynamic
+ * WaaS (the current TSS-MPC embedded wallet) and can be upgraded to it. Use this
+ * when you need the accounts themselves — for example to render only the
+ * upgrade entry points on those wallets. Already-upgraded Dynamic WaaS accounts
+ * are never returned. For a simple boolean check, use
+ * {@link hasWalletsRequiringUpgrade}.
+ *
+ * @example
+ * ```ts
+ * const walletsRequiringUpgrade = getWalletsRequiringUpgrade();
+ * if (walletsRequiringUpgrade.length > 0) {
+ *   promptUpgrade(walletsRequiringUpgrade);
+ * }
+ * ```
+ * @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
+ * @returns The wallet accounts requiring an upgrade to Dynamic WaaS (empty when none).
+ * @see hasWalletsRequiringUpgrade
+ * @see startUpgradeRedirect
+ */
+export declare const getWalletsRequiringUpgrade: (client?: import("@dynamic-labs-sdk/client").DynamicClient) => WalletAccount[];
+//# sourceMappingURL=getWalletsRequiringUpgrade.d.ts.map

package/dist/getWalletsRequiringUpgrade/getWalletsRequiringUpgrade.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getWalletsRequiringUpgrade.d.ts","sourceRoot":"","sources":["../../src/getWalletsRequiringUpgrade/getWalletsRequiringUpgrade.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,aAAa,EAGnB,MAAM,0BAA0B,CAAC;AAIlC;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,0BAA0B,iEAEpC,aAAa,EACgD,CAAC"}

package/dist/getWalletsRequiringUpgrade/index.d.ts

@@ -0,0 +1,2 @@
+export { getWalletsRequiringUpgrade } from './getWalletsRequiringUpgrade';
+//# sourceMappingURL=index.d.ts.map

package/dist/getWalletsRequiringUpgrade/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/getWalletsRequiringUpgrade/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,0BAA0B,EAAE,MAAM,8BAA8B,CAAC"}

package/dist/hasWalletsRequiringUpgrade/hasWalletsRequiringUpgrade.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Returns whether the current session has any legacy Dynamic embedded wallet
+ * that requires an upgrade to Dynamic WaaS.
+ *
+ * A boolean convenience over {@link getWalletsRequiringUpgrade} for the common
+ * case where you only need to decide whether to surface the upgrade flow (e.g.
+ * show a banner or gate a wallet's actions) rather than act on the specific
+ * accounts.
+ *
+ * @example
+ * ```ts
+ * if (hasWalletsRequiringUpgrade()) {
+ *   showUpgradeToWaasBanner();
+ * }
+ * ```
+ * @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
+ * @returns True when at least one wallet account requires an upgrade to Dynamic WaaS, false otherwise.
+ * @see getWalletsRequiringUpgrade
+ * @see startUpgradeRedirect
+ */
+export declare const hasWalletsRequiringUpgrade: (client?: import("@dynamic-labs-sdk/client").DynamicClient) => boolean;
+//# sourceMappingURL=hasWalletsRequiringUpgrade.d.ts.map

package/dist/hasWalletsRequiringUpgrade/hasWalletsRequiringUpgrade.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hasWalletsRequiringUpgrade.d.ts","sourceRoot":"","sources":["../../src/hasWalletsRequiringUpgrade/hasWalletsRequiringUpgrade.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,0BAA0B,iEAEpC,OAAwD,CAAC"}

package/dist/hasWalletsRequiringUpgrade/index.d.ts

@@ -0,0 +1,2 @@
+export { hasWalletsRequiringUpgrade } from './hasWalletsRequiringUpgrade';
+//# sourceMappingURL=index.d.ts.map

package/dist/hasWalletsRequiringUpgrade/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/hasWalletsRequiringUpgrade/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,0BAA0B,EAAE,MAAM,8BAA8B,CAAC"}

package/dist/index.cjs

@@ -0,0 +1,192 @@
+let _dynamic_labs_sdk_assert_package_version = require("@dynamic-labs-sdk/assert-package-version");
+let _dynamic_labs_sdk_client = require("@dynamic-labs-sdk/client");
+let _dynamic_labs_sdk_client_core = require("@dynamic-labs-sdk/client/core");
+
+//#region package.json
+var name = "@dynamic-labs-sdk/legacy-embedded-wallet-upgrade";
+var version = "1.21.2";
+
+//#endregion
+//#region src/errors/InvalidUpgradeBaseUrlError.ts
+var InvalidUpgradeBaseUrlError = class extends _dynamic_labs_sdk_client.BaseError {
+	constructor(baseUrl) {
+		super({
+			cause: null,
+			code: "invalid_upgrade_base_url_error",
+			docsUrl: null,
+			name: "InvalidUpgradeBaseUrlError",
+			shortMessage: `Upgrade baseUrl must be an absolute https URL, received: ${baseUrl}`
+		});
+	}
+};
+
+//#endregion
+//#region src/errors/InvalidUpgradeRedirectUrlError.ts
+var InvalidUpgradeRedirectUrlError = class extends _dynamic_labs_sdk_client.BaseError {
+	constructor(redirectUrl) {
+		super({
+			cause: null,
+			code: "invalid_upgrade_redirect_url_error",
+			docsUrl: null,
+			name: "InvalidUpgradeRedirectUrlError",
+			shortMessage: `Upgrade redirectUrl must be an absolute https URL, received: ${redirectUrl}`
+		});
+	}
+};
+
+//#endregion
+//#region src/upgradeAppContract.ts
+/**
+* Default base URL of the hosted WaaS upgrade app. Both upgrade paths point at
+* this origin and append `environmentId` + `redirectUrl` query params. Callers
+* can override it (e.g. to target a local or preview build during QA) via the
+* `baseUrl` option on the public functions.
+*/
+const UPGRADE_APP_BASE_URL = "https://waas-migration-dynamic-xyz.vercel.app";
+/**
+* Query param the upgrade app requires: which Dynamic environment to
+* authenticate the user against. Derived from the Dynamic client so callers
+* never pass it explicitly.
+*/
+const UPGRADE_ENVIRONMENT_ID_PARAM = "environmentId";
+/**
+* Query param the upgrade app requires: where to send the user (redirect flow)
+* or which origin it postMessages to (iframe flow) once the upgrade finishes.
+* The upgrade app rejects anything that is not an absolute https URL.
+*/
+const UPGRADE_REDIRECT_URL_PARAM = "redirectUrl";
+
+//#endregion
+//#region src/buildUpgradeUrl/buildUpgradeUrl.ts
+const HTTPS_PROTOCOL = "https:";
+/**
+* Builds the URL that drives the hosted upgrade app for the client's Dynamic
+* environment and a return target.
+*
+* This is the low-level primitive behind every upgrade path: the redirect flow
+* navigates the top-level window to it, the iframe flow loads it as the iframe
+* `src`, and a React Native WebView can load it directly. The environment id is
+* read from the client, and `redirectUrl` defaults to the current page, so the
+* common call is zero-arg. Prefer {@link startUpgradeRedirect} or
+* {@link openUpgradeIframe} unless you are mounting the upgrade app yourself.
+*
+* @example
+* ```ts
+* const src = buildUpgradeUrl();
+* // or target a local upgrade app during QA:
+* const localSrc = buildUpgradeUrl({ baseUrl: 'https://localhost:3000' });
+* ```
+* @param [params] - Options for the generated URL.
+* @param [params.redirectUrl] - Absolute https return URL; defaults to `window.location.href`.
+* @param [params.baseUrl] - Upgrade app base URL; defaults to the production app.
+* @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
+* @returns The fully-qualified upgrade app URL to load.
+* @throws {InvalidUpgradeRedirectUrlError} When `redirectUrl` is not an absolute https URL.
+* @throws {InvalidUpgradeBaseUrlError} When `baseUrl` is not an absolute https URL.
+* @throws {UnavailableInServerSideError} When called during SSR without an explicit `redirectUrl`.
+* @see startUpgradeRedirect
+* @see openUpgradeIframe
+*/
+const buildUpgradeUrl = ({ redirectUrl, baseUrl = UPGRADE_APP_BASE_URL } = {}, client = (0, _dynamic_labs_sdk_client.getDefaultClient)()) => {
+	if (redirectUrl === void 0 && typeof window === "undefined") throw new _dynamic_labs_sdk_client.UnavailableInServerSideError("buildUpgradeUrl");
+	const resolvedRedirectUrl = redirectUrl ?? window.location.href;
+	if (new URL(resolvedRedirectUrl).protocol !== HTTPS_PROTOCOL) throw new InvalidUpgradeRedirectUrlError(resolvedRedirectUrl);
+	const url = new URL(baseUrl);
+	if (url.protocol !== HTTPS_PROTOCOL) throw new InvalidUpgradeBaseUrlError(baseUrl);
+	const { environmentId } = (0, _dynamic_labs_sdk_client_core.getCore)(client);
+	url.searchParams.set(UPGRADE_ENVIRONMENT_ID_PARAM, environmentId);
+	url.searchParams.set(UPGRADE_REDIRECT_URL_PARAM, resolvedRedirectUrl);
+	return url.toString();
+};
+
+//#endregion
+//#region src/walletAccountRequiresUpgrade/walletAccountRequiresUpgrade.ts
+/**
+* Provider-key substring shared by every Dynamic embedded wallet that predates
+* Dynamic WaaS and can therefore be upgraded to it. A wallet account's
+* `walletProviderKey` is a composite backend value (e.g. `<provider>evm` /
+* `<provider>hdsolana` suffixed with `:embeddedWallet`); both the standard and
+* HD variants contain this marker, so matching it as a substring identifies all
+* of them. This is an opaque backend value, matched verbatim — not a user-facing
+* concept.
+*/
+const LEGACY_EMBEDDED_WALLET_PROVIDER_KEY = "turnkey";
+/**
+* Returns whether a wallet account is a legacy Dynamic embedded wallet that
+* requires an upgrade to Dynamic WaaS.
+*
+* Shared predicate behind both the imperative {@link getWalletsRequiringUpgrade}
+* getter and the reactive `useWalletsRequiringUpgrade` hook, so the definition
+* of "requires upgrade" lives in exactly one place.
+*
+* @example
+* ```ts
+* const upgradeable = walletAccounts.filter(walletAccountRequiresUpgrade);
+* ```
+* @param walletAccount - The wallet account to test.
+* @returns True when the account is a legacy embedded wallet requiring an upgrade.
+* @see getWalletsRequiringUpgrade
+* @see hasWalletsRequiringUpgrade
+*/
+const walletAccountRequiresUpgrade = (walletAccount) => walletAccount.walletProviderKey.includes(LEGACY_EMBEDDED_WALLET_PROVIDER_KEY);
+
+//#endregion
+//#region src/getWalletsRequiringUpgrade/getWalletsRequiringUpgrade.ts
+/**
+* Returns the current session's wallet accounts that are legacy Dynamic
+* embedded wallets requiring an upgrade to Dynamic WaaS.
+*
+* These are earlier-generation Dynamic embedded wallets that predate Dynamic
+* WaaS (the current TSS-MPC embedded wallet) and can be upgraded to it. Use this
+* when you need the accounts themselves — for example to render only the
+* upgrade entry points on those wallets. Already-upgraded Dynamic WaaS accounts
+* are never returned. For a simple boolean check, use
+* {@link hasWalletsRequiringUpgrade}.
+*
+* @example
+* ```ts
+* const walletsRequiringUpgrade = getWalletsRequiringUpgrade();
+* if (walletsRequiringUpgrade.length > 0) {
+*   promptUpgrade(walletsRequiringUpgrade);
+* }
+* ```
+* @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
+* @returns The wallet accounts requiring an upgrade to Dynamic WaaS (empty when none).
+* @see hasWalletsRequiringUpgrade
+* @see startUpgradeRedirect
+*/
+const getWalletsRequiringUpgrade = (client = (0, _dynamic_labs_sdk_client.getDefaultClient)()) => (0, _dynamic_labs_sdk_client.getWalletAccounts)(client).filter(walletAccountRequiresUpgrade);
+
+//#endregion
+//#region src/hasWalletsRequiringUpgrade/hasWalletsRequiringUpgrade.ts
+/**
+* Returns whether the current session has any legacy Dynamic embedded wallet
+* that requires an upgrade to Dynamic WaaS.
+*
+* A boolean convenience over {@link getWalletsRequiringUpgrade} for the common
+* case where you only need to decide whether to surface the upgrade flow (e.g.
+* show a banner or gate a wallet's actions) rather than act on the specific
+* accounts.
+*
+* @example
+* ```ts
+* if (hasWalletsRequiringUpgrade()) {
+*   showUpgradeToWaasBanner();
+* }
+* ```
+* @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
+* @returns True when at least one wallet account requires an upgrade to Dynamic WaaS, false otherwise.
+* @see getWalletsRequiringUpgrade
+* @see startUpgradeRedirect
+*/
+const hasWalletsRequiringUpgrade = (client = (0, _dynamic_labs_sdk_client.getDefaultClient)()) => getWalletsRequiringUpgrade(client).length > 0;
+
+//#endregion
+//#region src/exports/index.ts
+(0, _dynamic_labs_sdk_assert_package_version.assertPackageVersion)(name, version);
+
+//#endregion
+exports.buildUpgradeUrl = buildUpgradeUrl;
+exports.getWalletsRequiringUpgrade = getWalletsRequiringUpgrade;
+exports.hasWalletsRequiringUpgrade = hasWalletsRequiringUpgrade;
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","names":["BaseError","BaseError","UnavailableInServerSideError","packageName","packageVersion"],"sources":["../package.json","../src/errors/InvalidUpgradeBaseUrlError.ts","../src/errors/InvalidUpgradeRedirectUrlError.ts","../src/upgradeAppContract.ts","../src/buildUpgradeUrl/buildUpgradeUrl.ts","../src/walletAccountRequiresUpgrade/walletAccountRequiresUpgrade.ts","../src/getWalletsRequiringUpgrade/getWalletsRequiringUpgrade.ts","../src/hasWalletsRequiringUpgrade/hasWalletsRequiringUpgrade.ts","../src/exports/index.ts"],"sourcesContent":["","import { BaseError } from '@dynamic-labs-sdk/client';\n\nexport class InvalidUpgradeBaseUrlError extends BaseError {\n  // eslint-disable-next-line custom-rules/require-single-object-param\n  constructor(baseUrl: string) {\n    super({\n      cause: null,\n      code: 'invalid_upgrade_base_url_error',\n      docsUrl: null,\n      name: 'InvalidUpgradeBaseUrlError',\n      shortMessage: `Upgrade baseUrl must be an absolute https URL, received: ${baseUrl}`,\n    });\n  }\n}\n","import { BaseError } from '@dynamic-labs-sdk/client';\n\nexport class InvalidUpgradeRedirectUrlError extends BaseError {\n  // eslint-disable-next-line custom-rules/require-single-object-param\n  constructor(redirectUrl: string) {\n    super({\n      cause: null,\n      code: 'invalid_upgrade_redirect_url_error',\n      docsUrl: null,\n      name: 'InvalidUpgradeRedirectUrlError',\n      shortMessage: `Upgrade redirectUrl must be an absolute https URL, received: ${redirectUrl}`,\n    });\n  }\n}\n","// Contract shared with the standalone WaaS upgrade app\n// (dynamic-labs-oss/waas-migration). Every identifier below MUST stay\n// byte-for-byte identical to the ones the upgrade app reads/emits in its\n// `migrationConfig.ts`, otherwise the redirect round-trip and the iframe\n// postMessage handshake break silently.\n\n/**\n * Default base URL of the hosted WaaS upgrade app. Both upgrade paths point at\n * this origin and append `environmentId` + `redirectUrl` query params. Callers\n * can override it (e.g. to target a local or preview build during QA) via the\n * `baseUrl` option on the public functions.\n */\nexport const UPGRADE_APP_BASE_URL =\n  'https://waas-migration-dynamic-xyz.vercel.app';\n\n/**\n * Query param the upgrade app requires: which Dynamic environment to\n * authenticate the user against. Derived from the Dynamic client so callers\n * never pass it explicitly.\n */\nexport const UPGRADE_ENVIRONMENT_ID_PARAM = 'environmentId';\n\n/**\n * Query param the upgrade app requires: where to send the user (redirect flow)\n * or which origin it postMessages to (iframe flow) once the upgrade finishes.\n * The upgrade app rejects anything that is not an absolute https URL.\n */\nexport const UPGRADE_REDIRECT_URL_PARAM = 'redirectUrl';\n\n/**\n * postMessage `type` the upgrade app emits to its iframe parent on completion.\n */\nexport const UPGRADE_COMPLETE_MESSAGE_TYPE = 'dynamic-waas-migration:complete';\n\n/**\n * Query param the upgrade app appends to `redirectUrl` when it runs top-level\n * (redirect flow), carrying the outcome back to the app after navigation.\n */\nexport const UPGRADE_STATUS_PARAM = 'dynamicWaasMigrationStatus';\n\n/** Outcome value the upgrade app reports when the upgrade succeeded. */\nexport const UPGRADE_STATUS_SUCCESS = 'success';\n\n/** Outcome value the upgrade app reports when the upgrade failed. */\nexport const UPGRADE_STATUS_ERROR = 'error';\n\n/**\n * The outcome of a legacy embedded wallet upgrade attempt: `success` when the\n * wallet was upgraded to Dynamic WaaS, `error` when it failed. These are the\n * only two values the upgrade app ever reports, on both the redirect and the\n * iframe paths.\n *\n * @example\n * ```ts\n * const isSuccess = (status: WalletUpgradeStatus) => status === 'success';\n * ```\n * @see WalletUpgradeOutcome\n * @see consumeUpgradeRedirect\n */\nexport type WalletUpgradeStatus =\n  | typeof UPGRADE_STATUS_SUCCESS\n  | typeof UPGRADE_STATUS_ERROR;\n\n/**\n * The resolved result of an upgrade flow, carrying the reported\n * {@link WalletUpgradeStatus}. Returned by the redirect-result consumer and\n * handed to the iframe completion callback so callers can react (toast,\n * refetch, close a sheet, etc.).\n *\n * @example\n * ```ts\n * const onComplete = (outcome: WalletUpgradeOutcome) => {\n *   if (outcome.status === 'success') showSuccessToast();\n * };\n * ```\n * @see WalletUpgradeStatus\n * @see subscribeToUpgradeCompletion\n */\nexport type WalletUpgradeOutcome = {\n  status: WalletUpgradeStatus;\n};\n\n/**\n * Shape of the completion message the upgrade app posts to its parent window\n * in the iframe flow. Internal to the message handshake — consumers receive the\n * parsed {@link WalletUpgradeOutcome} instead.\n */\nexport type UpgradeCompleteMessage = {\n  status: WalletUpgradeStatus;\n  type: typeof UPGRADE_COMPLETE_MESSAGE_TYPE;\n};\n","/* eslint-disable no-restricted-globals */\n\nimport {\n  UnavailableInServerSideError,\n  getDefaultClient,\n} from '@dynamic-labs-sdk/client';\nimport { getCore } from '@dynamic-labs-sdk/client/core';\n\nimport { InvalidUpgradeBaseUrlError } from '../errors/InvalidUpgradeBaseUrlError';\nimport { InvalidUpgradeRedirectUrlError } from '../errors/InvalidUpgradeRedirectUrlError';\nimport {\n  UPGRADE_APP_BASE_URL,\n  UPGRADE_ENVIRONMENT_ID_PARAM,\n  UPGRADE_REDIRECT_URL_PARAM,\n} from '../upgradeAppContract';\n\nconst HTTPS_PROTOCOL = 'https:';\n\ntype BuildUpgradeUrlParams = {\n  /**\n   * Base URL of the hosted upgrade app. Defaults to the production upgrade app;\n   * override it to target a local or preview build (e.g. during QA).\n   */\n  baseUrl?: string;\n  /**\n   * Absolute https URL the upgrade app returns to (redirect flow) or\n   * postMessages (iframe flow) on completion. Defaults to the current page\n   * (`window.location.href`). The upgrade app rejects any non-https URL.\n   */\n  redirectUrl?: string;\n};\n\n/**\n * Builds the URL that drives the hosted upgrade app for the client's Dynamic\n * environment and a return target.\n *\n * This is the low-level primitive behind every upgrade path: the redirect flow\n * navigates the top-level window to it, the iframe flow loads it as the iframe\n * `src`, and a React Native WebView can load it directly. The environment id is\n * read from the client, and `redirectUrl` defaults to the current page, so the\n * common call is zero-arg. Prefer {@link startUpgradeRedirect} or\n * {@link openUpgradeIframe} unless you are mounting the upgrade app yourself.\n *\n * @example\n * ```ts\n * const src = buildUpgradeUrl();\n * // or target a local upgrade app during QA:\n * const localSrc = buildUpgradeUrl({ baseUrl: 'https://localhost:3000' });\n * ```\n * @param [params] - Options for the generated URL.\n * @param [params.redirectUrl] - Absolute https return URL; defaults to `window.location.href`.\n * @param [params.baseUrl] - Upgrade app base URL; defaults to the production app.\n * @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.\n * @returns The fully-qualified upgrade app URL to load.\n * @throws {InvalidUpgradeRedirectUrlError} When `redirectUrl` is not an absolute https URL.\n * @throws {InvalidUpgradeBaseUrlError} When `baseUrl` is not an absolute https URL.\n * @throws {UnavailableInServerSideError} When called during SSR without an explicit `redirectUrl`.\n * @see startUpgradeRedirect\n * @see openUpgradeIframe\n */\nexport const buildUpgradeUrl = (\n  { redirectUrl, baseUrl = UPGRADE_APP_BASE_URL }: BuildUpgradeUrlParams = {},\n  client = getDefaultClient()\n): string => {\n  // The default return target is the current page, which only exists in the\n  // browser; fail loudly during SSR rather than dereferencing an absent window.\n  if (redirectUrl === undefined && typeof window === 'undefined') {\n    throw new UnavailableInServerSideError('buildUpgradeUrl');\n  }\n\n  const resolvedRedirectUrl = redirectUrl ?? window.location.href;\n\n  // Validate the return target up front: the upgrade app only accepts an\n  // absolute https URL, so reject anything else (relative, http, other schemes)\n  // here rather than letting it be silently refused after navigation. `new URL`\n  // throws on non-absolute input, so the explicit check only guards the scheme.\n  const parsedRedirectUrl = new URL(resolvedRedirectUrl);\n\n  if (parsedRedirectUrl.protocol !== HTTPS_PROTOCOL) {\n    throw new InvalidUpgradeRedirectUrlError(resolvedRedirectUrl);\n  }\n\n  // Validate the upgrade app origin before we ever load it in an iframe or\n  // navigate to it. The default is a trusted https app, but `baseUrl` is an\n  // override (custom deployments, forks, local QA), so enforce the https scheme\n  // to reject non-secure or dangerous schemes (`http:`, `javascript:`, `data:`)\n  // rather than mounting an untrusted origin. Any https host is allowed on\n  // purpose — customers self-host the upgrade app on their own domains.\n  const url = new URL(baseUrl);\n\n  if (url.protocol !== HTTPS_PROTOCOL) {\n    throw new InvalidUpgradeBaseUrlError(baseUrl);\n  }\n\n  const { environmentId } = getCore(client);\n\n  url.searchParams.set(UPGRADE_ENVIRONMENT_ID_PARAM, environmentId);\n  url.searchParams.set(UPGRADE_REDIRECT_URL_PARAM, resolvedRedirectUrl);\n\n  return url.toString();\n};\n","import type { WalletAccount } from '@dynamic-labs-sdk/client';\n\n/**\n * Provider-key substring shared by every Dynamic embedded wallet that predates\n * Dynamic WaaS and can therefore be upgraded to it. A wallet account's\n * `walletProviderKey` is a composite backend value (e.g. `<provider>evm` /\n * `<provider>hdsolana` suffixed with `:embeddedWallet`); both the standard and\n * HD variants contain this marker, so matching it as a substring identifies all\n * of them. This is an opaque backend value, matched verbatim — not a user-facing\n * concept.\n */\nconst LEGACY_EMBEDDED_WALLET_PROVIDER_KEY = 'turnkey';\n\n/**\n * Returns whether a wallet account is a legacy Dynamic embedded wallet that\n * requires an upgrade to Dynamic WaaS.\n *\n * Shared predicate behind both the imperative {@link getWalletsRequiringUpgrade}\n * getter and the reactive `useWalletsRequiringUpgrade` hook, so the definition\n * of \"requires upgrade\" lives in exactly one place.\n *\n * @example\n * ```ts\n * const upgradeable = walletAccounts.filter(walletAccountRequiresUpgrade);\n * ```\n * @param walletAccount - The wallet account to test.\n * @returns True when the account is a legacy embedded wallet requiring an upgrade.\n * @see getWalletsRequiringUpgrade\n * @see hasWalletsRequiringUpgrade\n */\nexport const walletAccountRequiresUpgrade = (\n  walletAccount: WalletAccount\n): boolean =>\n  walletAccount.walletProviderKey.includes(\n    LEGACY_EMBEDDED_WALLET_PROVIDER_KEY\n  );\n","import {\n  type WalletAccount,\n  getDefaultClient,\n  getWalletAccounts,\n} from '@dynamic-labs-sdk/client';\n\nimport { walletAccountRequiresUpgrade } from '../walletAccountRequiresUpgrade';\n\n/**\n * Returns the current session's wallet accounts that are legacy Dynamic\n * embedded wallets requiring an upgrade to Dynamic WaaS.\n *\n * These are earlier-generation Dynamic embedded wallets that predate Dynamic\n * WaaS (the current TSS-MPC embedded wallet) and can be upgraded to it. Use this\n * when you need the accounts themselves — for example to render only the\n * upgrade entry points on those wallets. Already-upgraded Dynamic WaaS accounts\n * are never returned. For a simple boolean check, use\n * {@link hasWalletsRequiringUpgrade}.\n *\n * @example\n * ```ts\n * const walletsRequiringUpgrade = getWalletsRequiringUpgrade();\n * if (walletsRequiringUpgrade.length > 0) {\n *   promptUpgrade(walletsRequiringUpgrade);\n * }\n * ```\n * @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.\n * @returns The wallet accounts requiring an upgrade to Dynamic WaaS (empty when none).\n * @see hasWalletsRequiringUpgrade\n * @see startUpgradeRedirect\n */\nexport const getWalletsRequiringUpgrade = (\n  client = getDefaultClient()\n): WalletAccount[] =>\n  getWalletAccounts(client).filter(walletAccountRequiresUpgrade);\n","import { getDefaultClient } from '@dynamic-labs-sdk/client';\n\nimport { getWalletsRequiringUpgrade } from '../getWalletsRequiringUpgrade';\n\n/**\n * Returns whether the current session has any legacy Dynamic embedded wallet\n * that requires an upgrade to Dynamic WaaS.\n *\n * A boolean convenience over {@link getWalletsRequiringUpgrade} for the common\n * case where you only need to decide whether to surface the upgrade flow (e.g.\n * show a banner or gate a wallet's actions) rather than act on the specific\n * accounts.\n *\n * @example\n * ```ts\n * if (hasWalletsRequiringUpgrade()) {\n *   showUpgradeToWaasBanner();\n * }\n * ```\n * @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.\n * @returns True when at least one wallet account requires an upgrade to Dynamic WaaS, false otherwise.\n * @see getWalletsRequiringUpgrade\n * @see startUpgradeRedirect\n */\nexport const hasWalletsRequiringUpgrade = (\n  client = getDefaultClient()\n): boolean => getWalletsRequiringUpgrade(client).length > 0;\n","import { assertPackageVersion } from '@dynamic-labs-sdk/assert-package-version';\n\nimport {\n  name as packageName,\n  version as packageVersion,\n} from '../../package.json';\n\nassertPackageVersion(packageName, packageVersion);\n\nexport { buildUpgradeUrl } from '../buildUpgradeUrl';\nexport { getWalletsRequiringUpgrade } from '../getWalletsRequiringUpgrade';\nexport { hasWalletsRequiringUpgrade } from '../hasWalletsRequiringUpgrade';\n"],"mappings":";;;;;;;;;;ACEA,IAAa,6BAAb,cAAgDA,mCAAU;CAExD,YAAY,SAAiB;AAC3B,QAAM;GACJ,OAAO;GACP,MAAM;GACN,SAAS;GACT,MAAM;GACN,cAAc,4DAA4D;GAC3E,CAAC;;;;;;ACTN,IAAa,iCAAb,cAAoDC,mCAAU;CAE5D,YAAY,aAAqB;AAC/B,QAAM;GACJ,OAAO;GACP,MAAM;GACN,SAAS;GACT,MAAM;GACN,cAAc,gEAAgE;GAC/E,CAAC;;;;;;;;;;;;ACCN,MAAa,uBACX;;;;;;AAOF,MAAa,+BAA+B;;;;;;AAO5C,MAAa,6BAA6B;;;;ACX1C,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4CvB,MAAa,mBACX,EAAE,aAAa,UAAU,yBAAgD,EAAE,EAC3E,yDAA2B,KAChB;AAGX,KAAI,gBAAgB,UAAa,OAAO,WAAW,YACjD,OAAM,IAAIC,sDAA6B,kBAAkB;CAG3D,MAAM,sBAAsB,eAAe,OAAO,SAAS;AAQ3D,KAF0B,IAAI,IAAI,oBAAoB,CAEhC,aAAa,eACjC,OAAM,IAAI,+BAA+B,oBAAoB;CAS/D,MAAM,MAAM,IAAI,IAAI,QAAQ;AAE5B,KAAI,IAAI,aAAa,eACnB,OAAM,IAAI,2BAA2B,QAAQ;CAG/C,MAAM,EAAE,6DAA0B,OAAO;AAEzC,KAAI,aAAa,IAAI,8BAA8B,cAAc;AACjE,KAAI,aAAa,IAAI,4BAA4B,oBAAoB;AAErE,QAAO,IAAI,UAAU;;;;;;;;;;;;;;ACxFvB,MAAM,sCAAsC;;;;;;;;;;;;;;;;;;AAmB5C,MAAa,gCACX,kBAEA,cAAc,kBAAkB,SAC9B,oCACD;;;;;;;;;;;;;;;;;;;;;;;;;;;ACJH,MAAa,8BACX,yDAA2B,qDAET,OAAO,CAAC,OAAO,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;ACVhE,MAAa,8BACX,yDAA2B,KACf,2BAA2B,OAAO,CAAC,SAAS;;;;mECnBrCC,MAAaC,QAAe"}