@dynamic-labs/sdk-react-core 0.16.0

package/src/lib/context/ViewContext/ViewContext.es.js

@@ -0,0 +1,29 @@
+import { jsx } from 'react/jsx-runtime';
+import { createContext, useState, useEffect, useMemo, useContext } from 'react';
+
+const ViewContext = createContext(undefined);
+const ViewContextProvider = ({ children, loginWithEmail, }) => {
+    const [view, setView] = useState(loginWithEmail ? 'login-with-email-or-wallet' : 'wallet-list');
+    useEffect(() => {
+        if (loginWithEmail) {
+            setView('login-with-email-or-wallet');
+        }
+        else {
+            setView('wallet-list');
+        }
+    }, [loginWithEmail]);
+    const value = useMemo(() => ({
+        setView,
+        view,
+    }), [view]);
+    return jsx(ViewContext.Provider, Object.assign({ value: value }, { children: children }));
+};
+const useViewContext = () => {
+    const context = useContext(ViewContext);
+    if (context === undefined) {
+        throw new Error('usage of useViewContext not wrapped in `ViewContextProvider`.');
+    }
+    return context;
+};
+
+export { ViewContext, ViewContextProvider, useViewContext };

package/src/lib/context/ViewContext/index.d.ts

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

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

@@ -0,0 +1,356 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('../../../_virtual/_tslib.cjs.js');
+var multiWallet = require('@dynamic-labs/multi-wallet');
+var sdkApi$1 = require('@dynamic-labs/sdk-api');
+var version = require('../../version.cjs.js');
+var ApiEndpoint = require('../config/ApiEndpoint.cjs.js');
+var logger = require('../shared/logger.cjs.js');
+require('@dynamic-labs/iconic');
+require('react/jsx-runtime');
+require('../context/ViewContext/ViewContext.cjs.js');
+require('react');
+require('../utils/constants/colors.cjs.js');
+require('../shared/consts/index.cjs.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.VERSION}`;
+    settings.headers['x-dyn-api-version'] = `API/${version.API_VERSION}`;
+    return new sdkApi$1.SDKApi(new sdkApi$1.Configuration(settings));
+};
+const fetchNonce = (environmentId) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const res = yield sdkApi().getNonce({
+            environmentId,
+        });
+        return res.nonce;
+    }
+    catch (e) {
+        return undefined;
+    }
+});
+const createEmailVerification = ({ email, environmentId, }) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const res = yield sdkApi().createEmailVerification({
+            emailVerificationCreateRequest: {
+                email,
+            },
+            environmentId,
+        });
+        return res;
+    }
+    catch (e) {
+        const data = yield e.json();
+        logger.logger.error(data.error);
+        throw new multiWallet.EmailVerificationError(data.code);
+    }
+});
+const signInWithEmailVerification = ({ verificationToken, verificationUUID, environmentId, }) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const res = yield sdkApi().signInWithEmailVerification({
+            emailVerificationVerifyRequest: {
+                verificationToken,
+                verificationUUID,
+            },
+            environmentId,
+        });
+        return res;
+    }
+    catch (e) {
+        const data = yield e.json();
+        logger.logger.error(data.error);
+        throw new multiWallet.EmailVerificationError(data.code);
+    }
+});
+const retryEmailVerification = ({ email, environmentId, verificationUUID, }) => _tslib.__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.logger.error(data.error);
+        throw new multiWallet.EmailVerificationError(data.code);
+    }
+});
+const verifyEmail = ({ verificationToken, verificationUUID, environmentId, }, userJwt) => _tslib.__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.logger.error(data.error);
+        throw new multiWallet.EmailVerificationError(data.code);
+    }
+});
+const revokeSession = ({ environmentId, sessionId, }, userJwt) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+    try {
+        yield sdkApi(userJwt).revokeSession({
+            environmentId,
+        });
+    }
+    catch (error) {
+        const body = yield error.json();
+        logger.logger.error(Error(body.error.message));
+    }
+});
+const linkWallet = (environmentId, { messageToSign, signedMessage, publicWalletAddress, chain, walletName, walletProvider, }, userJwt) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+    // We should find a better way to do this than force type casting
+    const verifyRequest = {
+        chain,
+        messageToSign,
+        publicWalletAddress,
+        signedMessage,
+        walletName,
+        walletProvider,
+    };
+    try {
+        const { jwt } = yield sdkApi(userJwt).verifyLink({
+            environmentId,
+            verifyRequest,
+        });
+        return jwt;
+    }
+    catch (e) {
+        logger.logger.error(e);
+        const data = yield e.json();
+        if (data.code === 'reassign_wallet_confirm' ||
+            data.code === 'reassign_wallet_error') {
+            throw new multiWallet.WalletUsedError(data.code);
+        }
+        return undefined;
+    }
+});
+const unlinkWallet = ({ environmentId, primaryWalletId, walletId, }, userJwt) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const { jwt } = yield sdkApi(userJwt).verifyUnlink({
+            environmentId,
+            verifyUnlinkRequest: {
+                primaryWalletId,
+                walletId,
+            },
+        });
+        return jwt;
+    }
+    catch (e) {
+        return undefined;
+    }
+});
+const transferWallet = (environmentId, { messageToSign, signedMessage, publicWalletAddress, chain, walletName, walletProvider, skipEmptyAccountCheck = false, }, userJwt) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+    // We should find a better way to do this than force type casting
+    const verifyRequest = {
+        chain,
+        messageToSign,
+        publicWalletAddress,
+        signedMessage,
+        skipEmptyAccountCheck,
+        walletName,
+        walletProvider,
+    };
+    try {
+        const { jwt } = yield sdkApi(userJwt).verifyTransfer({
+            environmentId,
+            verifyRequest,
+        });
+        return jwt;
+    }
+    catch (_a) {
+        return undefined;
+    }
+});
+const mapChainToChainEnum = (chain) => {
+    const foundChain = Object.values(sdkApi$1.ChainEnum).find((value) => value === chain);
+    if (!foundChain) {
+        throw new multiWallet.DynamicError(`Invalid chain ${chain}`);
+    }
+    return foundChain;
+};
+const mapProviderToProviderEnum = (provider) => {
+    const foundProvider = Object.values(sdkApi$1.WalletProviderEnum).find((value) => value === provider);
+    if (!foundProvider) {
+        throw new multiWallet.DynamicError(`Invalid provider ${provider}`);
+    }
+    return foundProvider;
+};
+const mapAuthModeTypeToEnum = (authMode) => {
+    const found = Object.values(sdkApi$1.AuthModeEnum).find((value) => value === authMode);
+    if (!found) {
+        throw new multiWallet.DynamicError(`Invalid authMode ${authMode}`);
+    }
+    return found;
+};
+const createVisit = ({ authMode, chain, environmentId, walletProvider, publicWalletAddress, walletName, }) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const connectRequest = {
+            address: publicWalletAddress,
+            authMode: mapAuthModeTypeToEnum(authMode),
+            chain: mapChainToChainEnum(chain),
+            provider: mapProviderToProviderEnum(walletProvider),
+            walletName,
+        };
+        yield sdkApi().createVisit({
+            connectRequest,
+            environmentId,
+        });
+    }
+    catch (error) {
+        // log error to console, don't do anything else
+        logger.logger.error(error);
+    }
+});
+const verifyWallet = (environmentId, { messageToSign, signedMessage, publicWalletAddress, chain, walletName, walletProvider, captchaToken, }) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+    // We should find a better way to do this than force type casting
+    const verifyRequest = {
+        captchaToken,
+        chain,
+        messageToSign,
+        publicWalletAddress,
+        signedMessage,
+        walletName,
+        walletProvider,
+    };
+    try {
+        const { jwt } = yield sdkApi().verify({
+            environmentId,
+            verifyRequest,
+        });
+        return jwt;
+    }
+    catch (e) {
+        logger.logger.error(e);
+        const data = yield e.json();
+        if (data.code === 'wallet_not_deployed') {
+            throw new multiWallet.WalletNotDeployedError();
+        }
+        if (data.error.code === 'chainalysis_blocked_wallet') {
+            throw new multiWallet.ChainalysisError(data.payload.walletPublicKey);
+        }
+        if (data.error.code === 'missing_from_list') {
+            throw new multiWallet.NoAccessError(data.payload.walletPublicKey);
+        }
+        return undefined;
+    }
+});
+const fetchNetworkSettings = (environmentId) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const res = yield sdkApi().getNetworksConfigurationByEnvId({
+            environmentId,
+        });
+        return res;
+    }
+    catch (e) {
+        logger.logger.error(e);
+        return undefined;
+    }
+});
+const fetchProjectSettings = (environmentId) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const res = yield sdkApi().getEnvironmentSettings({
+            environmentId,
+        });
+        return res;
+    }
+    catch (e) {
+        logger.logger.error(e);
+        return undefined;
+    }
+});
+const updateUserProfileFields = (jwt, environmentId, fields) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+    try {
+        if (!jwt)
+            throw new multiWallet.DynamicError('User not authenticated');
+        const res = yield sdkApi(jwt).updateSelf({
+            environmentId,
+            userFields: fields,
+        });
+        return res;
+    }
+    catch (e) {
+        logger.logger.error(e);
+        if (e instanceof Response) {
+            const error = yield e.json();
+            if (error.code === 'email_already_exists') {
+                throw new multiWallet.EmailAlreadyExistsError();
+            }
+            else if (error.code === 'username_already_exists') {
+                throw new multiWallet.UsernameAlreadyExistsError();
+            }
+        }
+        throw e;
+    }
+});
+const verifyOAuth = (environmentId, providerType, { code }, userJwt) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+    const oauthRequest = {
+        code,
+    };
+    try {
+        const { jwt } = yield sdkApi(userJwt).oauthVerify({
+            environmentId,
+            oauthRequest,
+            providerType,
+        });
+        return jwt;
+    }
+    catch (e) {
+        logger.logger.error(e);
+        return undefined;
+    }
+});
+const unlinkOAuth = ({ environmentId, verifiedCrentialId, }, userJwt) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const { jwt } = yield sdkApi(userJwt).verifyUnlink({
+            environmentId,
+            verifyUnlinkRequest: {
+                verifiedCrentialId,
+            },
+        });
+        return jwt;
+    }
+    catch (e) {
+        return undefined;
+    }
+});
+
+exports.createEmailVerification = createEmailVerification;
+exports.createVisit = createVisit;
+exports.fetchNetworkSettings = fetchNetworkSettings;
+exports.fetchNonce = fetchNonce;
+exports.fetchProjectSettings = fetchProjectSettings;
+exports.linkWallet = linkWallet;
+exports.mapAuthModeTypeToEnum = mapAuthModeTypeToEnum;
+exports.mapChainToChainEnum = mapChainToChainEnum;
+exports.mapProviderToProviderEnum = mapProviderToProviderEnum;
+exports.retryEmailVerification = retryEmailVerification;
+exports.revokeSession = revokeSession;
+exports.signInWithEmailVerification = signInWithEmailVerification;
+exports.transferWallet = transferWallet;
+exports.unlinkOAuth = unlinkOAuth;
+exports.unlinkWallet = unlinkWallet;
+exports.updateUserProfileFields = updateUserProfileFields;
+exports.verifyEmail = verifyEmail;
+exports.verifyOAuth = verifyOAuth;
+exports.verifyWallet = verifyWallet;

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

@@ -0,0 +1,53 @@
+import { ProjectSettings, UserFields, NetworkConfigurationResponse, ChainEnum, UpdateSelfResponse, WalletProviderEnum, AuthModeEnum, EmailVerificationCreateResponse, VerifyResponse, OauthRequest, ProviderEnum } from '@dynamic-labs/sdk-api';
+import { AuthModeType, VerifyWallet } from '../shared/types';
+export declare const fetchNonce: (environmentId: string) => Promise<string | undefined>;
+export declare const createEmailVerification: ({ email, environmentId, }: {
+    email: string;
+    environmentId: string;
+}) => Promise<EmailVerificationCreateResponse>;
+export declare const signInWithEmailVerification: ({ verificationToken, verificationUUID, environmentId, }: {
+    environmentId: string;
+    verificationToken: string;
+    verificationUUID: string;
+}) => 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>;
+export declare const revokeSession: ({ environmentId, sessionId, }: {
+    environmentId: string;
+    sessionId: string;
+}, userJwt: string) => Promise<void>;
+export declare const linkWallet: (environmentId: string, { messageToSign, signedMessage, publicWalletAddress, chain, walletName, walletProvider, }: VerifyWallet, userJwt: string) => Promise<string | undefined>;
+export declare const unlinkWallet: ({ environmentId, primaryWalletId, walletId, }: {
+    environmentId: string;
+    primaryWalletId: string | undefined;
+    walletId: string;
+}, userJwt: string) => Promise<string | undefined>;
+export declare const transferWallet: (environmentId: string, { messageToSign, signedMessage, publicWalletAddress, chain, walletName, walletProvider, skipEmptyAccountCheck, }: VerifyWallet, userJwt: string) => Promise<string | undefined>;
+export declare const mapChainToChainEnum: (chain: string) => ChainEnum;
+export declare const mapProviderToProviderEnum: (provider: string) => WalletProviderEnum;
+export declare const mapAuthModeTypeToEnum: (authMode: string) => AuthModeEnum;
+export declare const createVisit: ({ authMode, chain, environmentId, walletProvider, publicWalletAddress, walletName, }: {
+    authMode: AuthModeType;
+    chain: string;
+    environmentId: string;
+    publicWalletAddress: string;
+    walletName: string;
+    walletProvider: string;
+}) => Promise<void | undefined>;
+export declare const verifyWallet: (environmentId: string, { messageToSign, signedMessage, publicWalletAddress, chain, walletName, walletProvider, captchaToken, }: VerifyWallet) => Promise<string | undefined>;
+export declare const fetchNetworkSettings: (environmentId: string) => Promise<NetworkConfigurationResponse[] | undefined>;
+export declare const fetchProjectSettings: (environmentId: string) => Promise<ProjectSettings | undefined>;
+export declare const updateUserProfileFields: (jwt: string | undefined, environmentId: string, fields: UserFields) => Promise<UpdateSelfResponse>;
+export declare const verifyOAuth: (environmentId: string, providerType: ProviderEnum, { code }: OauthRequest, userJwt: string) => Promise<string | undefined>;
+export declare const unlinkOAuth: ({ environmentId, verifiedCrentialId, }: {
+    environmentId: string;
+    verifiedCrentialId: string;
+}, userJwt: string) => Promise<string | undefined>;