@dynamic-labs/sdk-react-core 2.0.0-alpha.31 → 2.0.0-alpha.32

package/src/lib/data/api/api.cjs

@@ -0,0 +1,24 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var sdkApiCore = require('@dynamic-labs/sdk-api-core');
+var version = require('../../../version.cjs');
+var ApiEndpoint = require('../../config/ApiEndpoint.cjs');
+
+const sdkApi = (jwt) => {
+    const settings = {
+        basePath: ApiEndpoint.getBaseUrl(),
+        headers: {
+            'Content-Type': 'application/json',
+        },
+    };
+    if (jwt) {
+        settings.headers.Authorization = `Bearer ${jwt}`;
+    }
+    settings.headers['x-dyn-version'] = `WalletKit/${version.VERSION}`;
+    settings.headers['x-dyn-api-version'] = `API/${version.API_VERSION}`;
+    return new sdkApiCore.SDKApi(new sdkApiCore.Configuration(settings));
+};
+
+exports.sdkApi = sdkApi;

package/src/lib/data/api/api.d.ts

@@ -0,0 +1,2 @@
+import { SDKApi } from '@dynamic-labs/sdk-api-core';
+export declare const sdkApi: (jwt?: string) => SDKApi;

package/src/lib/data/api/api.js

@@ -0,0 +1,20 @@
+import { SDKApi, Configuration } from '@dynamic-labs/sdk-api-core';
+import { VERSION, API_VERSION } from '../../../version.js';
+import ApiEndpoint from '../../config/ApiEndpoint.js';
+
+const sdkApi = (jwt) => {
+    const settings = {
+        basePath: ApiEndpoint.getBaseUrl(),
+        headers: {
+            'Content-Type': 'application/json',
+        },
+    };
+    if (jwt) {
+        settings.headers.Authorization = `Bearer ${jwt}`;
+    }
+    settings.headers['x-dyn-version'] = `WalletKit/${VERSION}`;
+    settings.headers['x-dyn-api-version'] = `API/${API_VERSION}`;
+    return new SDKApi(new Configuration(settings));
+};
+
+export { sdkApi };

package/src/lib/data/api/email/email.cjs

@@ -0,0 +1,118 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('../../../../../_virtual/_tslib.cjs');
+var utils = require('@dynamic-labs/utils');
+var sdkApiCore = require('@dynamic-labs/sdk-api-core');
+var logger = require('../../../shared/logger.cjs');
+require('@dynamic-labs/iconic');
+require('@dynamic-labs/wallet-connector-core');
+require('react/jsx-runtime');
+require('../../../context/ViewContext/ViewContext.cjs');
+require('react');
+require('@dynamic-labs/wallet-book');
+require('../../../utils/constants/colors.cjs');
+require('../../../utils/constants/values.cjs');
+require('../../../shared/utils/classes/storage/localStorage.cjs');
+require('../../../shared/consts/index.cjs');
+var api = require('../api.cjs');
+
+const getEmailProvider = ({ email, environmentId, }) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const res = yield api.sdkApi().getEmailProvider({
+            email,
+            environmentId,
+        });
+        return res;
+    }
+    catch (e) {
+        const data = yield e.json();
+        logger.logger.error(data.error);
+        throw new utils.EmailProviderError(data.code);
+    }
+});
+const createEmailVerification = ({ email, environmentId, captchaToken, }) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const res = yield api.sdkApi().createEmailVerification({
+            emailVerificationCreateRequest: {
+                captchaToken,
+                email,
+            },
+            environmentId,
+        });
+        return res;
+    }
+    catch (e) {
+        const data = yield e.json();
+        logger.logger.error(data.error);
+        throw new utils.EmailVerificationError(data.code);
+    }
+});
+const signInWithEmailVerification = ({ verificationToken, verificationUUID, environmentId, captchaToken, }) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const res = yield api.sdkApi().signInWithEmailVerification({
+            emailVerificationVerifyRequest: {
+                captchaToken,
+                verificationToken,
+                verificationUUID,
+            },
+            environmentId,
+        });
+        return res;
+    }
+    catch (e) {
+        const data = yield e.json();
+        logger.logger.error(data.error);
+        if (data.error.code === 'missing_from_list') {
+            throw new utils.NoAccessError({ email: data.payload.email });
+        }
+        if (data.code === 'email_associated_with_different_provider') {
+            throw new utils.AccountExistsError(data.error, data.payload);
+        }
+        throw new utils.EmailVerificationError(data.code);
+    }
+});
+const retryEmailVerification = ({ email, environmentId, verificationUUID, }) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const res = yield api.sdkApi().retryEmailVerification({
+            emailVerificationRetryRequest: {
+                email,
+                verificationUUID,
+            },
+            environmentId,
+        });
+        return res;
+    }
+    catch (e) {
+        const data = yield e.json();
+        logger.logger.error(data.error);
+        throw new utils.EmailVerificationError(data.code);
+    }
+});
+const verifyEmail = ({ verificationToken, verificationUUID, environmentId, }, userJwt) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const res = yield api.sdkApi(userJwt).verifyEmailVerification({
+            emailVerificationVerifyRequest: {
+                verificationToken,
+                verificationUUID,
+            },
+            environmentId,
+        });
+        return res;
+    }
+    catch (e) {
+        const data = yield e.json();
+        logger.logger.error(data.error);
+        if (data.code === sdkApiCore.UnprocessableEntityErrorCode.UserHasAlreadyAccountWithEmail) {
+            throw new utils.UserHasAccountWithEmailError(data.error);
+        }
+        throw new utils.EmailVerificationError(data.code);
+    }
+});
+
+exports.createEmailVerification = createEmailVerification;
+exports.getEmailProvider = getEmailProvider;
+exports.retryEmailVerification = retryEmailVerification;
+exports.signInWithEmailVerification = signInWithEmailVerification;
+exports.verifyEmail = verifyEmail;

package/src/lib/data/api/email/email.d.ts

@@ -0,0 +1,26 @@
+import { UpdateSelfResponse, EmailVerificationCreateResponse, VerifyResponse, EmailProviderResponse } from '@dynamic-labs/sdk-api-core';
+export declare const getEmailProvider: ({ email, environmentId, }: {
+    email: string;
+    environmentId: string;
+}) => Promise<EmailProviderResponse>;
+export declare const createEmailVerification: ({ email, environmentId, captchaToken, }: {
+    email: string;
+    environmentId: string;
+    captchaToken?: string | undefined;
+}) => Promise<EmailVerificationCreateResponse>;
+export declare const signInWithEmailVerification: ({ verificationToken, verificationUUID, environmentId, captchaToken, }: {
+    environmentId: string;
+    verificationToken: string;
+    verificationUUID: string;
+    captchaToken?: string | undefined;
+}) => Promise<VerifyResponse>;
+export declare const retryEmailVerification: ({ email, environmentId, verificationUUID, }: {
+    email: string;
+    environmentId: string;
+    verificationUUID: string;
+}) => Promise<EmailVerificationCreateResponse>;
+export declare const verifyEmail: ({ verificationToken, verificationUUID, environmentId, }: {
+    environmentId: string;
+    verificationToken: string;
+    verificationUUID: string;
+}, userJwt: string) => Promise<UpdateSelfResponse>;

package/src/lib/data/api/email/email.js

@@ -0,0 +1,110 @@
+import { __awaiter } from '../../../../../_virtual/_tslib.js';
+import { NoAccessError, AccountExistsError, EmailVerificationError, UserHasAccountWithEmailError, EmailProviderError } from '@dynamic-labs/utils';
+import { UnprocessableEntityErrorCode } from '@dynamic-labs/sdk-api-core';
+import { logger } from '../../../shared/logger.js';
+import '@dynamic-labs/iconic';
+import '@dynamic-labs/wallet-connector-core';
+import 'react/jsx-runtime';
+import '../../../context/ViewContext/ViewContext.js';
+import 'react';
+import '@dynamic-labs/wallet-book';
+import '../../../utils/constants/colors.js';
+import '../../../utils/constants/values.js';
+import '../../../shared/utils/classes/storage/localStorage.js';
+import '../../../shared/consts/index.js';
+import { sdkApi } from '../api.js';
+
+const getEmailProvider = ({ email, environmentId, }) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const res = yield sdkApi().getEmailProvider({
+            email,
+            environmentId,
+        });
+        return res;
+    }
+    catch (e) {
+        const data = yield e.json();
+        logger.error(data.error);
+        throw new EmailProviderError(data.code);
+    }
+});
+const createEmailVerification = ({ email, environmentId, captchaToken, }) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const res = yield sdkApi().createEmailVerification({
+            emailVerificationCreateRequest: {
+                captchaToken,
+                email,
+            },
+            environmentId,
+        });
+        return res;
+    }
+    catch (e) {
+        const data = yield e.json();
+        logger.error(data.error);
+        throw new EmailVerificationError(data.code);
+    }
+});
+const signInWithEmailVerification = ({ verificationToken, verificationUUID, environmentId, captchaToken, }) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const res = yield sdkApi().signInWithEmailVerification({
+            emailVerificationVerifyRequest: {
+                captchaToken,
+                verificationToken,
+                verificationUUID,
+            },
+            environmentId,
+        });
+        return res;
+    }
+    catch (e) {
+        const data = yield e.json();
+        logger.error(data.error);
+        if (data.error.code === 'missing_from_list') {
+            throw new NoAccessError({ email: data.payload.email });
+        }
+        if (data.code === 'email_associated_with_different_provider') {
+            throw new AccountExistsError(data.error, data.payload);
+        }
+        throw new EmailVerificationError(data.code);
+    }
+});
+const retryEmailVerification = ({ email, environmentId, verificationUUID, }) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const res = yield sdkApi().retryEmailVerification({
+            emailVerificationRetryRequest: {
+                email,
+                verificationUUID,
+            },
+            environmentId,
+        });
+        return res;
+    }
+    catch (e) {
+        const data = yield e.json();
+        logger.error(data.error);
+        throw new EmailVerificationError(data.code);
+    }
+});
+const verifyEmail = ({ verificationToken, verificationUUID, environmentId, }, userJwt) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const res = yield sdkApi(userJwt).verifyEmailVerification({
+            emailVerificationVerifyRequest: {
+                verificationToken,
+                verificationUUID,
+            },
+            environmentId,
+        });
+        return res;
+    }
+    catch (e) {
+        const data = yield e.json();
+        logger.error(data.error);
+        if (data.code === UnprocessableEntityErrorCode.UserHasAlreadyAccountWithEmail) {
+            throw new UserHasAccountWithEmailError(data.error);
+        }
+        throw new EmailVerificationError(data.code);
+    }
+});
+
+export { createEmailVerification, getEmailProvider, retryEmailVerification, signInWithEmailVerification, verifyEmail };

package/src/lib/data/api/email/index.d.ts

@@ -0,0 +1 @@
+export * from './email';

package/src/lib/data/api/embeddedWallets/embeddedWallets.cjs

@@ -0,0 +1,191 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('../../../../../_virtual/_tslib.cjs');
+var utils = require('@dynamic-labs/utils');
+var sdkApiCore = require('@dynamic-labs/sdk-api-core');
+var logger = require('../../../shared/logger.cjs');
+require('@dynamic-labs/iconic');
+require('@dynamic-labs/wallet-connector-core');
+require('react/jsx-runtime');
+require('../../../context/ViewContext/ViewContext.cjs');
+require('react');
+require('@dynamic-labs/wallet-book');
+require('../../../utils/constants/colors.cjs');
+require('../../../utils/constants/values.cjs');
+require('../../../shared/utils/classes/storage/localStorage.cjs');
+require('../../../shared/consts/index.cjs');
+var api = require('../api.cjs');
+
+const createTurnkeyEmbeddedWallet = ({ attestation, challenge, environmentId, userJwt, chains = [sdkApiCore.ChainEnum.Evm], passkeyAlias, }) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+    const embeddedWallets = [
+        {
+            chains,
+            embeddedWalletProvider: sdkApiCore.EmbeddedWalletProviderEnum.Turnkeyhd,
+            isAuthenticatorAttached: false,
+            passkeyAlias,
+        },
+    ];
+    if (attestation && challenge) {
+        embeddedWallets[0] = Object.assign(Object.assign({}, embeddedWallets[0]), { embeddedWalletSpecificOpts: {
+                attestation,
+                challenge,
+            }, isAuthenticatorAttached: true });
+    }
+    return api.sdkApi(userJwt).createEmbeddedWallets({
+        createEmbeddedWalletsRequest: {
+            embeddedWallets,
+        },
+        environmentId,
+    });
+});
+const initEmbeddedWalletSession = ({ authenticatorType, walletId, publicKey, environmentId, userJwt, }) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+    if (authenticatorType === 'passkey') {
+        return api.sdkApi(userJwt).initPasskeyRecovery({
+            environmentId,
+            initPasskeyRecoveryRequest: {
+                turnkeyRecoveryTargetPublicKey: publicKey,
+                walletId,
+            },
+        });
+    }
+    return api.sdkApi(userJwt).initEmailAuth({
+        environmentId,
+        initEmailAuthRequest: {
+            turnkeyEmailAuthTargetPublicKey: publicKey,
+            walletId,
+        },
+    });
+});
+const completePasskeyRecovery = ({ walletId, attestation, challenge, environmentId, userJwt, }) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+    return api.sdkApi(userJwt).completePasskeyRecovery({
+        completePasskeyRecoveryRequest: {
+            attestation,
+            challenge,
+            walletId,
+        },
+        environmentId,
+    });
+});
+const updatePasskeyRecoveryEmail = ({ userJwt, environmentId, updateRecoveryEmailRequest, }) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+    try {
+        yield api.sdkApi(userJwt).updateEmbeddedWalletRecoveryEmail({
+            environmentId,
+            updateRecoveryEmailRequest,
+        });
+    }
+    catch (e) {
+        logger.logger.error('Error while trying to update recovery email: ', e);
+        throw new utils.DynamicError('Error updating recovery email');
+    }
+});
+const getUserPasskeys = ({ userJwt, environmentId, }) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const data = yield api.sdkApi(userJwt).getUserPasskeys({
+            environmentId,
+        });
+        return data;
+    }
+    catch (e) {
+        logger.logger.error(e);
+        return {
+            count: 0,
+            passkeys: [],
+        };
+    }
+});
+const updateUserPasskey = ({ userJwt, environmentId, id, alias, }) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const data = yield api.sdkApi(userJwt).updatePasskey({
+            environmentId,
+            updateUserPasskeyRequest: { alias, id },
+        });
+        return data;
+    }
+    catch (e) {
+        logger.logger.error(e);
+        return undefined;
+    }
+});
+const exportEmbeddedWallet = ({ userJwt, environmentId, walletId, activityId, }) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const data = yield api.sdkApi(userJwt).embeddedWalletExport({
+            activityId,
+            environmentId,
+            walletId,
+        });
+        return data;
+    }
+    catch (e) {
+        logger.logger.error(e);
+        return { exportBundle: '' };
+    }
+});
+const getWalletAuthToken = ({ environmentId, type, }, userJwt) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const authToken = yield api.sdkApi(userJwt).getAuthToken({
+            environmentId,
+            type,
+        });
+        return authToken.token;
+    }
+    catch (e) {
+        return undefined;
+    }
+});
+const getEmbeddedWalletBackup = ({ environmentId, }, userJwt) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const response = yield api.sdkApi(userJwt).getEmbeddedWalletBackups({
+            environmentId,
+        });
+        return response.secret;
+    }
+    catch (e) {
+        return undefined;
+    }
+});
+const getEmbeddedWalletPasscode = ({ environmentId, }, userJwt) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const response = yield api.sdkApi(userJwt).getEmbeddedWalletPasscode({
+            environmentId,
+        });
+        return response.secret;
+    }
+    catch (e) {
+        return undefined;
+    }
+});
+const claimEmbeddedWallet = ({ environmentId, walletId, }, userJwt) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+    var _a, _b;
+    try {
+        const response = yield api.sdkApi(userJwt).claimEmbeddedWallet({
+            embeddedWalletPasscodeClaimRequest: {
+                walletId,
+            },
+            environmentId,
+        });
+        return response;
+    }
+    catch (e) {
+        logger.logger.error(e);
+        // request failed, return unknown error
+        const data = yield ((_a = e === null || e === void 0 ? void 0 : e.json) === null || _a === void 0 ? void 0 : _a.call(e));
+        if (!((_b = data === null || data === void 0 ? void 0 : data.error) === null || _b === void 0 ? void 0 : _b.code)) {
+            return { code: 'unknown_error' };
+        }
+        throw e;
+    }
+});
+
+exports.claimEmbeddedWallet = claimEmbeddedWallet;
+exports.completePasskeyRecovery = completePasskeyRecovery;
+exports.createTurnkeyEmbeddedWallet = createTurnkeyEmbeddedWallet;
+exports.exportEmbeddedWallet = exportEmbeddedWallet;
+exports.getEmbeddedWalletBackup = getEmbeddedWalletBackup;
+exports.getEmbeddedWalletPasscode = getEmbeddedWalletPasscode;
+exports.getUserPasskeys = getUserPasskeys;
+exports.getWalletAuthToken = getWalletAuthToken;
+exports.initEmbeddedWalletSession = initEmbeddedWalletSession;
+exports.updatePasskeyRecoveryEmail = updatePasskeyRecoveryEmail;
+exports.updateUserPasskey = updateUserPasskey;

package/src/lib/data/api/embeddedWallets/embeddedWallets.d.ts

@@ -0,0 +1,30 @@
+import { VerifyResponse, ExportEmbeddedWalletResponse, EmbeddedWalletAuthType } from '@dynamic-labs/sdk-api-core';
+import { CompletePasskeyRecoveryProps, CreateTurnkeyEmbeddedWalletProps, GetUserPasskeysProps, InitPasskeyRecoveryProps, UpdatePasskeyRecoveryEmailProps, UpdateUserPasskeysProps } from './types';
+export declare const createTurnkeyEmbeddedWallet: ({ attestation, challenge, environmentId, userJwt, chains, passkeyAlias, }: CreateTurnkeyEmbeddedWalletProps) => Promise<VerifyResponse>;
+export declare const initEmbeddedWalletSession: ({ authenticatorType, walletId, publicKey, environmentId, userJwt, }: InitPasskeyRecoveryProps) => Promise<import("@dynamic-labs/sdk-api-core").InitPasskeyRecoveryResponse | import("@dynamic-labs/sdk-api-core").InitEmailAuthResponse>;
+export declare const completePasskeyRecovery: ({ walletId, attestation, challenge, environmentId, userJwt, }: CompletePasskeyRecoveryProps) => Promise<VerifyResponse>;
+export declare const updatePasskeyRecoveryEmail: ({ userJwt, environmentId, updateRecoveryEmailRequest, }: UpdatePasskeyRecoveryEmailProps) => Promise<void>;
+export declare const getUserPasskeys: ({ userJwt, environmentId, }: GetUserPasskeysProps) => Promise<import("@dynamic-labs/sdk-api-core").GetUserPasskeysResponse>;
+export declare const updateUserPasskey: ({ userJwt, environmentId, id, alias, }: UpdateUserPasskeysProps) => Promise<import("@dynamic-labs/sdk-api-core").UserPasskey | undefined>;
+export declare const exportEmbeddedWallet: ({ userJwt, environmentId, walletId, activityId, }: {
+    userJwt: string;
+    environmentId: string;
+    walletId: string;
+    activityId: string;
+}) => Promise<ExportEmbeddedWalletResponse>;
+export declare const getWalletAuthToken: ({ environmentId, type, }: {
+    environmentId: string;
+    type: EmbeddedWalletAuthType | undefined;
+}, userJwt: string) => Promise<string | undefined>;
+export declare const getEmbeddedWalletBackup: ({ environmentId, }: {
+    environmentId: string;
+}, userJwt: string) => Promise<string | undefined>;
+export declare const getEmbeddedWalletPasscode: ({ environmentId, }: {
+    environmentId: string;
+}, userJwt: string) => Promise<string | undefined>;
+export declare const claimEmbeddedWallet: ({ environmentId, walletId, }: {
+    environmentId: string;
+    walletId: string;
+}, userJwt: string) => Promise<VerifyResponse | {
+    code: string;
+}>;