@dynamic-labs-sdk/wallet-connect 0.1.1 → 0.2.3

package/core.esm.js

@@ -1,609 +0,0 @@
-import { assertPackageVersion } from '@dynamic-labs-sdk/assert-package-version';
-import { i as isWalletConnectWalletProvider, n as name, v as version } from './isWalletConnectWalletProvider.esm.js';
-import { getWalletAccounts, verifyWalletAccount } from '@dynamic-labs-sdk/client';
-import { assertDefined, filterDuplicates, formatWalletAccountId, createStorageKeySchema, getCore, createRuntimeServiceAccessKey, getWalletProviderRegistry, WalletProviderPriority, splitWalletProviderKey, updateWalletProviderKeysForVerifiedCredentials, setUnverifiedWalletAccounts, createVisit, emitWalletAccountsChangedEvent, waitForProjectSettings, getWalletProviders, verifySignInMessage, updateAuthFromVerifyResponse } from '@dynamic-labs-sdk/client/core';
-import * as z from 'zod/mini';
-import { SDK_ERRORS, formatMessage } from '@walletconnect/utils';
-import SignClient from '@walletconnect/sign-client';
-import { WalletProviderEnum } from '@dynamic-labs/sdk-api-core';
-
-function _extends() {
-    _extends = Object.assign || function assign(target) {
-        for(var i = 1; i < arguments.length; i++){
-            var source = arguments[i];
-            for(var key in source)if (Object.prototype.hasOwnProperty.call(source, key)) target[key] = source[key];
-        }
-        return target;
-    };
-    return _extends.apply(this, arguments);
-}
-
-/**
- * An account in WalletConnect follows the CAIP-10 standard
- * and is formatted as follows:
- *
- * `<namespace>:<chain>:<address>`
- *
- * Where:
- * - `<namespace>` is the namespace key (e.g. "eip155")
- * - `<chain>` is what we refer to as a network ID (e.g. "1")
- * - `<address>` is the address of the account (e.g. "0x1234567890")
- *
- * See docs: https://github.com/ChainAgnostic/CAIPs/blob/main/CAIPs/caip-10.md
- *
- * @returns An object with the address, namespace key, and network id
- */ const splitCaip10Token = (caip10Token)=>{
-    const [namespaceKey, networkId, address] = caip10Token.split(':');
-    return {
-        address,
-        namespaceKey,
-        networkId
-    };
-};
-
-const createWalletAccountsForWalletConnectWalletProvider = ({ walletProvider })=>{
-    /**
-   * Since each session can have multiple namespaces, we need to find the namespace
-   * that corresponds to this specific wallet provider.
-   *
-   * A WalletConnect namespace is the equivalent of what we refer to as a chain in the SDK,
-   * and they have attributed to them the methods, events and networks that are expected
-   * to be supported by the wallet application, as well as which accounts are connected.
-   */ const namespace = walletProvider.session.namespaces[walletProvider.namespaceKey];
-    assertDefined(namespace, `Namespace key ${walletProvider.namespaceKey} of wallet provider ${walletProvider.key} not found in its session ${walletProvider.topic}`);
-    const accountAddresses = filterDuplicates(namespace.accounts.map((account)=>splitCaip10Token(account).address));
-    var _walletProvider_formatWalletAddress;
-    const formatAddress = (_walletProvider_formatWalletAddress = walletProvider.formatWalletAddress) != null ? _walletProvider_formatWalletAddress : ({ address })=>address;
-    return accountAddresses.map((address)=>({
-            address: formatAddress({
-                address
-            }),
-            chain: walletProvider.chain,
-            id: formatWalletAccountId({
-                address,
-                chain: walletProvider.chain,
-                walletProviderKey: walletProvider.key
-            }),
-            lastSelectedAt: null,
-            verifiedCredentialId: null,
-            walletProviderKey: walletProvider.key
-        }));
-};
-
-const sessionTopicsStorageKeySchema = createStorageKeySchema({
-    key: 'sessionTopics',
-    schema: z.record(/**
-     * The session topic that identifies this session.
-     */ z.string(), /**
-     * The session data.
-     */ z.object({
-        /**
-       * Whether this session's wallet accounts should be added to the dynamic's wallet accounts.
-       * When a customer connects a session with addToDynamicWalletAccounts set to false, the resulting session
-       * should not produce wallet accounts to be added to the dynamic's wallet accounts.
-       * When that happens, we cannot clear them until the page is refreshed or the wallet account is removed
-       * by the external owner by calling removeWalletAccount.
-       */ shouldAddToDynamicWalletAccounts: z.boolean()
-    }))
-});
-
-/**
- * Sets the session topics data.
- *
- * Read more about it in the sessionTopicsData.types.ts file.
- *
- * @param update - The function to update the session topics data.
- * @param client - The client instance.
- */ const setSessionTopicsData = async ({ update }, client)=>{
-    const { storage } = getCore(client);
-    const sessionTopicsData = await storage.getItem(sessionTopicsStorageKeySchema);
-    const newSessionTopicsData = update(sessionTopicsData != null ? sessionTopicsData : {});
-    if (Object.keys(newSessionTopicsData).length === 0) {
-        return storage.removeItem(sessionTopicsStorageKeySchema);
-    }
-    return storage.setItem(sessionTopicsStorageKeySchema, newSessionTopicsData);
-};
-
-/**
- * Gets the session topics data.
- *
- * Read more about it in the sessionTopicsData.types.ts file.
- * @param client - The client instance.
- */ const getSessionTopicsData = async (client)=>{
-    const { storage } = getCore(client);
-    const sessionTopicsData = await storage.getItem(sessionTopicsStorageKeySchema);
-    return sessionTopicsData != null ? sessionTopicsData : {};
-};
-
-const createSignClient = async (client)=>{
-    var _client_projectSettings_sdk_walletConnect, _core_metadata, _core_metadata1;
-    const core = getCore(client);
-    assertDefined(client.projectSettings, 'Project settings not available');
-    const generalSettings = client.projectSettings.general;
-    assertDefined(generalSettings.displayName, 'Please configure an app name in dashboard to use WalletConnect');
-    const projectId = (_client_projectSettings_sdk_walletConnect = client.projectSettings.sdk.walletConnect) == null ? void 0 : _client_projectSettings_sdk_walletConnect.projectId;
-    assertDefined(projectId, 'Please configure a project ID for WalletConnect in dashboard');
-    const customStoragePrefix = `dynamic_${core.environmentId}_walletconnect`;
-    var _core_metadata_name;
-    const displayName = (_core_metadata_name = (_core_metadata = core.metadata) == null ? void 0 : _core_metadata.name) != null ? _core_metadata_name : generalSettings.displayName;
-    var _core_metadata_iconUrl;
-    const appLogo = (_core_metadata_iconUrl = (_core_metadata1 = core.metadata) == null ? void 0 : _core_metadata1.iconUrl) != null ? _core_metadata_iconUrl : generalSettings.appLogo;
-    return SignClient.init({
-        customStoragePrefix,
-        metadata: {
-            description: '',
-            icons: appLogo ? [
-                appLogo
-            ] : [],
-            name: displayName,
-            url: ''
-        },
-        projectId
-    });
-};
-
-const getSignClient = createRuntimeServiceAccessKey('walletConnectSignClient', (client)=>createSignClient(client));
-
-const createNamespaceRegistry = ()=>{
-    const walletProviderBuilderMap = new Map();
-    return {
-        getWalletProviderBuilder: (key)=>walletProviderBuilderMap.get(key),
-        registerNamespace: ({ createWalletProviderFromSession, namespaceKey })=>{
-            walletProviderBuilderMap.set(namespaceKey, createWalletProviderFromSession);
-        }
-    };
-};
-
-const getNamespaceRegistry = createRuntimeServiceAccessKey('walletConnectNamespaceRegistry', createNamespaceRegistry);
-
-const addMissingWalletProvidersForSessions = async ({ sessions, allowOverridingWalletProviders }, client)=>{
-    const namespaceRegistry = getNamespaceRegistry(client);
-    const walletProviderRegistry = getWalletProviderRegistry(client);
-    const sessionTopicsData = await getSessionTopicsData(client);
-    const currentWalletAccounts = getWalletAccounts(client);
-    // Sort so the oldest sessions are first and the newer sessions will
-    // override the older ones' wallet accounts (if there is any overlap).
-    sessions.sort((sessionA, sessionB)=>sessionA.expiry - sessionB.expiry);
-    /**
-   * All the WC wallet providers that are currently registered
-   */ const currentWalletProviders = walletProviderRegistry.listProviders().filter(isWalletConnectWalletProvider);
-    /**
-   * Keep record on which walletProviders are tied to active sessions
-   */ const walletProvidersWithActiveSession = [];
-    /**
-   * Maps the ID of the created wallet accounts to the wallet accounts themselves.
-   */ const createdWalletAccounts = {};
-    /**
-   * Keep record on which wallet account IDs were not in the current wallet accounts
-   * and are therefore brand new.
-   */ const brandNewWalletAccounts = new Set();
-    /**
-   * Keep record on which wallet account IDs already exist but will have
-   * their wallet provider keys overridden to use the new WC wallet provider key.
-   *
-   * This will only ever be the case for unverified wallet accounts, however. That is
-   * because verified wallets will already override the wallet provider key on the verification
-   * step, which happens at the call to verifyWalletConnectAuths, which happens before this function.
-   */ const unverifiedWalletAccountsToOverride = new Set();
-    for (const session of sessions){
-        const namespaceKeys = Object.keys(session.namespaces);
-        for (const namespaceKey of namespaceKeys){
-            const existingWalletProvider = currentWalletProviders.find((walletProvider)=>walletProvider.namespaceKey === namespaceKey && walletProvider.topic === session.topic);
-            if (existingWalletProvider) {
-                walletProvidersWithActiveSession.push(existingWalletProvider);
-                continue;
-            }
-            const walletProviderBuilder = namespaceRegistry.getWalletProviderBuilder(namespaceKey);
-            /**
-       * There being no wallet provider builder for this namespace simply means the customer
-       * didn't add an extension for the corresponding chain.
-       * For instance, if we get a namespace for Solana but only have an Evm extension,
-       * the solana namespace would fall here. No need to throw.
-       */ if (!walletProviderBuilder) {
-                continue;
-            }
-            const walletProvider = await walletProviderBuilder({
-                session
-            }, client);
-            walletProviderRegistry.register({
-                priority: WalletProviderPriority.WALLET_SDK,
-                walletProvider
-            });
-            walletProvidersWithActiveSession.push(walletProvider);
-            const sessionData = sessionTopicsData[session.topic];
-            if (!sessionData.shouldAddToDynamicWalletAccounts) {
-                continue;
-            }
-            const namespaceWalletAccounts = createWalletAccountsForWalletConnectWalletProvider({
-                walletProvider
-            });
-            if (namespaceWalletAccounts.length === 0) {
-                continue;
-            }
-            for (const createdWalletAccount of namespaceWalletAccounts){
-                const isBrandNew = !currentWalletAccounts.some((existingAccount)=>existingAccount.id === createdWalletAccount.id);
-                if (isBrandNew) {
-                    createdWalletAccounts[createdWalletAccount.id] = createdWalletAccount;
-                    brandNewWalletAccounts.add(createdWalletAccount.id);
-                    continue;
-                }
-                const existingAccount = currentWalletAccounts.find((existingAccount)=>existingAccount.id === createdWalletAccount.id);
-                const isOverrideCandidate = existingAccount && existingAccount.walletProviderKey !== createdWalletAccount.walletProviderKey;
-                if (!isOverrideCandidate) {
-                    continue;
-                }
-                // If overriding wallet providers is not allowed, we can still override
-                // as long as the wallet account being overridden is also a wallet connect wallet account.
-                const existingWalletIsWalletConnect = splitWalletProviderKey(existingAccount.walletProviderKey).walletProviderType === WalletProviderEnum.WalletConnect;
-                if (allowOverridingWalletProviders || existingWalletIsWalletConnect) {
-                    createdWalletAccounts[createdWalletAccount.id] = createdWalletAccount;
-                    if (existingAccount.verifiedCredentialId) {
-                        /**
-             * A verified wallet account only arrives here when its wallet provider key is lacking the suffix,
-             * which should be the sessionTopic. So we just need to add its entry to the verifiedCredentialId map.
-             */ updateWalletProviderKeysForVerifiedCredentials({
-                            keysToUpdate: {
-                                [existingAccount.verifiedCredentialId]: walletProvider.key
-                            }
-                        }, client);
-                    } else {
-                        unverifiedWalletAccountsToOverride.add(createdWalletAccount.id);
-                    }
-                }
-            }
-        }
-    }
-    if (unverifiedWalletAccountsToOverride.size === 0 && brandNewWalletAccounts.size === 0) {
-        return {
-            walletProvidersWithActiveSession
-        };
-    }
-    setUnverifiedWalletAccounts({
-        unverifiedWalletAccountsToUpdate: Object.values(createdWalletAccounts)
-    }, client);
-    if (brandNewWalletAccounts.size > 0) {
-        for (const walletAccountId of brandNewWalletAccounts){
-            void createVisit({
-                walletAccount: createdWalletAccounts[walletAccountId]
-            }, client);
-        }
-    }
-    emitWalletAccountsChangedEvent(client);
-    return {
-        walletProvidersWithActiveSession
-    };
-};
-
-const doSyncSessionsToWalletProviders = async ({ allowOverridingWalletProviders }, client)=>{
-    await waitForProjectSettings(client);
-    const signClient = await getSignClient(client);
-    const walletProviderRegistry = getWalletProviderRegistry(client);
-    const sessionTopicsData = await getSessionTopicsData(client);
-    const sessions = signClient.session.getAll().filter((session)=>{
-        if (sessionTopicsData[session.topic]) {
-            return true;
-        }
-        // If we don't have data for this session, it is corrupted and we need to disconnect
-        void signClient.disconnect({
-            reason: SDK_ERRORS.USER_DISCONNECTED,
-            topic: session.topic
-        });
-        return false;
-    });
-    /**
-   * All the WC wallet providers that are currently registered
-   */ const currentWalletProviders = walletProviderRegistry.listProviders().filter(isWalletConnectWalletProvider);
-    // Step 1: remove wallet providers whose sessions have been cleared
-    for (const walletProvider of currentWalletProviders){
-        const hasSession = sessions.some((session)=>session.topic === walletProvider.topic && walletProvider.namespaceKey in session.namespaces);
-        if (!hasSession) {
-            walletProviderRegistry.unregister(walletProvider.key);
-        }
-    }
-    // Step 2: add wallet providers that are missing for current sessions
-    const { walletProvidersWithActiveSession: updatedWalletProviders } = await addMissingWalletProvidersForSessions({
-        allowOverridingWalletProviders,
-        sessions
-    }, client);
-    // Step 3: identify which sessions have no more associated wallet accounts for clean up
-    const currentWalletAccounts = getWalletAccounts(client);
-    /**
-   * Maps which sessions have wallet accounts associated with them
-   */ const sessionTopicHasWalletAccountMap = new Map();
-    for (const walletProvider of updatedWalletProviders){
-        const sessionTopic = walletProvider.topic;
-        if (!sessionTopicHasWalletAccountMap.has(sessionTopic)) {
-            sessionTopicHasWalletAccountMap.set(sessionTopic, false);
-        }
-        // Early return if we already know this session has wallet accounts associated with it
-        if (sessionTopicHasWalletAccountMap.get(sessionTopic)) {
-            continue;
-        }
-        const walletProviderWalletAccounts = currentWalletAccounts.filter((walletAccount)=>walletAccount.walletProviderKey === walletProvider.key);
-        if (walletProviderWalletAccounts.length > 0) {
-            sessionTopicHasWalletAccountMap.set(sessionTopic, true);
-        }
-    }
-    // Step 4: kill sessions and their wallet providers if they have no more wallet accounts
-    // Ignore sessions that are NOT marked as shouldAddToDynamicWalletAccounts
-    for (const [sessionTopic, hasWalletAccount] of sessionTopicHasWalletAccountMap){
-        if (hasWalletAccount || !sessionTopicsData[sessionTopic].shouldAddToDynamicWalletAccounts) {
-            continue;
-        }
-        const session = sessions.find((session)=>session.topic === sessionTopic);
-        if (session) {
-            void signClient.disconnect({
-                reason: SDK_ERRORS.USER_DISCONNECTED,
-                topic: session.topic
-            });
-        }
-        for (const walletProvider of updatedWalletProviders){
-            if (walletProvider.topic === sessionTopic) {
-                walletProviderRegistry.unregister(walletProvider.key);
-            }
-        }
-    }
-    // Step 5: compile which session topics are active to clean up stale session data
-    // We do session.getAll() again here to catch any sessions that might have been disconnected from other steps or even externally.
-    const activeSessionTopics = new Set(signClient.session.getAll().map((session)=>session.topic));
-    await setSessionTopicsData({
-        update: (sessionTopicsData)=>{
-            return Object.fromEntries(Object.entries(sessionTopicsData).filter(([topic])=>activeSessionTopics.has(topic)));
-        }
-    }, client);
-};
-const syncSessionsToWalletProviders = async ({ debounceTime = 0, allowOverridingWalletProviders }, client)=>{
-    const core = getCore(client);
-    // This is called on adding WC extensions, which could be many in quick succession, so let's debounce
-    // the syncSessionsToWalletProviders call to ensure it only runs once and avoid race conditions.
-    return core.debouncedMutex({
-        callback: async ()=>doSyncSessionsToWalletProviders({
-                allowOverridingWalletProviders
-            }, client),
-        debounceTime,
-        lockKey: 'wallet-connect-sync-sessions-to-wallet-providers'
-    });
-};
-
-/**
- * This is a lower level function that is used to connect a WalletConnect session to the Dynamic SDK.
- * It will generate the wallet providers and wallet accounts for all accounts in the session.
- *
- * @param session - The session object created from the approval promise of the signClient.connect method.
- * @param addToDynamicWalletAccounts - Whether to add the wallet accounts to the dynamic's wallet accounts.
- * @param client - The Dynamic client instance. Only required when using multiple Dynamic clients.
- * @returns The wallet accounts.
- */ const importWalletConnectSession = async ({ addToDynamicWalletAccounts = true, session }, client)=>{
-    /**
-   * You would normally get the session from the signClient.connect method. It takes the optionalNamespaces as an argument.
-   *
-   * Each chain should build its own "connectWithWalletConnect<chain-name>" function.
-   * Understand how to build the optionalNamespaces object:
-   *
-   * The namespace configurations are used at the time a wallet application receives the connection URI.
-   * It will use the configurations we supply to understand which methods, events and networks it should provide.
-   *
-   * The wallet application will then accept the connection request and, in the session`object, provide its own namespace object
-   * in return, which will contain the methods, events and networks it does in fact support, as well as
-   * which accounts are available.
-   *
-   * WalletConnect expects namespaces defined in the following format:
-   * ```typescript
-   * {
-   *   <namespaceKey>: {
-   *     "accounts": ["<account1>", "<account2>", "<account3>", ...],
-   *     "events": ["accountsChanged", "chainChanged", "disconnected"],
-   *     "methods": ["personal_sign", "eth_sendTransaction", "eth_accounts", ...],
-   *     "chains": ["<chain1>", "<chain2>", "<chain3>", ...]
-   *   },
-   *   ...
-   * }
-   * ```
-   *
-   * Where each account is a CAIP-10 formatted string, for example: "eip155:1:0x1234567890"
-   * — see docs: https://chainagnostic.org/CAIPs/caip-10
-   *
-   * Where each chain is a CAIP-2 formatted string, for example: "eip155:1"
-   * — see docs: https://chainagnostic.org/CAIPs/caip-2
-   */ const sessionData = {
-        shouldAddToDynamicWalletAccounts: addToDynamicWalletAccounts
-    };
-    await setSessionTopicsData({
-        update: (sessionTopicsData)=>_extends({}, sessionTopicsData, {
-                [session.topic]: sessionData
-            })
-    }, client);
-    /**
-   * Once the connection is established, we ensure that all active connections (aka sessions)
-   * are synced to our WalletConnect wallet providers.
-   * Each session can be uniquely identified by its topic (a random string generated by WalletConnect).
-   *
-   * Each session may have multiple wallet providers, one for each namespace (aka our SDK chains)
-   */ await syncSessionsToWalletProviders({
-        allowOverridingWalletProviders: true
-    }, client);
-    const sessionWalletProviders = getWalletProviders(client).filter(isWalletConnectWalletProvider).filter((provider)=>provider.topic === session.topic);
-    /**
-   * Upon setting the session data to NOT externally owned, syncSessionsToWalletProviders will have
-   * already created the wallet accounts for each of this session's wallet providers — so all we need
-   * to do is retrieve them.
-   */ if (addToDynamicWalletAccounts) {
-        const sessionWalletProviderKeys = sessionWalletProviders.map((provider)=>provider.key);
-        const walletAccounts = getWalletAccounts(client).filter((walletAccount)=>sessionWalletProviderKeys.includes(walletAccount.walletProviderKey));
-        return {
-            walletAccounts
-        };
-    }
-    /**
-   * If we didn't add the wallet accounts to the dynamic's wallet accounts,
-   * we never created them at all, so we need to create them now and provide
-   * them to the caller, which will become their [external] owner.
-   */ const walletAccounts = sessionWalletProviders.map((walletProvider)=>createWalletAccountsForWalletConnectWalletProvider({
-            walletProvider
-        })).flat();
-    return {
-        walletAccounts
-    };
-};
-
-const getAddressFromIss = (iss)=>iss.split(':')[4];
-const verifyWalletConnectAuths = async ({ auths, chain, walletDisplayName }, client)=>{
-    /**
-   * The only differences between each auth object will be the signature (auth.s.s)
-   * and the iss (auth.p.iss).
-   *
-   * The iss is comprised of 2 WC fields that are irrelevant to us and then the CAIP-10 token
-   * of the address, where the first 2 fields are also split by the ":" character.
-   *
-   * Usually, there will be multiple auths if the wallet app bundles signatures for multiple
-   * networks at once, so the only field that will change among auth iss will be the networkId under iss.
-   */ const visitedAddresses = new Set();
-    const authsFilteredByAddress = auths.filter((auth)=>{
-        const address = getAddressFromIss(auth.p.iss);
-        if (!address || visitedAddresses.has(address)) {
-            return false;
-        }
-        visitedAddresses.add(address);
-        return true;
-    });
-    let lastResponse = undefined;
-    /**
-   * WalletConnect's auth object is what they call a "Cacao" object, with data on the SIWE message
-   * and the signature itself.
-   * By consulting how they implemented their "validateSignedCacao" function,
-   * we are able to reconstruct the original message which can be used to verify the signature
-   * in our backend.
-   */ for (const auth of authsFilteredByAddress){
-        const publicWalletAddress = getAddressFromIss(auth.p.iss);
-        assertDefined(publicWalletAddress, `Unable to get public wallet address from WalletConnect Cacao object iss: ${auth.p.iss}`);
-        const messageToSign = formatMessage(auth.p, auth.p.iss);
-        const signature = auth.s.s;
-        lastResponse = await verifySignInMessage({
-            chain,
-            messageToSign,
-            signature,
-            walletAddress: publicWalletAddress,
-            walletDisplayName,
-            walletProviderType: WalletProviderEnum.WalletConnect
-        }, client);
-    }
-    if (!lastResponse) {
-        return;
-    }
-    /**
-   * Adds the user with the new wallet verified credentials
-   * This will add the new verified wallet accounts to the client`s state
-   */ updateAuthFromVerifyResponse({
-        response: lastResponse
-    }, client);
-};
-
-/**
- * A low level function that is used to connect a WalletConnect authenticate response to the Dynamic SDK.
- * It will generate the wallet providers and wallet accounts for all accounts in the session.
- *
- * @see WalletConnect's docs on [session authentication](https://docs.reown.com/advanced/api/sign/dapp-usage#session-authenticate-with-recaps)
- * @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
- * @returns A promise that resolves to the connected and verified wallet account.
- */ const importWalletConnectAuthResponse = async ({ authResponse, chain }, client)=>{
-    const { session, auths } = authResponse;
-    /**
-   * Some wallets do not support WC's authenticate method (such as Rainbow).
-   * For these wallets, the authenticate method will act as a regular connect method.
-   * Therefore we must call verify individually.
-   */ if (!auths || auths.length === 0) {
-        /**
-     * Set addToDynamicWalletAccounts to false to avoid adding the wallet accounts to the dynamic's wallet accounts
-     * while we are still verifying them.
-     * After verifying, we set addToDynamicWalletAccounts back to true.
-     */ const { walletAccounts } = await importWalletConnectSession({
-            addToDynamicWalletAccounts: false,
-            session
-        }, client);
-        // This should not be concurrent because the first will be a verify and the rest will be a link
-        for (const walletAccount of walletAccounts){
-            await verifyWalletAccount({
-                walletAccount
-            }, client);
-        }
-        await setSessionTopicsData({
-            update: (sessionTopicsData)=>_extends({}, sessionTopicsData, {
-                    [session.topic]: {
-                        shouldAddToDynamicWalletAccounts: true
-                    }
-                })
-        }, client);
-        return {
-            walletAccounts
-        };
-    }
-    /**
-   * This reconstructs the message that was signed by the wallet and verifies the signature
-   * in the backend. It will update the user with the new verified credentials.
-   */ await verifyWalletConnectAuths({
-        auths,
-        chain,
-        walletDisplayName: session.peer.metadata.name
-    }, client);
-    const { walletAccounts } = await importWalletConnectSession({
-        addToDynamicWalletAccounts: true,
-        session
-    }, client);
-    const verifiedCredentialWalletProviderKeyMap = Object.fromEntries(walletAccounts.map((walletAccount)=>{
-        const { verifiedCredentialId } = walletAccount;
-        assertDefined(verifiedCredentialId, `Wallet account of ID ${walletAccount.id} still has no verified credential after being verified`);
-        return [
-            verifiedCredentialId,
-            walletAccount.walletProviderKey
-        ];
-    }));
-    updateWalletProviderKeysForVerifiedCredentials({
-        keysToUpdate: verifiedCredentialWalletProviderKeyMap
-    }, client);
-    return {
-        walletAccounts
-    };
-};
-
-/**
- * Clears all temporary sessions and disconnects from them.
- *
- * External sessions are for WC sessions whose accounts are not supposed to be saved in
- * the current dynamic's wallet accounts.
- * Since we don't own the created wallet accounts, we must keep their corresponding WC sessions alive
- * until the page is refreshed or the customer removes the wallet account.
- *
- * @param client - The client instance.
- */ const clearTemporarySessions = async (client)=>{
-    const signClient = await getSignClient(client);
-    const sessionTopicsData = await getSessionTopicsData(client);
-    const temporarySessionTopics = Object.keys(sessionTopicsData).filter((topic)=>!sessionTopicsData[topic].shouldAddToDynamicWalletAccounts);
-    if (temporarySessionTopics.length === 0) {
-        return;
-    }
-    for (const topic of temporarySessionTopics){
-        await signClient.disconnect({
-            reason: SDK_ERRORS.USER_DISCONNECTED,
-            topic
-        });
-    }
-    const newSessionTopicsData = Object.fromEntries(Object.entries(sessionTopicsData).filter(([, { shouldAddToDynamicWalletAccounts: isPermanentSession }])=>isPermanentSession));
-    await setSessionTopicsData({
-        update: ()=>newSessionTopicsData
-    }, client);
-};
-
-const initializeWalletConnectExtension = async (client)=>{
-    // Clear external session topics that were created in previous browser sessions
-    // Read more in the clearTemporarySessions function.
-    await clearTemporarySessions(client);
-    // Add debounce to account for multiple WC extension additions in quick succession
-    await syncSessionsToWalletProviders({
-        allowOverridingWalletProviders: false,
-        debounceTime: 200
-    }, client);
-};
-
-assertPackageVersion(name, version);
-
-export { getNamespaceRegistry, getSignClient, importWalletConnectAuthResponse, importWalletConnectSession, initializeWalletConnectExtension, splitCaip10Token, syncSessionsToWalletProviders };

package/index.cjs.d.ts

@@ -1 +0,0 @@
-export * from "./src/exports/index";

package/index.cjs.js

@@ -1,13 +0,0 @@
-'use strict';
-
-var assertPackageVersion = require('@dynamic-labs-sdk/assert-package-version');
-var isWalletConnectWalletProvider = require('./isWalletConnectWalletProvider.cjs.js');
-var utils = require('@walletconnect/utils');
-
-assertPackageVersion.assertPackageVersion(isWalletConnectWalletProvider.name, isWalletConnectWalletProvider.version);
-
-exports.isWalletConnectWalletProvider = isWalletConnectWalletProvider.isWalletConnectWalletProvider;
-Object.defineProperty(exports, "WC_ERRORS", {
-  enumerable: true,
-  get: function () { return utils.SDK_ERRORS; }
-});

package/index.esm.d.ts

@@ -1 +0,0 @@
-export * from "./src/exports/index";

package/index.esm.js

@@ -1,6 +0,0 @@
-import { assertPackageVersion } from '@dynamic-labs-sdk/assert-package-version';
-import { n as name, v as version } from './isWalletConnectWalletProvider.esm.js';
-export { i as isWalletConnectWalletProvider } from './isWalletConnectWalletProvider.esm.js';
-export { SDK_ERRORS as WC_ERRORS } from '@walletconnect/utils';
-
-assertPackageVersion(name, version);

package/isWalletConnectWalletProvider.cjs.js

@@ -1,23 +0,0 @@
-'use strict';
-
-var name = "@dynamic-labs-sdk/wallet-connect";
-var version = "0.1.1";
-
-/**
- * This is a way to ensure Typescript will guard that all keys defined in
- * WalletConnectWalletProvider are accounted for in this function.
- *
- * It will complain if any key is missing or if there are any extra keys.
- */ const wcExclusiveKeysRecord = {
-    namespaceKey: null,
-    session: null,
-    topic: null
-};
-const wcExclusiveKeys = Object.keys(wcExclusiveKeysRecord);
-const isWalletConnectWalletProvider = (walletProvider)=>{
-    return wcExclusiveKeys.every((key)=>key in walletProvider);
-};
-
-exports.isWalletConnectWalletProvider = isWalletConnectWalletProvider;
-exports.name = name;
-exports.version = version;

package/isWalletConnectWalletProvider.esm.js

@@ -1,19 +0,0 @@
-var name = "@dynamic-labs-sdk/wallet-connect";
-var version = "0.1.1";
-
-/**
- * This is a way to ensure Typescript will guard that all keys defined in
- * WalletConnectWalletProvider are accounted for in this function.
- *
- * It will complain if any key is missing or if there are any extra keys.
- */ const wcExclusiveKeysRecord = {
-    namespaceKey: null,
-    session: null,
-    topic: null
-};
-const wcExclusiveKeys = Object.keys(wcExclusiveKeysRecord);
-const isWalletConnectWalletProvider = (walletProvider)=>{
-    return wcExclusiveKeys.every((key)=>key in walletProvider);
-};
-
-export { isWalletConnectWalletProvider as i, name as n, version as v };