@dynamic-labs/embedded-wallet 0.0.0-exp20240808.0

package/src/lib/ExportHandler/ExportHandler.js

@@ -0,0 +1,150 @@
+'use client'
+import { __awaiter } from '../../../_virtual/_tslib.js';
+import { IframeStamper, KeyFormat } from '@turnkey/iframe-stamper';
+import { TurnkeyClient } from '@turnkey/http';
+import { getTLD, PlatformService, DynamicError } from '@dynamic-labs/utils';
+import { turnkeyAuthenticatorRecoveryHandler } from '../AuthenticatorHandler/TurnkeyAuthenticatorRecoveryHandler.js';
+import { PasskeyService } from '../utils/PasskeyService/PasskeyService.js';
+import '../utils/convertAttestationTransports/convertAttestationTransports.js';
+import { logger } from '../utils/logger/logger.js';
+
+const turnkeyBaseUrl = 'https://api.turnkey.com';
+const turnkeyExportUrl = 'https://export.turnkey.com';
+class ExportHandler {
+    get publicKey() {
+        return this.__publicKey;
+    }
+    clear() {
+        var _a;
+        (_a = this.__iframeStamper) === null || _a === void 0 ? void 0 : _a.clear();
+        this.__iframeStamper = undefined;
+        this.__publicKey = undefined;
+        this.__turnkeyClient = undefined;
+    }
+    initExport(iframeContainer, iframeElementId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.__iframeStamper = new IframeStamper({
+                iframeContainer,
+                iframeElementId,
+                iframeUrl: turnkeyExportUrl,
+            });
+            yield this.__iframeStamper.init();
+            this.__publicKey = this.__iframeStamper.publicKey();
+            if (turnkeyAuthenticatorRecoveryHandler.isSessionActive()) {
+                this.__turnkeyClient = turnkeyAuthenticatorRecoveryHandler.client;
+            }
+            else {
+                let rpId = getTLD();
+                if (!rpId) {
+                    rpId = PlatformService.getHostname();
+                }
+                const passkeyStamper = PasskeyService.createWebauthnStamper({
+                    rpId,
+                });
+                const apiKeyStamper = ExportHandler === null || ExportHandler === void 0 ? void 0 : ExportHandler.apiKeyStamper;
+                const stamper = apiKeyStamper !== null && apiKeyStamper !== void 0 ? apiKeyStamper : passkeyStamper;
+                this.__turnkeyClient = new TurnkeyClient({
+                    baseUrl: turnkeyBaseUrl,
+                }, stamper);
+            }
+            return this.__publicKey;
+        });
+    }
+    verifyExportWallet(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ exportBundle, organizationId, }) {
+            if (!this.__iframeStamper) {
+                throw new DynamicError('Cannot proceed with your request');
+            }
+            try {
+                return yield this.__iframeStamper.injectWalletExportBundle(exportBundle, organizationId);
+            }
+            catch (err) {
+                logger.error('Error while verifying export wallet', err);
+                throw err;
+            }
+        });
+    }
+    verifyExportPrivateKey(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ exportBundle, organizationId, chain, }) {
+            if (!this.__iframeStamper) {
+                throw new DynamicError('Cannot proceed with your request');
+            }
+            try {
+                return yield this.__iframeStamper.injectKeyExportBundle(exportBundle, organizationId, chain === 'solana' ? KeyFormat.Solana : KeyFormat.Hexadecimal);
+            }
+            catch (err) {
+                logger.error('Error while verifying export private key', err);
+                throw err;
+            }
+        });
+    }
+    exportPrivateKey(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ privateKeyId, organizationId, }) {
+            const apiKeyStamper = ExportHandler === null || ExportHandler === void 0 ? void 0 : ExportHandler.apiKeyStamper;
+            if (apiKeyStamper) {
+                this.__turnkeyClient = new TurnkeyClient({
+                    baseUrl: turnkeyBaseUrl,
+                }, apiKeyStamper);
+            }
+            if (!this.__iframeStamper ||
+                !this.__publicKey ||
+                !this.__turnkeyClient ||
+                !privateKeyId) {
+                throw new DynamicError('Cannot proceed with your request');
+            }
+            try {
+                const newActivity = yield this.__turnkeyClient.exportPrivateKey({
+                    organizationId,
+                    parameters: { privateKeyId, targetPublicKey: this.__publicKey },
+                    timestampMs: String(Date.now()),
+                    type: 'ACTIVITY_TYPE_EXPORT_PRIVATE_KEY',
+                });
+                return newActivity.activity;
+            }
+            catch (err) {
+                logger.error('[TK] Error while completing export private key process', err);
+                throw err;
+            }
+        });
+    }
+    exportWallet(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ walletId, organizationId, address, }) {
+            const apiKeyStamper = ExportHandler === null || ExportHandler === void 0 ? void 0 : ExportHandler.apiKeyStamper;
+            if (apiKeyStamper) {
+                this.__turnkeyClient = new TurnkeyClient({
+                    baseUrl: turnkeyBaseUrl,
+                }, apiKeyStamper);
+            }
+            if (!this.__iframeStamper ||
+                !this.__publicKey ||
+                !this.__turnkeyClient ||
+                !walletId) {
+                throw new DynamicError('Cannot proceed with your request');
+            }
+            try {
+                if (address) {
+                    const newActivity = yield this.__turnkeyClient.exportWalletAccount({
+                        organizationId,
+                        parameters: { address, targetPublicKey: this.__publicKey },
+                        timestampMs: String(Date.now()),
+                        type: 'ACTIVITY_TYPE_EXPORT_WALLET_ACCOUNT',
+                    });
+                    return newActivity.activity;
+                }
+                const newActivity = yield this.__turnkeyClient.exportWallet({
+                    organizationId,
+                    parameters: { targetPublicKey: this.__publicKey, walletId },
+                    timestampMs: String(Date.now()),
+                    type: 'ACTIVITY_TYPE_EXPORT_WALLET',
+                });
+                return newActivity.activity;
+            }
+            catch (err) {
+                logger.error('[TK] Error while completing export wallet process', err);
+                throw err;
+            }
+        });
+    }
+}
+
+export { ExportHandler };

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

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

package/src/lib/TurnkeyWalletConnectorBase/TurnkeyWalletConnectorBase.cjs

@@ -0,0 +1,238 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('../../../_virtual/_tslib.cjs');
+var apiKeyStamper = require('@turnkey/api-key-stamper');
+var walletConnectorCore = require('@dynamic-labs/wallet-connector-core');
+var utils = require('@dynamic-labs/utils');
+var base64UrlEncode = require('../utils/base64UrlEncode/base64UrlEncode.cjs');
+var generateRandomBuffer = require('../utils/generateRandomBuffer/generateRandomBuffer.cjs');
+var convertAttestationTransports = require('../utils/convertAttestationTransports/convertAttestationTransports.cjs');
+var logger = require('../utils/logger/logger.cjs');
+var TurnkeyAuthenticatorRecoveryHandler = require('../AuthenticatorHandler/TurnkeyAuthenticatorRecoveryHandler.cjs');
+var ExportHandler = require('../ExportHandler/ExportHandler.cjs');
+var PasskeyService = require('../utils/PasskeyService/PasskeyService.cjs');
+
+class TurnkeyWalletConnectorBase extends walletConnectorCore.WalletConnectorBase {
+    constructor(nameAndKey, props) {
+        super(props);
+        // Public fields
+        this.requiresNonDynamicEmailOtp = false;
+        this.isEmbeddedWallet = true;
+        this.removeSessionKeys = () => _tslib.__awaiter(this, void 0, void 0, function* () {
+            TurnkeyWalletConnectorBase.sessionKeys = undefined;
+            TurnkeyWalletConnectorBase.apiKeyStamper = undefined;
+            ExportHandler.ExportHandler.apiKeyStamper = undefined;
+            if (typeof (this === null || this === void 0 ? void 0 : this.removeSessionKeysFunction) === 'function') {
+                this.removeSessionKeysFunction();
+            }
+        });
+        if (!props.appName) {
+            throw new Error('appName not set');
+        }
+        this.name = nameAndKey.name;
+        this.overrideKey = nameAndKey.key;
+        this.appName = props.appName;
+        this.__authenticatorMethodHandler = TurnkeyAuthenticatorRecoveryHandler.turnkeyAuthenticatorRecoveryHandler;
+        this.__exportHandler = new ExportHandler.ExportHandler();
+    }
+    getWebAuthnAttestation() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            const challenge = generateRandomBuffer.generateRandomBuffer();
+            const authenticatorUserId = generateRandomBuffer.generateRandomBuffer();
+            const { email, passkeyIdentifier } = this;
+            if (!email && !passkeyIdentifier) {
+                throw new Error('Email or passkeyIdentifier must be set to register a webauthn credential.');
+            }
+            const displayName = email || `${this.appName} - ${passkeyIdentifier}`;
+            const webAuthnCreateParams = {
+                publicKey: {
+                    authenticatorSelection: {
+                        authenticatorAttachment: undefined,
+                        requireResidentKey: false,
+                        residentKey: 'preferred',
+                        userVerification: 'discouraged',
+                    },
+                    challenge,
+                    pubKeyCredParams: [
+                        {
+                            alg: -7,
+                            type: 'public-key',
+                        },
+                    ],
+                    rp: {
+                        id: utils.getTLD(),
+                        name: this.appName,
+                    },
+                    user: {
+                        displayName,
+                        id: authenticatorUserId,
+                        name: email || `${this.appName} - ${passkeyIdentifier}`,
+                    },
+                },
+            };
+            let attestation;
+            try {
+                attestation = yield PasskeyService.PasskeyService.getWebAuthnAttestation(webAuthnCreateParams);
+            }
+            catch (error) {
+                logger.logger.warn(`Unable to register webauthn credential on the current page's TLD ${utils.getTLD()}. Falling back to using hostname. ${utils.PlatformService.getHostname()}`, error);
+                // Create the passkey on the hostname instead.
+                webAuthnCreateParams.publicKey.rp.id = utils.PlatformService.getHostname();
+                attestation = yield PasskeyService.PasskeyService.getWebAuthnAttestation(webAuthnCreateParams);
+            }
+            return {
+                attestation: {
+                    attestationObject: attestation.attestationObject,
+                    clientDataJson: attestation.clientDataJson,
+                    credentialId: attestation.credentialId,
+                    transports: convertAttestationTransports.convertAttestationTransports(attestation.transports),
+                },
+                challenge: base64UrlEncode.base64UrlEncode(challenge),
+                displayName,
+            };
+        });
+    }
+    getAuthenticatorHandler() {
+        return this.__authenticatorMethodHandler;
+    }
+    getExportHandler() {
+        return this.__exportHandler;
+    }
+    // Public methods
+    get email() {
+        return this._email;
+    }
+    setEmail(email) {
+        this._email = email;
+    }
+    get phone() {
+        return this._phone;
+    }
+    setPhone(phone) {
+        this._phone = phone;
+    }
+    get passkeyIdentifier() {
+        return this._passkeyIdentifier;
+    }
+    setPasskeyIdentifier(passkeyIdentifier) {
+        this._passkeyIdentifier = passkeyIdentifier;
+    }
+    clearEmail() {
+        this._email = null;
+    }
+    getAddress() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            var _a;
+            return (_a = this.verifiedCredential) === null || _a === void 0 ? void 0 : _a.address;
+        });
+    }
+    getConnectedAccounts() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const address = (_a = this.verifiedCredential) === null || _a === void 0 ? void 0 : _a.address;
+            if (!address) {
+                return [];
+            }
+            return [address];
+        });
+    }
+    getMobileOrInstalledWallet() {
+        return this;
+    }
+    get turnkeyAddress() {
+        var _a;
+        const { address } = (_a = this.verifiedCredential) !== null && _a !== void 0 ? _a : {};
+        return address;
+    }
+    get walletProperties() {
+        const { walletProperties } = this.verifiedCredential || {};
+        return walletProperties;
+    }
+    // Private methods
+    set verifiedCredential(verifiedCredential) {
+        this._verifiedCredential = verifiedCredential;
+    }
+    get verifiedCredential() {
+        return this._verifiedCredential;
+    }
+    setSessionKeyFetcher(func) {
+        this.createOrRestoreSessionFetcherFunction = func;
+    }
+    setSessionKeyRemoveFunction(func) {
+        this.removeSessionKeysFunction = func;
+    }
+    createOrRestoreSession() {
+        return _tslib.__awaiter(this, arguments, void 0, function* ({ ignoreRestore, } = {}) {
+            var _a;
+            if (!this.isSessionKeyCompatible() ||
+                TurnkeyWalletConnectorBase.isLoadingSession) {
+                return;
+            }
+            if (!this.createOrRestoreSessionFetcherFunction) {
+                throw new utils.DynamicError('Cannot register session key to init provider');
+            }
+            if ((_a = TurnkeyWalletConnectorBase.sessionKeys) === null || _a === void 0 ? void 0 : _a.publicKey) {
+                return TurnkeyWalletConnectorBase.sessionKeys.publicKey;
+            }
+            try {
+                TurnkeyWalletConnectorBase.isLoadingSession = true;
+                const sessionKeys = yield this.createOrRestoreSessionFetcherFunction({
+                    ignoreRestore,
+                });
+                TurnkeyWalletConnectorBase.sessionKeys = sessionKeys;
+                TurnkeyWalletConnectorBase.apiKeyStamper = new apiKeyStamper.ApiKeyStamper({
+                    apiPrivateKey: sessionKeys.privateKey,
+                    apiPublicKey: sessionKeys.publicKey,
+                });
+                ExportHandler.ExportHandler.apiKeyStamper = TurnkeyWalletConnectorBase.apiKeyStamper;
+                logger.logger.setMetaData('sessionApiPublicKey', sessionKeys.publicKey);
+                return sessionKeys.publicKey;
+            }
+            catch (error) {
+                throw new utils.DynamicError('Failed to create or restore session');
+            }
+            finally {
+                TurnkeyWalletConnectorBase.isLoadingSession = false;
+            }
+        });
+    }
+    isSessionKeyCompatible() {
+        var _a;
+        const walletProperties = (_a = this.verifiedCredential) === null || _a === void 0 ? void 0 : _a.walletProperties;
+        const isSessionKeyCompatible = walletProperties === null || walletProperties === void 0 ? void 0 : walletProperties.isSessionKeyCompatible;
+        return Boolean(isSessionKeyCompatible);
+    }
+    isSessionActive() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            const hasWallet = yield this.getAddress();
+            return Boolean(hasWallet &&
+                TurnkeyWalletConnectorBase.sessionKeys &&
+                TurnkeyWalletConnectorBase.apiKeyStamper);
+        });
+    }
+    get sessionKeys() {
+        return TurnkeyWalletConnectorBase.sessionKeys;
+    }
+    setLoggerMetadata() {
+        var _a, _b, _c;
+        logger.logger.setMetaData('turnkeySubOrganizationId', (_b = (_a = this._verifiedCredential) === null || _a === void 0 ? void 0 : _a.walletProperties) === null || _b === void 0 ? void 0 : _b.turnkeySubOrganizationId);
+        logger.logger.setMetaData('walletId', (_c = this._verifiedCredential) === null || _c === void 0 ? void 0 : _c.id);
+        let authMethod = 'Unknown';
+        if (this.isSessionKeyCompatible()) {
+            authMethod = 'SessionKeys';
+        }
+        else if (this.__authenticatorMethodHandler.recoveryType === 'passkey') {
+            authMethod = 'Passkey';
+        }
+        else if (this.__authenticatorMethodHandler.recoveryType === 'email') {
+            authMethod = 'EmailAuth';
+        }
+        logger.logger.setMetaData('authMethod', authMethod);
+    }
+}
+TurnkeyWalletConnectorBase.isLoadingSession = false;
+
+exports.TurnkeyWalletConnectorBase = TurnkeyWalletConnectorBase;

package/src/lib/TurnkeyWalletConnectorBase/TurnkeyWalletConnectorBase.d.ts

@@ -0,0 +1,73 @@
+import { ApiKeyStamper } from '@turnkey/api-key-stamper';
+import { JwtVerifiedCredential, TurnkeyWalletProperties } from '@dynamic-labs/sdk-api-core';
+import { WalletBookSchema } from '@dynamic-labs/wallet-book';
+import { WalletConnectorBase } from '@dynamic-labs/wallet-connector-core';
+import type { AuthenticatorRecoveryHandler, IEmailWalletConnector, IPasskeyWalletConnector, ISMSWalletConnector, WalletConnector } from '@dynamic-labs/wallet-connector-core';
+import { TurnkeyWalletConnectorNameAndKey } from '../../types';
+import { ExportHandler } from '../ExportHandler';
+export type TurnkeyConnectorBaseProps = {
+    walletBook: WalletBookSchema;
+    appName?: string;
+};
+export type SessionKeys = {
+    publicKey: string;
+    privateKey: string;
+};
+type ITurnkeyWalletConnector = IEmailWalletConnector & IPasskeyWalletConnector & ISMSWalletConnector;
+export declare abstract class TurnkeyWalletConnectorBase extends WalletConnectorBase implements ITurnkeyWalletConnector {
+    requiresNonDynamicEmailOtp: boolean;
+    name: string;
+    isEmbeddedWallet: boolean;
+    static isLoadingSession: boolean;
+    private appName;
+    private _email;
+    private _phone;
+    private _passkeyIdentifier;
+    private _verifiedCredential;
+    private __authenticatorMethodHandler;
+    private __exportHandler;
+    static sessionKeys: SessionKeys | undefined;
+    static apiKeyStamper: ApiKeyStamper | undefined;
+    createOrRestoreSessionFetcherFunction: (({ ignoreRestore }: {
+        ignoreRestore?: boolean;
+    }) => Promise<SessionKeys>) | undefined;
+    removeSessionKeysFunction: (() => Promise<void>) | undefined;
+    constructor(nameAndKey: TurnkeyWalletConnectorNameAndKey, props: TurnkeyConnectorBaseProps);
+    getWebAuthnAttestation(): Promise<{
+        attestation: {
+            attestationObject: string;
+            clientDataJson: string;
+            credentialId: string;
+            transports: import("@dynamic-labs/sdk-api-core").AuthenticatorTransportProtocol[];
+        };
+        challenge: string;
+        displayName: string;
+    }>;
+    getAuthenticatorHandler(): AuthenticatorRecoveryHandler;
+    getExportHandler(): ExportHandler;
+    get email(): string | null | undefined;
+    setEmail(email: string | null | undefined): void;
+    get phone(): string | null | undefined;
+    setPhone(phone: string | null | undefined): void;
+    get passkeyIdentifier(): string | null | undefined;
+    setPasskeyIdentifier(passkeyIdentifier: string | null | undefined): void;
+    clearEmail(): void;
+    getAddress(): Promise<string | undefined>;
+    getConnectedAccounts(): Promise<string[]>;
+    getMobileOrInstalledWallet(): WalletConnector;
+    get turnkeyAddress(): string | undefined;
+    get walletProperties(): TurnkeyWalletProperties | undefined;
+    set verifiedCredential(verifiedCredential: JwtVerifiedCredential | undefined);
+    get verifiedCredential(): JwtVerifiedCredential | undefined;
+    setSessionKeyFetcher(func: () => Promise<SessionKeys>): void;
+    setSessionKeyRemoveFunction(func: () => Promise<void>): void;
+    removeSessionKeys: () => Promise<void>;
+    createOrRestoreSession({ ignoreRestore, }?: {
+        ignoreRestore?: boolean;
+    }): Promise<string | undefined>;
+    isSessionKeyCompatible(): boolean;
+    isSessionActive(): Promise<boolean>;
+    get sessionKeys(): SessionKeys | undefined;
+    protected setLoggerMetadata(): void;
+}
+export {};