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

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Dynamic Labs, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,7 @@
+# multi-wallet
+
+This library was generated with [Nx](https://nx.dev).
+
+## Running unit tests
+
+Run `nx test multi-wallet` to execute the unit tests via [Jest](https://jestjs.io).

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@dynamic-labs/multi-wallet",
+  "version": "0.0.0-exp20240808.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/dynamic-labs/dynamic-auth.git",
+    "directory": "packages/multi-wallet"
+  },
+  "dependencies": {
+    "@dynamic-labs/sdk-api-core": "0.0.509",
+    "tslib": "2.4.1",
+    "@dynamic-labs/rpc-providers": "0.0.0-exp20240808.0",
+    "@dynamic-labs/types": "0.0.0-exp20240808.0",
+    "@dynamic-labs/utils": "0.0.0-exp20240808.0",
+    "@dynamic-labs/wallet-book": "0.0.0-exp20240808.0",
+    "@dynamic-labs/wallet-connector-core": "0.0.0-exp20240808.0"
+  },
+  "devDependencies": {
+    "@walletconnect/types": "2.10.6"
+  },
+  "description": "Multi-wallet is a toolkit for working with many different wallets to create and verify signatures",
+  "bugs": {
+    "url": "https://github.com/dynamic-labs/DynamicAuth/issues"
+  },
+  "homepage": "https://github.com/dynamic-labs/DynamicAuth/main/packages/multi-wallet#readme",
+  "author": "Dynamic Labs, Inc.",
+  "license": "MIT",
+  "main": "./src/index.cjs",
+  "module": "./src/index.js",
+  "types": "./src/index.d.ts",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./src/index.d.ts",
+      "import": "./src/index.js",
+      "require": "./src/index.cjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "peerDependencies": {}
+}

package/src/index.cjs

@@ -0,0 +1,15 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var multiWallet = require('./multi-wallet.cjs');
+var message = require('./utils/message.cjs');
+
+
+
+exports.getEnabledProviders = multiWallet.getEnabledProviders;
+exports.getEnabledWallets = multiWallet.getEnabledWallets;
+exports.getSupportedChainsForWalletConnector = multiWallet.getSupportedChainsForWalletConnector;
+exports.getSupportedWallets = multiWallet.getSupportedWallets;
+exports.generateMessageToSign = message.generateMessageToSign;

package/src/index.d.ts

@@ -0,0 +1,3 @@
+export * from './multi-wallet';
+export * from './types';
+export { generateMessageToSign } from './utils/message';

package/src/index.js

@@ -0,0 +1,3 @@
+'use client'
+export { getEnabledProviders, getEnabledWallets, getSupportedChainsForWalletConnector, getSupportedWallets } from './multi-wallet.js';
+export { generateMessageToSign } from './utils/message.js';

package/src/multi-wallet.cjs

@@ -0,0 +1,178 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var walletConnectorCore = require('@dynamic-labs/wallet-connector-core');
+var walletBook = require('@dynamic-labs/wallet-book');
+var utils = require('@dynamic-labs/utils');
+var sdkApiCore = require('@dynamic-labs/sdk-api-core');
+var getApiProviders = require('./utils/getApiProviders.cjs');
+
+let wallets = [];
+const defaultWalletUiUtils = {
+    createPassword: () => {
+        throw Error('createPassword not implemented');
+    },
+    disabledConfirmationOnce: () => {
+        throw Error('disabledConfirmationOnce, not implemented');
+    },
+    enterPassword: () => {
+        throw Error('enterPassword not implemented');
+    },
+    sendTransaction: () => {
+        throw Error('requestSendTransactionConfirmation not implemented');
+    },
+    signMessage: () => {
+        throw Error('signMessage not implemented');
+    },
+    syncWallet: () => {
+        throw Error('syncWallet not implemented');
+    },
+};
+const getSupportedWallets = (args) => {
+    const { appLogoUrl = '', appName = '', coinbaseWalletPreference, chainRpcProviders, deepLinkPreference, flowNetwork, mobileExperience = 'in-app-browser', networkConfigurations = { cosmos: [], evm: [], solana: [], starknet: [] }, settings, skipMemo = false, walletConnectProjectId = '', walletConnectorsProp, walletUiUtils = undefined, walletBook, walletConnectPreferredChains, } = args;
+    if (!skipMemo && wallets.length > 0) {
+        return wallets;
+    }
+    const evmNetworkConfigs = (networkConfigurations === null || networkConfigurations === void 0 ? void 0 : networkConfigurations.evm) || [];
+    const solanaNetworkConfigs = (networkConfigurations === null || networkConfigurations === void 0 ? void 0 : networkConfigurations.solana) || [];
+    const cosmosNetworkConfigs = (networkConfigurations === null || networkConfigurations === void 0 ? void 0 : networkConfigurations.cosmos) || [];
+    const starknetNetworkConfigs = (networkConfigurations === null || networkConfigurations === void 0 ? void 0 : networkConfigurations.starknet) || [];
+    const apiProviders = getApiProviders.getApiProviders(getEnabledProviders(settings.providers));
+    const opts = {
+        apiProviders,
+        appLogoUrl,
+        appName,
+        chainRpcProviders,
+        coinbaseWalletPreference,
+        cosmosNetworks: cosmosNetworkConfigs,
+        deepLinkPreference,
+        evmNetworks: evmNetworkConfigs,
+        flowNetwork,
+        mobileExperience,
+        projectId: walletConnectProjectId,
+        settings,
+        solNetworks: solanaNetworkConfigs,
+        starknetNetworks: starknetNetworkConfigs,
+        walletBook,
+        walletConnectPreferredChains,
+        walletUiUtils: walletUiUtils || defaultWalletUiUtils,
+    };
+    const allWallets = walletConnectorsProp
+        .map((walletConnector) => walletConnector(opts))
+        .flat()
+        .map((wallet) => {
+        try {
+            // This may contain third party code so we must be ready for anything
+            return new wallet(opts);
+        }
+        catch (error) {
+            walletConnectorCore.logger.error(`Failed to construct wallet ${wallet.name}`, error);
+            return undefined;
+        }
+    })
+        .filter((wallet) => wallet === null || wallet === void 0 ? void 0 : wallet.filter())
+        .map((wallet) => wallet.getMobileOrInstalledWallet());
+    // Memoize the wallets
+    const filteredWallets = filterWalletsForPlatform(walletBook, allWallets);
+    wallets = applyLinksOverrides(walletBook, filteredWallets);
+    return wallets;
+};
+const applyLinksOverrides = (walletBook$1, wallets) => wallets.map((wallet) => {
+    const metadata = walletBook.getWalletBookWallet(walletBook$1, wallet.key, wallet.walletFallback);
+    if (metadata.switchNetworkOnlyFromWallet !== undefined) {
+        wallet.switchNetworkOnlyFromWallet = metadata.switchNetworkOnlyFromWallet;
+    }
+    return wallet;
+});
+const filterWalletsForPlatform = (walletBook$1, wallets) => wallets.filter((wallet) => {
+    const metadata = walletBook.getWalletBookWallet(walletBook$1, wallet.key, wallet.walletFallback);
+    if (wallet.isInstalledOnBrowser()) {
+        return true;
+    }
+    else if (walletConnectorCore.isEmbeddedConnector(wallet)) {
+        return true;
+    }
+    else if (metadata.showOnlyIfInstalled) {
+        return false;
+    }
+    else if (!utils.isMobile()) {
+        return true;
+    }
+    else {
+        return handleMobileWalletFilter(walletBook$1, wallet.key, metadata);
+    }
+});
+const handleMobileWalletFilter = (walletBook$1, walletKey, metadata) => {
+    if (!metadata.mobile)
+        return false;
+    /**
+     * WalletConnect provides a "universal" and "native" deep link. They recommend using
+     * the universal deep link over the native one due to UX differences, and our current
+     * implementation uses only universal. This means we need to filter for wallets that
+     * have a universal deep link available.
+     */
+    const hasWalletConnectLink = Boolean(metadata.mobile.universal) || Boolean(metadata.mobile.native);
+    const isWalletConnectWallet = metadata.walletConnect !== undefined;
+    if (utils.isIPad() || utils.isIPhone()) {
+        const hasIOSLink = Boolean(walletBook.getWalletLinks(walletBook$1, walletKey).ios);
+        return !isWalletConnectWallet
+            ? hasIOSLink
+            : hasIOSLink && hasWalletConnectLink;
+    }
+    else {
+        const hasAndroidLink = Boolean(walletBook.getWalletLinks(walletBook$1, walletKey).android);
+        return !isWalletConnectWallet
+            ? hasAndroidLink
+            : hasAndroidLink && hasWalletConnectLink;
+    }
+};
+const chainStringToChains = {
+    'eip155:1': ['ETH', 'EVM'],
+    'flow:mainnet': ['FLOW'],
+};
+const getSupportedChainsForWalletConnector = (walletBook$1, walletConnector) => {
+    var _a;
+    const metadata = walletBook.getWalletBookWallet(walletBook$1, walletConnector.key, walletConnector.walletFallback);
+    /**
+     * chains could contain multiple eth networks eg
+     *  "eip155:1",
+     *  "eip155:10",
+     *  "eip155:56",
+     *  "eip155:100",
+     *
+     * so we will use a set to ensure uniqueness
+     */
+    const chainSet = new Set();
+    const chainStringList = (_a = metadata.chains) !== null && _a !== void 0 ? _a : [];
+    chainStringList.forEach((chainString) => {
+        const chains = chainStringToChains[chainString];
+        chains === null || chains === void 0 ? void 0 : chains.forEach((chain) => {
+            chainSet.add(chain);
+        });
+    });
+    walletConnector.supportedChains.forEach((chain) => {
+        chainSet.add(chain);
+    });
+    return [...chainSet];
+};
+const getEnabledWallets = (props) => {
+    const supportedWallets = getSupportedWallets(props.getSupportedWalletOpts);
+    const allEnabledWallets = supportedWallets.filter((wallet) => props.enabledChains.some((chain) => getSupportedChainsForWalletConnector(props.getSupportedWalletOpts.walletBook, wallet).includes(chain)) || wallet.key === 'magiclink');
+    return allEnabledWallets;
+};
+// get list of providers enabled in the sense that we should have wallet connectors for them
+// note: magic and turnkey are considered enabled when a provider exists (for magic, a providerProjectId exists)
+const getEnabledProviders = (providers) => {
+    var _a;
+    return (_a = providers === null || providers === void 0 ? void 0 : providers.filter((provider) => Boolean(provider.enabledAt) ||
+        (provider.provider === sdkApiCore.ProviderEnum.MagicLink &&
+            Boolean(provider.providerProjectId)) ||
+        provider.provider === sdkApiCore.ProviderEnum.Turnkey)) !== null && _a !== void 0 ? _a : [];
+};
+
+exports.getEnabledProviders = getEnabledProviders;
+exports.getEnabledWallets = getEnabledWallets;
+exports.getSupportedChainsForWalletConnector = getSupportedChainsForWalletConnector;
+exports.getSupportedWallets = getSupportedWallets;

package/src/multi-wallet.d.ts

@@ -0,0 +1,11 @@
+import { Chain, WalletConnector } from '@dynamic-labs/wallet-connector-core';
+import { WalletBookSchema } from '@dynamic-labs/wallet-book';
+import { Provider } from '@dynamic-labs/sdk-api-core';
+import { GetSupportedWallets, GetSupportedWalletsOpts } from './types';
+export declare const getSupportedWallets: GetSupportedWallets;
+export declare const getSupportedChainsForWalletConnector: (walletBook: WalletBookSchema, walletConnector: WalletConnector) => Chain[];
+export declare const getEnabledWallets: (props: {
+    enabledChains: Chain[];
+    getSupportedWalletOpts: GetSupportedWalletsOpts;
+}) => WalletConnector[];
+export declare const getEnabledProviders: (providers: Provider[] | undefined) => Provider[];

package/src/multi-wallet.js

@@ -0,0 +1,171 @@
+'use client'
+import { logger, isEmbeddedConnector } from '@dynamic-labs/wallet-connector-core';
+import { getWalletBookWallet, getWalletLinks } from '@dynamic-labs/wallet-book';
+import { isMobile, isIPad, isIPhone } from '@dynamic-labs/utils';
+import { ProviderEnum } from '@dynamic-labs/sdk-api-core';
+import { getApiProviders } from './utils/getApiProviders.js';
+
+let wallets = [];
+const defaultWalletUiUtils = {
+    createPassword: () => {
+        throw Error('createPassword not implemented');
+    },
+    disabledConfirmationOnce: () => {
+        throw Error('disabledConfirmationOnce, not implemented');
+    },
+    enterPassword: () => {
+        throw Error('enterPassword not implemented');
+    },
+    sendTransaction: () => {
+        throw Error('requestSendTransactionConfirmation not implemented');
+    },
+    signMessage: () => {
+        throw Error('signMessage not implemented');
+    },
+    syncWallet: () => {
+        throw Error('syncWallet not implemented');
+    },
+};
+const getSupportedWallets = (args) => {
+    const { appLogoUrl = '', appName = '', coinbaseWalletPreference, chainRpcProviders, deepLinkPreference, flowNetwork, mobileExperience = 'in-app-browser', networkConfigurations = { cosmos: [], evm: [], solana: [], starknet: [] }, settings, skipMemo = false, walletConnectProjectId = '', walletConnectorsProp, walletUiUtils = undefined, walletBook, walletConnectPreferredChains, } = args;
+    if (!skipMemo && wallets.length > 0) {
+        return wallets;
+    }
+    const evmNetworkConfigs = (networkConfigurations === null || networkConfigurations === void 0 ? void 0 : networkConfigurations.evm) || [];
+    const solanaNetworkConfigs = (networkConfigurations === null || networkConfigurations === void 0 ? void 0 : networkConfigurations.solana) || [];
+    const cosmosNetworkConfigs = (networkConfigurations === null || networkConfigurations === void 0 ? void 0 : networkConfigurations.cosmos) || [];
+    const starknetNetworkConfigs = (networkConfigurations === null || networkConfigurations === void 0 ? void 0 : networkConfigurations.starknet) || [];
+    const apiProviders = getApiProviders(getEnabledProviders(settings.providers));
+    const opts = {
+        apiProviders,
+        appLogoUrl,
+        appName,
+        chainRpcProviders,
+        coinbaseWalletPreference,
+        cosmosNetworks: cosmosNetworkConfigs,
+        deepLinkPreference,
+        evmNetworks: evmNetworkConfigs,
+        flowNetwork,
+        mobileExperience,
+        projectId: walletConnectProjectId,
+        settings,
+        solNetworks: solanaNetworkConfigs,
+        starknetNetworks: starknetNetworkConfigs,
+        walletBook,
+        walletConnectPreferredChains,
+        walletUiUtils: walletUiUtils || defaultWalletUiUtils,
+    };
+    const allWallets = walletConnectorsProp
+        .map((walletConnector) => walletConnector(opts))
+        .flat()
+        .map((wallet) => {
+        try {
+            // This may contain third party code so we must be ready for anything
+            return new wallet(opts);
+        }
+        catch (error) {
+            logger.error(`Failed to construct wallet ${wallet.name}`, error);
+            return undefined;
+        }
+    })
+        .filter((wallet) => wallet === null || wallet === void 0 ? void 0 : wallet.filter())
+        .map((wallet) => wallet.getMobileOrInstalledWallet());
+    // Memoize the wallets
+    const filteredWallets = filterWalletsForPlatform(walletBook, allWallets);
+    wallets = applyLinksOverrides(walletBook, filteredWallets);
+    return wallets;
+};
+const applyLinksOverrides = (walletBook, wallets) => wallets.map((wallet) => {
+    const metadata = getWalletBookWallet(walletBook, wallet.key, wallet.walletFallback);
+    if (metadata.switchNetworkOnlyFromWallet !== undefined) {
+        wallet.switchNetworkOnlyFromWallet = metadata.switchNetworkOnlyFromWallet;
+    }
+    return wallet;
+});
+const filterWalletsForPlatform = (walletBook, wallets) => wallets.filter((wallet) => {
+    const metadata = getWalletBookWallet(walletBook, wallet.key, wallet.walletFallback);
+    if (wallet.isInstalledOnBrowser()) {
+        return true;
+    }
+    else if (isEmbeddedConnector(wallet)) {
+        return true;
+    }
+    else if (metadata.showOnlyIfInstalled) {
+        return false;
+    }
+    else if (!isMobile()) {
+        return true;
+    }
+    else {
+        return handleMobileWalletFilter(walletBook, wallet.key, metadata);
+    }
+});
+const handleMobileWalletFilter = (walletBook, walletKey, metadata) => {
+    if (!metadata.mobile)
+        return false;
+    /**
+     * WalletConnect provides a "universal" and "native" deep link. They recommend using
+     * the universal deep link over the native one due to UX differences, and our current
+     * implementation uses only universal. This means we need to filter for wallets that
+     * have a universal deep link available.
+     */
+    const hasWalletConnectLink = Boolean(metadata.mobile.universal) || Boolean(metadata.mobile.native);
+    const isWalletConnectWallet = metadata.walletConnect !== undefined;
+    if (isIPad() || isIPhone()) {
+        const hasIOSLink = Boolean(getWalletLinks(walletBook, walletKey).ios);
+        return !isWalletConnectWallet
+            ? hasIOSLink
+            : hasIOSLink && hasWalletConnectLink;
+    }
+    else {
+        const hasAndroidLink = Boolean(getWalletLinks(walletBook, walletKey).android);
+        return !isWalletConnectWallet
+            ? hasAndroidLink
+            : hasAndroidLink && hasWalletConnectLink;
+    }
+};
+const chainStringToChains = {
+    'eip155:1': ['ETH', 'EVM'],
+    'flow:mainnet': ['FLOW'],
+};
+const getSupportedChainsForWalletConnector = (walletBook, walletConnector) => {
+    var _a;
+    const metadata = getWalletBookWallet(walletBook, walletConnector.key, walletConnector.walletFallback);
+    /**
+     * chains could contain multiple eth networks eg
+     *  "eip155:1",
+     *  "eip155:10",
+     *  "eip155:56",
+     *  "eip155:100",
+     *
+     * so we will use a set to ensure uniqueness
+     */
+    const chainSet = new Set();
+    const chainStringList = (_a = metadata.chains) !== null && _a !== void 0 ? _a : [];
+    chainStringList.forEach((chainString) => {
+        const chains = chainStringToChains[chainString];
+        chains === null || chains === void 0 ? void 0 : chains.forEach((chain) => {
+            chainSet.add(chain);
+        });
+    });
+    walletConnector.supportedChains.forEach((chain) => {
+        chainSet.add(chain);
+    });
+    return [...chainSet];
+};
+const getEnabledWallets = (props) => {
+    const supportedWallets = getSupportedWallets(props.getSupportedWalletOpts);
+    const allEnabledWallets = supportedWallets.filter((wallet) => props.enabledChains.some((chain) => getSupportedChainsForWalletConnector(props.getSupportedWalletOpts.walletBook, wallet).includes(chain)) || wallet.key === 'magiclink');
+    return allEnabledWallets;
+};
+// get list of providers enabled in the sense that we should have wallet connectors for them
+// note: magic and turnkey are considered enabled when a provider exists (for magic, a providerProjectId exists)
+const getEnabledProviders = (providers) => {
+    var _a;
+    return (_a = providers === null || providers === void 0 ? void 0 : providers.filter((provider) => Boolean(provider.enabledAt) ||
+        (provider.provider === ProviderEnum.MagicLink &&
+            Boolean(provider.providerProjectId)) ||
+        provider.provider === ProviderEnum.Turnkey)) !== null && _a !== void 0 ? _a : [];
+};
+
+export { getEnabledProviders, getEnabledWallets, getSupportedChainsForWalletConnector, getSupportedWallets };

package/src/types.d.ts

@@ -0,0 +1,34 @@
+import type { ProjectSettings } from '@dynamic-labs/sdk-api-core';
+import { WalletConnector, Chain, WalletConnectorsMethod, DeepLinkVariant } from '@dynamic-labs/wallet-connector-core';
+import { type NetworkConfigurationMap, type WalletUiUtils, type CoinbaseWalletPreference, type MobileExperience } from '@dynamic-labs/types';
+import { IChainRpcProviders } from '@dynamic-labs/rpc-providers';
+import { WalletBookSchema } from '@dynamic-labs/wallet-book';
+export type GetSupportedWalletsOpts = {
+    appLogoUrl?: string;
+    appName?: string;
+    coinbaseWalletPreference?: CoinbaseWalletPreference;
+    chainRpcProviders: IChainRpcProviders;
+    deepLinkPreference?: DeepLinkVariant;
+    flowNetwork?: 'mainnet' | 'testnet';
+    mobileExperience?: MobileExperience;
+    networkConfigurations?: NetworkConfigurationMap;
+    settings: ProjectSettings;
+    skipMemo?: boolean;
+    walletBook: WalletBookSchema;
+    walletConnectProjectId?: string;
+    walletConnectorsProp: WalletConnectorsMethod[];
+    walletConnectPreferredChains?: `eip155:${number}`[];
+    walletUiUtils?: WalletUiUtils<WalletConnector>;
+};
+export type GetSupportedWallets = (opts: GetSupportedWalletsOpts) => WalletConnector[];
+export type ChainInfo = {
+    blockchainName: string;
+    displayName: string;
+    name: string;
+    symbol: Chain;
+};
+export type ChainWihtIcon = {
+    icon?: string;
+    name: string | undefined;
+    symbol: Chain | undefined;
+};

package/src/utils/getApiProviders.cjs

@@ -0,0 +1,16 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var sdkApiCore = require('@dynamic-labs/sdk-api-core');
+
+const getApiProviders = (providers) => Object.values(sdkApiCore.ProviderEnum).reduce((acc, provider) => {
+    const foundProvider = providers.find((providerSetting) => providerSetting.provider === provider);
+    if (foundProvider) {
+        acc[provider] = foundProvider;
+    }
+    return acc;
+}, {});
+
+exports.getApiProviders = getApiProviders;

package/src/utils/getApiProviders.d.ts

@@ -0,0 +1,28 @@
+import { Provider, ProviderEnum } from '@dynamic-labs/sdk-api-core';
+export declare const getApiProviders: (providers: Provider[]) => {
+    emailOnly?: Provider | undefined;
+    magicLink?: Provider | undefined;
+    apple?: Provider | undefined;
+    bitbucket?: Provider | undefined;
+    coinbasesocial?: Provider | undefined;
+    discord?: Provider | undefined;
+    facebook?: Provider | undefined;
+    farcaster?: Provider | undefined;
+    github?: Provider | undefined;
+    gitlab?: Provider | undefined;
+    google?: Provider | undefined;
+    instagram?: Provider | undefined;
+    linkedin?: Provider | undefined;
+    microsoft?: Provider | undefined;
+    twitch?: Provider | undefined;
+    twitter?: Provider | undefined;
+    blocto?: Provider | undefined;
+    banxa?: Provider | undefined;
+    dynamic?: Provider | undefined;
+    alchemy?: Provider | undefined;
+    zerodev?: Provider | undefined;
+    telegram?: Provider | undefined;
+    turnkey?: Provider | undefined;
+    coinbaseWaas?: Provider | undefined;
+    sms?: Provider | undefined;
+};

package/src/utils/getApiProviders.js

@@ -0,0 +1,12 @@
+'use client'
+import { ProviderEnum } from '@dynamic-labs/sdk-api-core';
+
+const getApiProviders = (providers) => Object.values(ProviderEnum).reduce((acc, provider) => {
+    const foundProvider = providers.find((providerSetting) => providerSetting.provider === provider);
+    if (foundProvider) {
+        acc[provider] = foundProvider;
+    }
+    return acc;
+}, {});
+
+export { getApiProviders };

package/src/utils/message.cjs

@@ -0,0 +1,50 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var walletConnectorCore = require('@dynamic-labs/wallet-connector-core');
+
+const generateMessageToSign = ({ blockchain, domain, chainId, nonce, uri, publicKey, issuedAt = new Date().toISOString(), statement, requestId, resources, }) => {
+    var _a, _b;
+    if (blockchain === 'STARK') {
+        /**
+         * Starknet requires the strings to be 31 chars long
+         * Nonce - we need to keep full size for nonce verification on the backend (the backend shortens it to 31 chars)
+         * Domain - we need to shorten the domain to 31 chars
+         */
+        return JSON.stringify({
+            domain: domain.substring(0, 31),
+            nonce,
+        });
+    }
+    const blockchainName = (_b = (_a = walletConnectorCore.getChainInfo(blockchain)) === null || _a === void 0 ? void 0 : _a.blockchainName) !== null && _b !== void 0 ? _b : 'Ethereum';
+    // This format follows the sign-in with ethereum (SIWE) standard,
+    // but we are using it also for non-ethereum wallets for now (eg. Solana)
+    // for more context on format and fields, please see:
+    // https://docs.login.xyz/general-information/siwe-overview/eip-4361
+    const header = `${domain} wants you to sign in with your ${blockchainName} account:`;
+    const prefix = [header, publicKey].join('\n');
+    // If there is a statement, we want to add a gap between the prefix and the statement
+    // two times '\n', first to move statement to next line and second to add a gap between prefix and statement
+    const prefixWithStatementGap = statement ? '\n\n' : '\n';
+    const prefixWithStatement = `${[prefix, statement].join(prefixWithStatementGap)}\n`;
+    const suffixFields = [];
+    suffixFields.push(`URI: ${uri}`);
+    suffixFields.push('Version: 1');
+    if (chainId) {
+        suffixFields.push(`Chain ID: ${chainId}`);
+    }
+    suffixFields.push(`Nonce: ${nonce}`);
+    suffixFields.push(`Issued At: ${issuedAt}`);
+    if (requestId) {
+        suffixFields.push(`Request ID: ${requestId}`);
+    }
+    if (resources === null || resources === void 0 ? void 0 : resources.length) {
+        suffixFields.push(`Resources:${resources.map((resource) => '\n- ' + resource).join()}`);
+    }
+    const suffix = suffixFields.join('\n');
+    return [prefixWithStatement, suffix].join('\n');
+};
+
+exports.generateMessageToSign = generateMessageToSign;

package/src/utils/message.d.ts

@@ -0,0 +1,14 @@
+import { Chain } from '@dynamic-labs/wallet-connector-core';
+export interface MessageParameters {
+    blockchain: Chain;
+    chainId?: number | string;
+    domain: string;
+    issuedAt?: string;
+    nonce: string;
+    publicKey: string;
+    requestId?: string;
+    resources?: string[];
+    statement?: string;
+    uri: string;
+}
+export declare const generateMessageToSign: ({ blockchain, domain, chainId, nonce, uri, publicKey, issuedAt, statement, requestId, resources, }: MessageParameters) => string;

package/src/utils/message.js

@@ -0,0 +1,46 @@
+'use client'
+import { getChainInfo } from '@dynamic-labs/wallet-connector-core';
+
+const generateMessageToSign = ({ blockchain, domain, chainId, nonce, uri, publicKey, issuedAt = new Date().toISOString(), statement, requestId, resources, }) => {
+    var _a, _b;
+    if (blockchain === 'STARK') {
+        /**
+         * Starknet requires the strings to be 31 chars long
+         * Nonce - we need to keep full size for nonce verification on the backend (the backend shortens it to 31 chars)
+         * Domain - we need to shorten the domain to 31 chars
+         */
+        return JSON.stringify({
+            domain: domain.substring(0, 31),
+            nonce,
+        });
+    }
+    const blockchainName = (_b = (_a = getChainInfo(blockchain)) === null || _a === void 0 ? void 0 : _a.blockchainName) !== null && _b !== void 0 ? _b : 'Ethereum';
+    // This format follows the sign-in with ethereum (SIWE) standard,
+    // but we are using it also for non-ethereum wallets for now (eg. Solana)
+    // for more context on format and fields, please see:
+    // https://docs.login.xyz/general-information/siwe-overview/eip-4361
+    const header = `${domain} wants you to sign in with your ${blockchainName} account:`;
+    const prefix = [header, publicKey].join('\n');
+    // If there is a statement, we want to add a gap between the prefix and the statement
+    // two times '\n', first to move statement to next line and second to add a gap between prefix and statement
+    const prefixWithStatementGap = statement ? '\n\n' : '\n';
+    const prefixWithStatement = `${[prefix, statement].join(prefixWithStatementGap)}\n`;
+    const suffixFields = [];
+    suffixFields.push(`URI: ${uri}`);
+    suffixFields.push('Version: 1');
+    if (chainId) {
+        suffixFields.push(`Chain ID: ${chainId}`);
+    }
+    suffixFields.push(`Nonce: ${nonce}`);
+    suffixFields.push(`Issued At: ${issuedAt}`);
+    if (requestId) {
+        suffixFields.push(`Request ID: ${requestId}`);
+    }
+    if (resources === null || resources === void 0 ? void 0 : resources.length) {
+        suffixFields.push(`Resources:${resources.map((resource) => '\n- ' + resource).join()}`);
+    }
+    const suffix = suffixFields.join('\n');
+    return [prefixWithStatement, suffix].join('\n');
+};
+
+export { generateMessageToSign };