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

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

@@ -0,0 +1,177 @@
+import { __awaiter } from '../../../../../_virtual/_tslib.js';
+import { DynamicError } from '@dynamic-labs/utils';
+import { EmbeddedWalletProviderEnum, ChainEnum } 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 createTurnkeyEmbeddedWallet = ({ attestation, challenge, environmentId, userJwt, chains = [ChainEnum.Evm], passkeyAlias, }) => __awaiter(void 0, void 0, void 0, function* () {
+    const embeddedWallets = [
+        {
+            chains,
+            embeddedWalletProvider: EmbeddedWalletProviderEnum.Turnkeyhd,
+            isAuthenticatorAttached: false,
+            passkeyAlias,
+        },
+    ];
+    if (attestation && challenge) {
+        embeddedWallets[0] = Object.assign(Object.assign({}, embeddedWallets[0]), { embeddedWalletSpecificOpts: {
+                attestation,
+                challenge,
+            }, isAuthenticatorAttached: true });
+    }
+    return sdkApi(userJwt).createEmbeddedWallets({
+        createEmbeddedWalletsRequest: {
+            embeddedWallets,
+        },
+        environmentId,
+    });
+});
+const initEmbeddedWalletSession = ({ authenticatorType, walletId, publicKey, environmentId, userJwt, }) => __awaiter(void 0, void 0, void 0, function* () {
+    if (authenticatorType === 'passkey') {
+        return sdkApi(userJwt).initPasskeyRecovery({
+            environmentId,
+            initPasskeyRecoveryRequest: {
+                turnkeyRecoveryTargetPublicKey: publicKey,
+                walletId,
+            },
+        });
+    }
+    return sdkApi(userJwt).initEmailAuth({
+        environmentId,
+        initEmailAuthRequest: {
+            turnkeyEmailAuthTargetPublicKey: publicKey,
+            walletId,
+        },
+    });
+});
+const completePasskeyRecovery = ({ walletId, attestation, challenge, environmentId, userJwt, }) => __awaiter(void 0, void 0, void 0, function* () {
+    return sdkApi(userJwt).completePasskeyRecovery({
+        completePasskeyRecoveryRequest: {
+            attestation,
+            challenge,
+            walletId,
+        },
+        environmentId,
+    });
+});
+const updatePasskeyRecoveryEmail = ({ userJwt, environmentId, updateRecoveryEmailRequest, }) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        yield sdkApi(userJwt).updateEmbeddedWalletRecoveryEmail({
+            environmentId,
+            updateRecoveryEmailRequest,
+        });
+    }
+    catch (e) {
+        logger.error('Error while trying to update recovery email: ', e);
+        throw new DynamicError('Error updating recovery email');
+    }
+});
+const getUserPasskeys = ({ userJwt, environmentId, }) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const data = yield sdkApi(userJwt).getUserPasskeys({
+            environmentId,
+        });
+        return data;
+    }
+    catch (e) {
+        logger.error(e);
+        return {
+            count: 0,
+            passkeys: [],
+        };
+    }
+});
+const updateUserPasskey = ({ userJwt, environmentId, id, alias, }) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const data = yield sdkApi(userJwt).updatePasskey({
+            environmentId,
+            updateUserPasskeyRequest: { alias, id },
+        });
+        return data;
+    }
+    catch (e) {
+        logger.error(e);
+        return undefined;
+    }
+});
+const exportEmbeddedWallet = ({ userJwt, environmentId, walletId, activityId, }) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const data = yield sdkApi(userJwt).embeddedWalletExport({
+            activityId,
+            environmentId,
+            walletId,
+        });
+        return data;
+    }
+    catch (e) {
+        logger.error(e);
+        return { exportBundle: '' };
+    }
+});
+const getWalletAuthToken = ({ environmentId, type, }, userJwt) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const authToken = yield sdkApi(userJwt).getAuthToken({
+            environmentId,
+            type,
+        });
+        return authToken.token;
+    }
+    catch (e) {
+        return undefined;
+    }
+});
+const getEmbeddedWalletBackup = ({ environmentId, }, userJwt) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const response = yield sdkApi(userJwt).getEmbeddedWalletBackups({
+            environmentId,
+        });
+        return response.secret;
+    }
+    catch (e) {
+        return undefined;
+    }
+});
+const getEmbeddedWalletPasscode = ({ environmentId, }, userJwt) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const response = yield sdkApi(userJwt).getEmbeddedWalletPasscode({
+            environmentId,
+        });
+        return response.secret;
+    }
+    catch (e) {
+        return undefined;
+    }
+});
+const claimEmbeddedWallet = ({ environmentId, walletId, }, userJwt) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a, _b;
+    try {
+        const response = yield sdkApi(userJwt).claimEmbeddedWallet({
+            embeddedWalletPasscodeClaimRequest: {
+                walletId,
+            },
+            environmentId,
+        });
+        return response;
+    }
+    catch (e) {
+        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;
+    }
+});
+
+export { claimEmbeddedWallet, completePasskeyRecovery, createTurnkeyEmbeddedWallet, exportEmbeddedWallet, getEmbeddedWalletBackup, getEmbeddedWalletPasscode, getUserPasskeys, getWalletAuthToken, initEmbeddedWalletSession, updatePasskeyRecoveryEmail, updateUserPasskey };

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

@@ -0,0 +1,2 @@
+export * from './embeddedWallets';
+export * from './types';

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

@@ -0,0 +1,39 @@
+import { ChainEnum, PasskeyRegistrationCredential, UpdateRecoveryEmailRequest } from '@dynamic-labs/sdk-api-core';
+import { AuthenticatorType } from '@dynamic-labs/wallet-connector-core';
+export type CreateTurnkeyEmbeddedWalletProps = {
+    userJwt: string;
+    environmentId: string;
+    attestation?: PasskeyRegistrationCredential;
+    challenge?: string;
+    chains?: ChainEnum[];
+    passkeyAlias?: string;
+};
+export type InitPasskeyRecoveryProps = {
+    authenticatorType: AuthenticatorType;
+    userJwt: string;
+    environmentId: string;
+    walletId: string;
+    publicKey: string;
+};
+export type CompletePasskeyRecoveryProps = {
+    userJwt: string;
+    environmentId: string;
+    walletId: string;
+    attestation: PasskeyRegistrationCredential;
+    challenge: string;
+};
+export type UpdatePasskeyRecoveryEmailProps = {
+    userJwt: string;
+    environmentId: string;
+    updateRecoveryEmailRequest: UpdateRecoveryEmailRequest;
+};
+export type GetUserPasskeysProps = {
+    userJwt: string;
+    environmentId: string;
+};
+export type UpdateUserPasskeysProps = {
+    userJwt: string;
+    environmentId: string;
+    id: string;
+    alias: string;
+};

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

@@ -0,0 +1,10 @@
+export * from './email';
+export * from './embeddedWallets';
+export * from './oauth';
+export * from './onramp';
+export * from './session';
+export * from './settings';
+export * from './sms';
+export * from './user';
+export * from './utils';
+export * from './wallets';

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

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

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

@@ -0,0 +1,136 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('../../../../../_virtual/_tslib.cjs');
+var utils = require('@dynamic-labs/utils');
+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 verifyOAuth = (environmentId, providerType, { code, codeVerifier, state }, userJwt) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+    const oauthRequest = {
+        code,
+        codeVerifier,
+        state,
+    };
+    try {
+        const response = yield api.sdkApi(userJwt).oauthVerify({
+            environmentId,
+            oauthRequest,
+            providerType,
+        });
+        return response;
+    }
+    catch (e) {
+        logger.logger.error(e);
+        const data = yield e.json();
+        if (data.code === 'social_account_already_exists') {
+            throw new utils.SocialAccountAlreadyExistsError();
+        }
+        return undefined;
+    }
+});
+const unlinkOAuth = ({ environmentId, primaryWalletId, verifiedCrentialId, }, userJwt) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const response = yield api.sdkApi(userJwt).verifyUnlink({
+            environmentId,
+            verifyUnlinkRequest: {
+                primaryWalletId,
+                verifiedCrentialId,
+            },
+        });
+        return response;
+    }
+    catch (e) {
+        return undefined;
+    }
+});
+const signInOAuth = (environmentId, providerType, { code, codeVerifier, state, captchaToken }) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+    var _a;
+    const oauthRequest = {
+        captchaToken,
+        code,
+        codeVerifier,
+        state,
+    };
+    try {
+        const response = yield api.sdkApi().oauthSignIn({
+            environmentId,
+            oauthRequest,
+            providerType,
+        });
+        return response;
+    }
+    catch (e) {
+        logger.logger.error(e);
+        const data = yield e.json();
+        if (data.error.code === 'gate_blocked') {
+            throw new utils.GateBlockedError(data.payload.walletPublicKey);
+        }
+        if (data.error.code === 'missing_from_list') {
+            throw new utils.NoAccessError({
+                walletPublicKey: (_a = data === null || data === void 0 ? void 0 : data.payload) === null || _a === void 0 ? void 0 : _a.walletPublicKey,
+            });
+        }
+        if (data.code === 'email_associated_with_different_provider') {
+            throw new utils.AccountExistsError(data.error, data.payload);
+        }
+        return undefined;
+    }
+});
+const getOAuthResult = (environmentId, providerType, { state }) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+    const oauthResultRequest = {
+        state,
+    };
+    try {
+        const result = yield api.sdkApi().oauthResult({
+            environmentId,
+            oauthResultRequest,
+            providerType,
+        });
+        return result;
+    }
+    catch (e) {
+        logger.logger.error(e);
+        return undefined;
+    }
+});
+const farcasterSignIn = (environmentId, farcasterSignInRequest) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const response = yield api.sdkApi().farcasterSignIn({
+            environmentId,
+            farcasterSignInRequest,
+        });
+        return response;
+    }
+    catch (e) {
+        logger.logger.error(e);
+        const data = yield e.json();
+        if (data.error.code === 'gate_blocked') {
+            throw new utils.GateBlockedError(data.payload.walletPublicKey);
+        }
+        if (data.error.code === 'missing_from_list') {
+            throw new utils.NoAccessError({
+                walletPublicKey: data.payload.walletPublicKey,
+            });
+        }
+        return undefined;
+    }
+});
+
+exports.farcasterSignIn = farcasterSignIn;
+exports.getOAuthResult = getOAuthResult;
+exports.signInOAuth = signInOAuth;
+exports.unlinkOAuth = unlinkOAuth;
+exports.verifyOAuth = verifyOAuth;

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

@@ -0,0 +1,11 @@
+import { FarcasterSignInRequest, OauthRequest, OauthResultRequest, OauthResultResponse, ProviderEnum, VerifyResponse } from '@dynamic-labs/sdk-api-core';
+export declare const getOauthLoginUrl: (environmentId: string, providerType: ProviderEnum, userJwt: string) => Promise<string | undefined>;
+export declare const verifyOAuth: (environmentId: string, providerType: ProviderEnum, { code, codeVerifier, state }: OauthRequest, userJwt: string) => Promise<VerifyResponse | undefined>;
+export declare const unlinkOAuth: ({ environmentId, primaryWalletId, verifiedCrentialId, }: {
+    environmentId: string;
+    primaryWalletId: string | undefined;
+    verifiedCrentialId: string;
+}, userJwt: string) => Promise<VerifyResponse | undefined>;
+export declare const signInOAuth: (environmentId: string, providerType: ProviderEnum, { code, codeVerifier, state, captchaToken }: OauthRequest) => Promise<VerifyResponse | undefined>;
+export declare const getOAuthResult: (environmentId: string, providerType: ProviderEnum, { state }: OauthResultRequest) => Promise<OauthResultResponse | undefined>;
+export declare const farcasterSignIn: (environmentId: string, farcasterSignInRequest: FarcasterSignInRequest) => Promise<VerifyResponse | undefined>;

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

@@ -0,0 +1,128 @@
+import { __awaiter } from '../../../../../_virtual/_tslib.js';
+import { GateBlockedError, NoAccessError, AccountExistsError, SocialAccountAlreadyExistsError } from '@dynamic-labs/utils';
+import '@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 verifyOAuth = (environmentId, providerType, { code, codeVerifier, state }, userJwt) => __awaiter(void 0, void 0, void 0, function* () {
+    const oauthRequest = {
+        code,
+        codeVerifier,
+        state,
+    };
+    try {
+        const response = yield sdkApi(userJwt).oauthVerify({
+            environmentId,
+            oauthRequest,
+            providerType,
+        });
+        return response;
+    }
+    catch (e) {
+        logger.error(e);
+        const data = yield e.json();
+        if (data.code === 'social_account_already_exists') {
+            throw new SocialAccountAlreadyExistsError();
+        }
+        return undefined;
+    }
+});
+const unlinkOAuth = ({ environmentId, primaryWalletId, verifiedCrentialId, }, userJwt) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const response = yield sdkApi(userJwt).verifyUnlink({
+            environmentId,
+            verifyUnlinkRequest: {
+                primaryWalletId,
+                verifiedCrentialId,
+            },
+        });
+        return response;
+    }
+    catch (e) {
+        return undefined;
+    }
+});
+const signInOAuth = (environmentId, providerType, { code, codeVerifier, state, captchaToken }) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a;
+    const oauthRequest = {
+        captchaToken,
+        code,
+        codeVerifier,
+        state,
+    };
+    try {
+        const response = yield sdkApi().oauthSignIn({
+            environmentId,
+            oauthRequest,
+            providerType,
+        });
+        return response;
+    }
+    catch (e) {
+        logger.error(e);
+        const data = yield e.json();
+        if (data.error.code === 'gate_blocked') {
+            throw new GateBlockedError(data.payload.walletPublicKey);
+        }
+        if (data.error.code === 'missing_from_list') {
+            throw new NoAccessError({
+                walletPublicKey: (_a = data === null || data === void 0 ? void 0 : data.payload) === null || _a === void 0 ? void 0 : _a.walletPublicKey,
+            });
+        }
+        if (data.code === 'email_associated_with_different_provider') {
+            throw new AccountExistsError(data.error, data.payload);
+        }
+        return undefined;
+    }
+});
+const getOAuthResult = (environmentId, providerType, { state }) => __awaiter(void 0, void 0, void 0, function* () {
+    const oauthResultRequest = {
+        state,
+    };
+    try {
+        const result = yield sdkApi().oauthResult({
+            environmentId,
+            oauthResultRequest,
+            providerType,
+        });
+        return result;
+    }
+    catch (e) {
+        logger.error(e);
+        return undefined;
+    }
+});
+const farcasterSignIn = (environmentId, farcasterSignInRequest) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const response = yield sdkApi().farcasterSignIn({
+            environmentId,
+            farcasterSignInRequest,
+        });
+        return response;
+    }
+    catch (e) {
+        logger.error(e);
+        const data = yield e.json();
+        if (data.error.code === 'gate_blocked') {
+            throw new GateBlockedError(data.payload.walletPublicKey);
+        }
+        if (data.error.code === 'missing_from_list') {
+            throw new NoAccessError({
+                walletPublicKey: data.payload.walletPublicKey,
+            });
+        }
+        return undefined;
+    }
+});
+
+export { farcasterSignIn, getOAuthResult, signInOAuth, unlinkOAuth, verifyOAuth };

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

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

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

@@ -0,0 +1,22 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('../../../../../_virtual/_tslib.cjs');
+var api = require('../api.cjs');
+
+const getOnrampProviders = ({ chain, environmentId, networkId, token, walletAddress, }) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+    const { onramps } = yield api.sdkApi().getSupportedOnramps({
+        chain,
+        environmentId,
+        networkId: networkId ? String(networkId) : undefined,
+        token,
+        walletAddress,
+    });
+    if (!onramps || onramps.length === 0) {
+        throw new Error('No onramps');
+    }
+    return onramps;
+});
+
+exports.getOnrampProviders = getOnrampProviders;

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

@@ -0,0 +1,8 @@
+import { OnrampConfiguration } from '@dynamic-labs/sdk-api-core';
+export declare const getOnrampProviders: ({ chain, environmentId, networkId, token, walletAddress, }: {
+    chain: string;
+    environmentId: string;
+    networkId?: string | number | undefined;
+    token?: string | undefined;
+    walletAddress: string;
+}) => Promise<OnrampConfiguration[]>;

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

@@ -0,0 +1,18 @@
+import { __awaiter } from '../../../../../_virtual/_tslib.js';
+import { sdkApi } from '../api.js';
+
+const getOnrampProviders = ({ chain, environmentId, networkId, token, walletAddress, }) => __awaiter(void 0, void 0, void 0, function* () {
+    const { onramps } = yield sdkApi().getSupportedOnramps({
+        chain,
+        environmentId,
+        networkId: networkId ? String(networkId) : undefined,
+        token,
+        walletAddress,
+    });
+    if (!onramps || onramps.length === 0) {
+        throw new Error('No onramps');
+    }
+    return onramps;
+});
+
+export { getOnrampProviders };

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

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

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

@@ -0,0 +1,77 @@
+'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 revokeSession = ({ environmentId, sessionId, }, userJwt) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+    try {
+        yield api.sdkApi(userJwt).revokeSession({
+            environmentId,
+        });
+    }
+    catch (error) {
+        const body = yield error.json();
+        logger.logger.error(Error(body.error.message));
+    }
+});
+const mapChainToChainEnum = (chain) => {
+    const foundChain = Object.values(sdkApiCore.ChainEnum).find((value) => value === chain);
+    if (!foundChain) {
+        throw new utils.DynamicError(`Invalid chain ${chain}`);
+    }
+    return foundChain;
+};
+const mapProviderToProviderEnum = (provider) => {
+    const foundProvider = Object.values(sdkApiCore.WalletProviderEnum).find((value) => value === provider);
+    if (!foundProvider) {
+        throw new utils.DynamicError(`Invalid provider ${provider}`);
+    }
+    return foundProvider;
+};
+const mapAuthModeTypeToEnum = (authMode) => {
+    const found = Object.values(sdkApiCore.AuthModeEnum).find((value) => value === authMode);
+    if (!found) {
+        throw new utils.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 api.sdkApi().createVisit({
+            connectRequest,
+            environmentId,
+        });
+    }
+    catch (error) {
+        // log error to console, don't do anything else
+        logger.logger.error(error);
+    }
+});
+
+exports.createVisit = createVisit;
+exports.mapAuthModeTypeToEnum = mapAuthModeTypeToEnum;
+exports.mapChainToChainEnum = mapChainToChainEnum;
+exports.mapProviderToProviderEnum = mapProviderToProviderEnum;
+exports.revokeSession = revokeSession;

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

@@ -0,0 +1,17 @@
+import { ChainEnum, WalletProviderEnum, AuthModeEnum } from '@dynamic-labs/sdk-api-core';
+import { AuthModeType } from '../../../shared/types';
+export declare const revokeSession: ({ environmentId, sessionId, }: {
+    environmentId: string;
+    sessionId: string;
+}, userJwt: string) => Promise<void>;
+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>;