@dynamic-labs/legacy-embedded-wallet-migration 0.0.0 → 5.0.0-rc.2

package/src/lib/recovery/usePasskeyRecovery/usePasskeyRecovery.js

@@ -0,0 +1,197 @@
+'use client'
+import { __awaiter } from '../../../../_virtual/_tslib.js';
+import { useCallback } from 'react';
+import { getDefaultClient, getCore, createApiClient, updateAuthFromVerifyResponse } from '@dynamic-labs-sdk/client/core';
+import { WalletProviderEnum, NextViewEnum } from '@dynamic-labs/sdk-api-core';
+import { logger, isPasskeyWalletConnector, isSessionKeyCompatibleWalletConnector } from '@dynamic-labs/wallet-connector-core';
+import { addEmailRecovery } from '../addEmailRecovery/addEmailRecovery.js';
+import { addNewPasskeyAuthenticator } from '../addNewPasskeyAuthenticator/addNewPasskeyAuthenticator.js';
+import { canRestoreEmbeddedWalletSession } from '../canRestoreEmbeddedWalletSession/canRestoreEmbeddedWalletSession.js';
+import { restoreEmbeddedWalletSession } from '../restoreEmbeddedWalletSession/restoreEmbeddedWalletSession.js';
+import { iframeElementId } from '../constants.js';
+import { useInitEmbeddedWalletAuthMethod } from '../useInitEmbeddedWalletAuthMethod/useInitEmbeddedWalletAuthMethod.js';
+
+const sessionExpirationUnit = {
+    days: 86400,
+    hours: 3600,
+    minutes: 60,
+};
+const toSessionExpirationSeconds = (duration) => {
+    var _a, _b;
+    if (!duration)
+        return 0;
+    const amount = (_a = duration.amount) !== null && _a !== void 0 ? _a : 0;
+    const unit = (_b = sessionExpirationUnit[duration.unit]) !== null && _b !== void 0 ? _b : 0;
+    return amount * unit;
+};
+const enabledSecurityMethodKeys = (supportedSecurityMethods) => {
+    if (!supportedSecurityMethods)
+        return [];
+    return Object.keys(supportedSecurityMethods).filter((key) => { var _a; return (_a = supportedSecurityMethods[key]) === null || _a === void 0 ? void 0 : _a.isEnabled; });
+};
+const hasEmbeddedWalletCredential = (user) => {
+    var _a;
+    return Boolean((_a = user === null || user === void 0 ? void 0 : user.verifiedCredentials) === null || _a === void 0 ? void 0 : _a.some(({ walletProvider }) => walletProvider === WalletProviderEnum.EmbeddedWallet));
+};
+const usePasskeyRecovery = ({ user, wallet, primaryWallet, sessionKeyDuration, supportedSecurityMethods, isTurnkeyWalletWithoutAuthenticator, hasRecoveryEmail, iframeContainer, onShowAddRecoveryEmail, onShowAuthChoice, awaitEmailVerification, onShowEmailBundle, onAuthMethodComplete, onEmailRecoveryComplete, onEmailRecoveryFailed, }) => {
+    const sessionExpiration = toSessionExpirationSeconds(sessionKeyDuration);
+    const { initAuthMethod } = useInitEmbeddedWalletAuthMethod({
+        onComplete: onAuthMethodComplete,
+        onShowEmailBundle,
+        sessionExpiration,
+        user,
+        wallet,
+    });
+    const isSessionRestored = useCallback(() => __awaiter(void 0, void 0, void 0, function* () {
+        if (!sessionKeyDuration ||
+            !canRestoreEmbeddedWalletSession(sessionKeyDuration)) {
+            return false;
+        }
+        try {
+            return yield restoreEmbeddedWalletSession({
+                iframeContainer: iframeContainer,
+                iframeElementId,
+                sessionExpiration,
+                user,
+                wallet: primaryWallet,
+            });
+        }
+        catch (err) {
+            logger.error('Failed to restore embedded wallet', err);
+        }
+        return false;
+    }), [
+        user,
+        iframeContainer,
+        primaryWallet,
+        sessionKeyDuration,
+        sessionExpiration,
+    ]);
+    const shouldInitRecovery = useCallback(() => __awaiter(void 0, void 0, void 0, function* () {
+        if (!wallet || !isPasskeyWalletConnector(wallet.connector)) {
+            return false;
+        }
+        const turnkeyRecoveryHandler = wallet.connector.getAuthenticatorHandler();
+        // user has passkey authenticator set up OR
+        // email auth - session is still up, so no need to recover
+        if (!isTurnkeyWalletWithoutAuthenticator ||
+            turnkeyRecoveryHandler.isSessionActive() ||
+            (yield isSessionRestored())) {
+            return false;
+        }
+        // For v2 wallets that logged in via email: the session key fetcher is
+        // wired by LegacyWalletMigrationRecoveryProvider on mount. The export
+        // step (LegacyEmbeddedWalletExport) handles its own session creation
+        // via createOrRestoreSession + getTurnkeyClient in sequence, so we
+        // can skip recovery for any session-key-compatible connector — the
+        // export component will establish the session itself.
+        if (isSessionKeyCompatibleWalletConnector(wallet.connector)) {
+            return false;
+        }
+        return true;
+    }), [wallet, isTurnkeyWalletWithoutAuthenticator, isSessionRestored]);
+    const initPasskeyRecoveryProcess = useCallback((authenticatorType, currentAction) => __awaiter(void 0, void 0, void 0, function* () {
+        if (!user) {
+            throw new Error('User is not logged in');
+        }
+        if (!hasEmbeddedWalletCredential(user)) {
+            throw new Error('Dynamic embedded wallet not found');
+        }
+        if (wallet && !isPasskeyWalletConnector(wallet.connector)) {
+            throw new Error('Dynamic embedded wallet not found.');
+        }
+        const turnkeyRecoveryHandler = (wallet === null || wallet === void 0 ? void 0 : wallet.connector).getAuthenticatorHandler();
+        // email auth - session is still up, so create passkey authenticator using the same session
+        if (authenticatorType === 'passkey' &&
+            turnkeyRecoveryHandler.isSessionActive()) {
+            yield addNewPasskeyAuthenticator({ user, wallet });
+            onAuthMethodComplete();
+            return;
+        }
+        const supportedAuthenticatorMethods = enabledSecurityMethodKeys(supportedSecurityMethods);
+        if (!hasRecoveryEmail) {
+            onShowAddRecoveryEmail();
+            return;
+        }
+        if (!authenticatorType && supportedAuthenticatorMethods.length > 1) {
+            onShowAuthChoice(currentAction);
+            return;
+        }
+        const [authType] = supportedAuthenticatorMethods;
+        // Since we force authenticatorType = 'email' during transactions when no
+        // passkey is configured, make sure it's actually supported. Otherwise
+        // fall back to the first supported authenticator type from the list.
+        let nextAuthenticatorType = authenticatorType !== null && authenticatorType !== void 0 ? authenticatorType : authType;
+        if (authenticatorType &&
+            !supportedAuthenticatorMethods.includes(authenticatorType)) {
+            nextAuthenticatorType = authType;
+        }
+        yield initAuthMethod({
+            authenticatorType: nextAuthenticatorType,
+            currentAction,
+            iframeContainer: iframeContainer,
+        });
+    }), [
+        wallet,
+        supportedSecurityMethods,
+        hasRecoveryEmail,
+        user,
+        onShowAddRecoveryEmail,
+        onShowAuthChoice,
+        onAuthMethodComplete,
+        initAuthMethod,
+        iframeContainer,
+    ]);
+    const updateUserProfile = (emailInput) => __awaiter(void 0, void 0, void 0, function* () {
+        var _a;
+        try {
+            const client = getDefaultClient();
+            const core = getCore(client);
+            const apiClient = createApiClient({}, client);
+            const response = yield apiClient.updateSelf({
+                environmentId: core.environmentId,
+                userFields: { email: emailInput },
+            });
+            updateAuthFromVerifyResponse({ response }, client);
+            if (response.nextView === NextViewEnum.Done) {
+                return response.user;
+            }
+            const verified = yield awaitEmailVerification({
+                email: emailInput,
+                verificationUUID: (_a = response.emailVerification) === null || _a === void 0 ? void 0 : _a.verificationUUID,
+            });
+            if (!verified) {
+                throw new Error('Failed to verify email');
+            }
+            return response.user;
+        }
+        catch (err) {
+            logger.error('Failed to update user email', err);
+            throw err;
+        }
+    });
+    const addRecoveryEmail = (emailInput) => __awaiter(void 0, void 0, void 0, function* () {
+        try {
+            let updatedUser = user;
+            if (!(user === null || user === void 0 ? void 0 : user.email)) {
+                updatedUser = (yield updateUserProfile(emailInput));
+            }
+            yield addEmailRecovery({
+                user: updatedUser,
+                wallet: primaryWallet,
+            });
+            onEmailRecoveryComplete === null || onEmailRecoveryComplete === void 0 ? void 0 : onEmailRecoveryComplete();
+        }
+        catch (err) {
+            logger.error('Failed to add recovery email', err);
+            onEmailRecoveryFailed === null || onEmailRecoveryFailed === void 0 ? void 0 : onEmailRecoveryFailed(err);
+        }
+    });
+    return {
+        addRecoveryEmail,
+        initPasskeyRecoveryProcess,
+        shouldInitRecovery,
+    };
+};
+
+export { usePasskeyRecovery };

package/src/lib/restoreEmbeddedWallet/index.d.ts

@@ -0,0 +1 @@
+export { restoreEmbeddedWallet } from './restoreEmbeddedWallet';

package/src/lib/restoreEmbeddedWallet/restoreEmbeddedWallet.d.ts

@@ -0,0 +1,5 @@
+type RestoreEmbeddedWalletProps = {
+    walletId: string;
+};
+export declare const restoreEmbeddedWallet: ({ walletId, }: RestoreEmbeddedWalletProps) => Promise<void>;
+export {};

package/src/lib/restoreEmbeddedWallet/restoreEmbeddedWallet.js

@@ -0,0 +1,21 @@
+'use client'
+import { __awaiter } from '../../../_virtual/_tslib.js';
+import { getDefaultClient, getCore, createApiClient } from '@dynamic-labs-sdk/client/core';
+import { DynamicError } from '@dynamic-labs/utils';
+
+const restoreEmbeddedWallet = (_a) => __awaiter(void 0, [_a], void 0, function* ({ walletId, }) {
+    const client = getDefaultClient();
+    const core = getCore(client);
+    const apiClient = createApiClient({}, client);
+    try {
+        yield apiClient.restoreEmbeddedWallet({
+            environmentId: core.environmentId,
+            walletId,
+        });
+    }
+    catch (e) {
+        throw new DynamicError('Error restoring embedded wallet', 'restore_embedded_wallet_failed');
+    }
+});
+
+export { restoreEmbeddedWallet };

package/src/lib/sessionKeys/base64urlDecode/base64urlDecode.d.ts

@@ -0,0 +1 @@
+export declare const base64urlDecode: (s?: string) => Uint8Array;

package/src/lib/sessionKeys/base64urlDecode/base64urlDecode.js

@@ -0,0 +1,12 @@
+'use client'
+// Takes a base64url-encoded string (e.g. "nMueRPiAm51YXEjRtka8S_8Ura3HaqbmqDqMJCZmvkM")
+// and returns the corresponding bytes as a Uint8Array.
+const base64urlDecode = (s) => {
+    var _a;
+    // Go from base64url encoding to base64 encoding
+    const base64 = (_a = s === null || s === void 0 ? void 0 : s.replace(/-/g, '+').replace(/_/g, '/')) !== null && _a !== void 0 ? _a : '';
+    // Use `atob` to decode base64
+    return Uint8Array.from(atob(base64), (c) => c.charCodeAt(0));
+};
+
+export { base64urlDecode };

package/src/lib/sessionKeys/base64urlDecode/index.d.ts

@@ -0,0 +1 @@
+export { base64urlDecode } from './base64urlDecode';

package/src/lib/sessionKeys/buf2hex/buf2hex.d.ts

@@ -0,0 +1 @@
+export declare const buf2hex: (buffer: ArrayBufferLike) => string;

package/src/lib/sessionKeys/buf2hex/buf2hex.js

@@ -0,0 +1,7 @@
+'use client'
+// Converts an ArrayBuffer to a hex-encoded string
+const buf2hex = (buffer) => [...new Uint8Array(buffer)]
+    .map((x) => x.toString(16).padStart(2, '0'))
+    .join('');
+
+export { buf2hex };

package/src/lib/sessionKeys/buf2hex/index.d.ts

@@ -0,0 +1 @@
+export { buf2hex } from './buf2hex';

package/src/lib/sessionKeys/compressRawPublicKey/compressRawPublicKey.d.ts

@@ -0,0 +1 @@
+export declare const compressRawPublicKey: (rawPublicKey: ArrayBuffer) => ArrayBuffer;

package/src/lib/sessionKeys/compressRawPublicKey/compressRawPublicKey.js

@@ -0,0 +1,15 @@
+'use client'
+// Accepts a public key array buffer and returns a buffer with the compressed
+// version of the public key. Drops the y-coordinate and encodes its parity in
+// the first byte.
+const compressRawPublicKey = (rawPublicKey) => {
+    const rawPublicKeyBytes = new Uint8Array(rawPublicKey);
+    const len = rawPublicKeyBytes.byteLength;
+    // Drop the y coordinate
+    const compressedBytes = rawPublicKeyBytes.slice(0, (1 + len) >>> 1);
+    // Encode the parity of `y` in first bit
+    compressedBytes[0] = 0x2 | (rawPublicKeyBytes[len - 1] & 0x01);
+    return compressedBytes.buffer;
+};
+
+export { compressRawPublicKey };

package/src/lib/sessionKeys/compressRawPublicKey/index.d.ts

@@ -0,0 +1 @@
+export { compressRawPublicKey } from './compressRawPublicKey';

package/src/lib/sessionKeys/generateAndSaveSessionKey/generateAndSaveSessionKey.d.ts

@@ -0,0 +1,7 @@
+import { type SessionKey } from '../generateSessionKey';
+/**
+ * Generates a new session key and persists it to storage. The key is *not*
+ * registered with the backend — that happens later when the connector first
+ * needs it.
+ */
+export declare const generateAndSaveSessionKey: () => Promise<SessionKey>;

package/src/lib/sessionKeys/generateAndSaveSessionKey/generateAndSaveSessionKey.js

@@ -0,0 +1,19 @@
+'use client'
+import { __awaiter } from '../../../../_virtual/_tslib.js';
+import { StorageService } from '@dynamic-labs/utils';
+import { SECURE_ENCLAVE_WALLET_SESSION_KEYS, SECURE_ENCLAVE_WALLET_SESSION_KEYS_STORAGE_OPTIONS } from '../../constants.js';
+import { generateSessionKey } from '../generateSessionKey/generateSessionKey.js';
+import { toEncodedFormat } from '../toEncodedFormat/toEncodedFormat.js';
+
+/**
+ * Generates a new session key and persists it to storage. The key is *not*
+ * registered with the backend — that happens later when the connector first
+ * needs it.
+ */
+const generateAndSaveSessionKey = () => __awaiter(void 0, void 0, void 0, function* () {
+    const newSessionKey = yield generateSessionKey();
+    StorageService.setItem(SECURE_ENCLAVE_WALLET_SESSION_KEYS, toEncodedFormat(newSessionKey.publicKey, newSessionKey.privateKey, newSessionKey.privateKeyJwk, newSessionKey.registered), SECURE_ENCLAVE_WALLET_SESSION_KEYS_STORAGE_OPTIONS);
+    return newSessionKey;
+});
+
+export { generateAndSaveSessionKey };

package/src/lib/sessionKeys/generateAndSaveSessionKey/index.d.ts

@@ -0,0 +1 @@
+export { generateAndSaveSessionKey } from './generateAndSaveSessionKey';

package/src/lib/sessionKeys/generateSessionKey/generateSessionKey.d.ts

@@ -0,0 +1,13 @@
+export type SessionKey = {
+    publicKey: string;
+    privateKey: string;
+    privateKeyJwk: JsonWebKey;
+    registered: boolean;
+    expirationDate?: Date;
+};
+/**
+ * Generates a fresh ECDSA P-256 keypair shaped as a {@link SessionKey}.
+ * The key is *not* persisted to storage and is *not* registered with the
+ * backend — callers are responsible for both.
+ */
+export declare const generateSessionKey: () => Promise<SessionKey>;

package/src/lib/sessionKeys/generateSessionKey/generateSessionKey.js

@@ -0,0 +1,20 @@
+'use client'
+import { __awaiter } from '../../../../_virtual/_tslib.js';
+import { p256Keygen } from '../p256Keygen/p256Keygen.js';
+
+/**
+ * Generates a fresh ECDSA P-256 keypair shaped as a {@link SessionKey}.
+ * The key is *not* persisted to storage and is *not* registered with the
+ * backend — callers are responsible for both.
+ */
+const generateSessionKey = () => __awaiter(void 0, void 0, void 0, function* () {
+    const { private: privateKey, public: publicKey, privateJwk, } = yield p256Keygen();
+    return {
+        privateKey,
+        privateKeyJwk: privateJwk,
+        publicKey,
+        registered: false,
+    };
+});
+
+export { generateSessionKey };

package/src/lib/sessionKeys/generateSessionKey/index.d.ts

@@ -0,0 +1 @@
+export { generateSessionKey, type SessionKey } from './generateSessionKey';

package/src/lib/sessionKeys/getDecodedSessionKeys/getDecodedSessionKeys.d.ts

@@ -0,0 +1,2 @@
+import type { SessionKey } from '../generateSessionKey';
+export declare const getDecodedSessionKeys: () => SessionKey | undefined;

package/src/lib/sessionKeys/getDecodedSessionKeys/getDecodedSessionKeys.js

@@ -0,0 +1,28 @@
+'use client'
+import { StorageService } from '@dynamic-labs/utils';
+import { SECURE_ENCLAVE_WALLET_SESSION_KEYS, SECURE_ENCLAVE_WALLET_SESSION_KEYS_STORAGE_OPTIONS } from '../../constants.js';
+
+const isSessionKey = (value) => {
+    if (!value || typeof value !== 'object')
+        return false;
+    const candidate = value;
+    return (typeof candidate.privateKey === 'string' &&
+        typeof candidate.publicKey === 'string' &&
+        typeof candidate.registered === 'boolean' &&
+        typeof candidate.privateKeyJwk === 'object' &&
+        candidate.privateKeyJwk !== null);
+};
+const getDecodedSessionKeys = () => {
+    const sessionKeysSS = StorageService.getItem(SECURE_ENCLAVE_WALLET_SESSION_KEYS, SECURE_ENCLAVE_WALLET_SESSION_KEYS_STORAGE_OPTIONS);
+    if (!sessionKeysSS)
+        return undefined;
+    try {
+        const parsed = JSON.parse(Buffer.from(sessionKeysSS, 'base64').toString());
+        return isSessionKey(parsed) ? parsed : undefined;
+    }
+    catch (_a) {
+        return undefined;
+    }
+};
+
+export { getDecodedSessionKeys };

package/src/lib/sessionKeys/getDecodedSessionKeys/index.d.ts

@@ -0,0 +1 @@
+export { getDecodedSessionKeys } from './getDecodedSessionKeys';

package/src/lib/sessionKeys/getSessionNonceHeaders/getSessionNonceHeaders.d.ts

@@ -0,0 +1,6 @@
+export type SessionNonceHeaders = {
+    nonce: string;
+    nonceSignature: string;
+    publicKey: string;
+};
+export declare const getSessionNonceHeaders: () => Promise<SessionNonceHeaders>;

package/src/lib/sessionKeys/getSessionNonceHeaders/getSessionNonceHeaders.js

@@ -0,0 +1,19 @@
+'use client'
+import { __awaiter } from '../../../../_virtual/_tslib.js';
+import { getDefaultClient, getSignedSessionId, getSessionKeys } from '@dynamic-labs-sdk/client/core';
+
+const getSessionNonceHeaders = () => __awaiter(void 0, void 0, void 0, function* () {
+    var _a, _b;
+    const client = getDefaultClient();
+    const { signature } = yield getSignedSessionId(client);
+    // signature format: "${signedSessionId}/${nonceSignature}/${nonce}"
+    const parts = signature.split('/');
+    if (parts.length < 3) {
+        throw new Error(`Unexpected session chaining signature format: expected 3 parts, got ${parts.length}`);
+    }
+    const [, nonceSignature, nonce] = parts;
+    const publicKey = (_b = (_a = getSessionKeys(client)) === null || _a === void 0 ? void 0 : _a.publicKey) !== null && _b !== void 0 ? _b : '';
+    return { nonce, nonceSignature, publicKey };
+});
+
+export { getSessionNonceHeaders };

package/src/lib/sessionKeys/getSessionNonceHeaders/index.d.ts

@@ -0,0 +1 @@
+export { getSessionNonceHeaders, type SessionNonceHeaders, } from './getSessionNonceHeaders';

package/src/lib/sessionKeys/p256Keygen/index.d.ts

@@ -0,0 +1 @@
+export { p256Keygen, type P256KeyPair } from './p256Keygen';

package/src/lib/sessionKeys/p256Keygen/p256Keygen.d.ts

@@ -0,0 +1,11 @@
+export type P256KeyPair = {
+    /** Hex-encoded raw private key — format used by the Turnkey API key stamper. */
+    private: string;
+    /** JWK private key — format required for signing chaining signatures. */
+    privateJwk: JsonWebKey;
+    /** Hex-encoded compressed public key. */
+    public: string;
+    /** Hex-encoded uncompressed public key. */
+    publicUncompressed: string;
+};
+export declare const p256Keygen: () => Promise<P256KeyPair>;

package/src/lib/sessionKeys/p256Keygen/p256Keygen.js

@@ -0,0 +1,26 @@
+'use client'
+import { __awaiter } from '../../../../_virtual/_tslib.js';
+import { base64urlDecode } from '../base64urlDecode/base64urlDecode.js';
+import { buf2hex } from '../buf2hex/buf2hex.js';
+import { compressRawPublicKey } from '../compressRawPublicKey/compressRawPublicKey.js';
+
+const p256Keygen = () => __awaiter(void 0, void 0, void 0, function* () {
+    const p256Keypair = yield crypto.subtle.generateKey({
+        name: 'ECDSA',
+        namedCurve: 'P-256',
+    }, true, ['sign', 'verify']);
+    // Export the raw public key (uncompressed)
+    const rawPublicKey = yield crypto.subtle.exportKey('raw', p256Keypair.publicKey);
+    // Export private as JWK (raw export of EC private keys isn't supported)
+    const privateKeyJwk = yield crypto.subtle.exportKey('jwk', p256Keypair.privateKey);
+    const compressedPublicKeyBuffer = compressRawPublicKey(rawPublicKey);
+    const privateKeyBuffer = base64urlDecode(privateKeyJwk.d);
+    return {
+        private: buf2hex(privateKeyBuffer.buffer),
+        privateJwk: privateKeyJwk,
+        public: buf2hex(compressedPublicKeyBuffer),
+        publicUncompressed: buf2hex(rawPublicKey),
+    };
+});
+
+export { p256Keygen };

package/src/lib/sessionKeys/p256Sign/index.d.ts

@@ -0,0 +1 @@
+export { p256Sign } from './p256Sign';

package/src/lib/sessionKeys/p256Sign/p256Sign.d.ts

@@ -0,0 +1 @@
+export declare const p256Sign: (privateKeyJwk: JsonWebKey, message: string) => Promise<string>;

package/src/lib/sessionKeys/p256Sign/p256Sign.js

@@ -0,0 +1,17 @@
+'use client'
+import { __awaiter } from '../../../../_virtual/_tslib.js';
+import { buf2hex } from '../buf2hex/buf2hex.js';
+
+const p256Sign = (privateKeyJwk, message) => __awaiter(void 0, void 0, void 0, function* () {
+    const privateKey = yield crypto.subtle.importKey('jwk', privateKeyJwk, {
+        name: 'ECDSA',
+        namedCurve: 'P-256',
+    }, false, ['sign']);
+    const signature = yield crypto.subtle.sign({
+        hash: 'SHA-256',
+        name: 'ECDSA',
+    }, privateKey, new TextEncoder().encode(message));
+    return buf2hex(signature);
+});
+
+export { p256Sign };

package/src/lib/sessionKeys/registerSessionKey/index.d.ts

@@ -0,0 +1 @@
+export { registerSessionKey } from './registerSessionKey';

package/src/lib/sessionKeys/registerSessionKey/registerSessionKey.d.ts

@@ -0,0 +1,8 @@
+import { RegisterEmbeddedWalletSessionKeyResponse } from '@dynamic-labs/sdk-api-core';
+type RegisterSessionKeyProps = {
+    prevSessionKeySignature?: string;
+    publicKey: string;
+    walletId: string;
+};
+export declare const registerSessionKey: ({ prevSessionKeySignature, publicKey, walletId, }: RegisterSessionKeyProps) => Promise<RegisterEmbeddedWalletSessionKeyResponse>;
+export {};

package/src/lib/sessionKeys/registerSessionKey/registerSessionKey.js

@@ -0,0 +1,42 @@
+'use client'
+import { __awaiter } from '../../../../_virtual/_tslib.js';
+import { getDefaultClient, getCore, createApiClient, APIError } from '@dynamic-labs-sdk/client/core';
+import { UnprocessableEntityErrorCode } from '@dynamic-labs/sdk-api-core';
+import { InvalidEmbeddedWalletSessionKeyError } from '@dynamic-labs/utils';
+import { getSessionNonceHeaders } from '../getSessionNonceHeaders/getSessionNonceHeaders.js';
+
+const SESSION_PUBLIC_KEY_HEADER = 'x-dyn-session-public-key';
+const SESSION_NONCE_HEADER = 'x-dyn-session-nonce';
+const SESSION_NONCE_SIGNATURE_HEADER = 'x-dyn-session-nonce-signature';
+const registerSessionKey = (_a) => __awaiter(void 0, [_a], void 0, function* ({ prevSessionKeySignature, publicKey, walletId, }) {
+    const client = getDefaultClient();
+    const core = getCore(client);
+    try {
+        const { nonce, nonceSignature, publicKey: sessionPublicKey, } = yield getSessionNonceHeaders();
+        const apiClient = createApiClient({
+            headers: {
+                [SESSION_NONCE_HEADER]: nonce,
+                [SESSION_NONCE_SIGNATURE_HEADER]: nonceSignature,
+                [SESSION_PUBLIC_KEY_HEADER]: sessionPublicKey,
+            },
+        }, client);
+        return yield apiClient.registerSessionKey({
+            environmentId: core.environmentId,
+            registerSessionKeyRequest: {
+                prevSessionKeySignature,
+                publicKey,
+                walletId,
+            },
+        });
+    }
+    catch (error) {
+        if (error instanceof APIError &&
+            error.status === 422 &&
+            error.code === UnprocessableEntityErrorCode.InvalidSessionPublicKey) {
+            throw new InvalidEmbeddedWalletSessionKeyError(error.message);
+        }
+        throw error;
+    }
+});
+
+export { registerSessionKey };

package/src/lib/sessionKeys/removeSessionKey/index.d.ts

@@ -0,0 +1 @@
+export { removeSessionKey } from './removeSessionKey';

package/src/lib/sessionKeys/removeSessionKey/removeSessionKey.d.ts

@@ -0,0 +1 @@
+export declare const removeSessionKey: () => void;

package/src/lib/sessionKeys/removeSessionKey/removeSessionKey.js

@@ -0,0 +1,9 @@
+'use client'
+import { StorageService } from '@dynamic-labs/utils';
+import { SECURE_ENCLAVE_WALLET_SESSION_KEYS, SECURE_ENCLAVE_WALLET_SESSION_KEYS_STORAGE_OPTIONS } from '../../constants.js';
+
+const removeSessionKey = () => {
+    StorageService.removeItem(SECURE_ENCLAVE_WALLET_SESSION_KEYS, SECURE_ENCLAVE_WALLET_SESSION_KEYS_STORAGE_OPTIONS);
+};
+
+export { removeSessionKey };

package/src/lib/sessionKeys/toEncodedFormat/index.d.ts

@@ -0,0 +1 @@
+export { toEncodedFormat } from './toEncodedFormat';

package/src/lib/sessionKeys/toEncodedFormat/toEncodedFormat.d.ts

@@ -0,0 +1 @@
+export declare const toEncodedFormat: (publicKey: string, privateKey: string, privateKeyJwk: JsonWebKey, registered: boolean, expirationDate?: Date) => string;

package/src/lib/sessionKeys/toEncodedFormat/toEncodedFormat.js

@@ -0,0 +1,15 @@
+'use client'
+// Encodes a session-key tuple as a base64-encoded JSON string for storage.
+const toEncodedFormat = (publicKey, privateKey, privateKeyJwk, registered, expirationDate) => {
+    const sessionKeys = {
+        expirationDate,
+        privateKey,
+        privateKeyJwk,
+        publicKey,
+        registered,
+    };
+    const sessionKeysString = JSON.stringify(sessionKeys);
+    return Buffer.from(sessionKeysString).toString('base64');
+};
+
+export { toEncodedFormat };

package/src/lib/sessionKeys/useRegisterEmbeddedWalletSessionKey/index.d.ts

@@ -0,0 +1 @@
+export { useRegisterEmbeddedWalletSessionKey, type RegisterEmbeddedWalletSessionKeyArgs, type RegisterEmbeddedWalletSessionKeyResult, } from './useRegisterEmbeddedWalletSessionKey';

package/src/lib/sessionKeys/useRegisterEmbeddedWalletSessionKey/useRegisterEmbeddedWalletSessionKey.d.ts

@@ -0,0 +1,11 @@
+import { type SessionKey } from '../generateSessionKey';
+export type RegisterEmbeddedWalletSessionKeyArgs = {
+    ignoreRestore?: boolean;
+    walletId: string;
+};
+export type RegisterEmbeddedWalletSessionKeyResult = {
+    expirationDate: Date;
+    privateKey: string;
+    publicKey: string;
+};
+export declare const useRegisterEmbeddedWalletSessionKey: () => ({ ignoreRestore, walletId, }: RegisterEmbeddedWalletSessionKeyArgs) => Promise<SessionKey | RegisterEmbeddedWalletSessionKeyResult>;