@dynamic-labs-sdk/solana 0.0.1-alpha.8 → 0.1.0-alpha.0

package/addSolanaWalletStandardExtension.esm.js

@@ -1,48 +1,81 @@
-import { MethodNotImplementedError, assertDefined, formatWalletProviderKey, formatWalletProviderGroupKey, bufferToBase64, getClient, getCore, createApiClient, formatSignInMessage, hasExtension, getWalletProviderRegistry, assignClient, WalletProviderPriority } from '@dynamic-labs-sdk/client/core';
+import { createBaseNetworkProvider, getNetworkProviderBuilderRegistry, assertDefined, formatWalletProviderKey, createWalletProviderEventEmitter, formatWalletProviderGroupKey, switchActiveNetworkInLastKnownRegistry, getActiveNetworkIdFromLastKnownRegistry, bufferToBase64, getNetworkProviderFromNetworkId, getDefaultClient, hasExtension, registerExtension, getWalletProviderRegistry, WalletProviderPriority } from '@dynamic-labs-sdk/client/core';
 import { getWallets } from '@wallet-standard/app';
+import { _ as _extends, c as createEmptyEventEmitter, i as isVersionedTransaction } from './isVersionedTransaction.esm.js';
+import { Connection, PublicKey, VersionedTransaction, Transaction } from '@solana/web3.js';
 import { assertWalletAccountSigningAvailability } from '@dynamic-labs-sdk/client';
-import { WalletProviderEnum, ChainEnum } from '@dynamic-labs/sdk-api-core';
-import { VersionedTransaction, Transaction, PublicKey } from '@solana/web3.js';
+import { WalletProviderEnum } from '@dynamic-labs/sdk-api-core';
+import bs58 from 'bs58';
 
-const isVersionedTransaction = (transaction)=>!('instructions' in transaction);
+const fetchSolBalance = async ({ address, rpcUrl })=>{
+    // Establish a connection to the Solana network using the provided RPC URL.
+    const connection = new Connection(rpcUrl);
+    // Convert the string address into a PublicKey object.
+    const publicKey = new PublicKey(address);
+    // Fetch the balance of the public key. The balance is in lamports.
+    const balanceInLamports = await connection.getBalance(publicKey);
+    // The getBalance method returns the balance in lamports.
+    // 1 SOL = 1,000,000,000 lamports.
+    const balanceInSol = balanceInLamports / 1000000000;
+    // Return the balance in SOL as a string
+    return balanceInSol.toString();
+};
+
+const createSolanaNetworkProvider = (networkData)=>_extends({}, createBaseNetworkProvider('SOL', networkData), {
+        cluster: networkData.cluster,
+        getBalance: async ({ address })=>({
+                balance: await fetchSolBalance({
+                    address,
+                    rpcUrl: networkData.rpcUrls.http[0]
+                })
+            })
+    });
+
+const registerSolanaNetworkProviderBuilder = (client)=>{
+    const networkProviderBuilderRegistry = getNetworkProviderBuilderRegistry(client);
+    /**
+   * If the Solana network provider builder is already registered, return.
+   */ if (networkProviderBuilderRegistry.get().get('SOL')) {
+        return;
+    }
+    networkProviderBuilderRegistry.register({
+        builder: createSolanaNetworkProvider,
+        chain: 'SOL'
+    });
+};
 
 const getFeaturesForSolanaStandardWallet = (wallet)=>{
     return wallet.features;
 };
 
-const createSolanaSignerFromSolanaStandardWallet = (wallet)=>{
-    const features = getFeaturesForSolanaStandardWallet(wallet);
+const createSolanaSignerFromSolanaStandardWallet = ({ networkProvider, walletStandardWallet })=>{
+    const features = getFeaturesForSolanaStandardWallet(walletStandardWallet);
     const getPublicKey = ()=>{
-        var _wallet_accounts_, _wallet_accounts;
-        if (!((_wallet_accounts = wallet.accounts) == null ? void 0 : (_wallet_accounts_ = _wallet_accounts[0]) == null ? void 0 : _wallet_accounts_.publicKey)) {
+        var _walletStandardWallet_accounts_, _walletStandardWallet_accounts;
+        if (!((_walletStandardWallet_accounts = walletStandardWallet.accounts) == null ? void 0 : (_walletStandardWallet_accounts_ = _walletStandardWallet_accounts[0]) == null ? void 0 : _walletStandardWallet_accounts_.publicKey)) {
             return undefined;
         }
-        return new PublicKey(wallet.accounts[0].publicKey);
+        return new PublicKey(walletStandardWallet.accounts[0].publicKey);
     };
     const getChain = ()=>{
-        // TODO: add support for getting the chain from the provider
-        // const currentNetwork = provider.getSelectedNetwork();
-        // assertDefined(currentNetwork, 'Network not found');
-        // const cluster = currentNetwork.cluster ?? 'mainnet';
-        const cluster = 'mainnet';
-        return `solana:${cluster}`;
+        assertDefined(networkProvider.cluster, `Cluster was not defined for network provider ${networkProvider.displayName} (networkId: ${networkProvider.networkId})`);
+        return `solana:${networkProvider.cluster}`;
     };
     const isConnected = ()=>{
-        var _wallet_accounts;
-        return ((_wallet_accounts = wallet.accounts) == null ? void 0 : _wallet_accounts.length) > 0;
+        var _walletStandardWallet_accounts;
+        return ((_walletStandardWallet_accounts = walletStandardWallet.accounts) == null ? void 0 : _walletStandardWallet_accounts.length) > 0;
     };
     const getCurrentAccount = async ()=>{
-        var _wallet_accounts;
+        var _walletStandardWallet_accounts;
         if (!isConnected()) {
             await connect();
         }
-        const account = (_wallet_accounts = wallet.accounts) == null ? void 0 : _wallet_accounts[0];
+        const account = (_walletStandardWallet_accounts = walletStandardWallet.accounts) == null ? void 0 : _walletStandardWallet_accounts[0];
         assertDefined(account, 'No connected accounts found');
         return account;
     };
     const connect = async ()=>{
         var _features_standardconnect, _result_accounts;
-        const autoConnectedAccounts = wallet.accounts;
+        const autoConnectedAccounts = walletStandardWallet.accounts;
         // some wallets like Farcaster will auto inject the account into the wallet object
         // instead of returning it from the connect method
         // so we need to check for that first
@@ -123,7 +156,7 @@ const createSolanaSignerFromSolanaStandardWallet = (wallet)=>{
         });
         const [{ signature }] = signedTransactions;
         return {
-            signature: new TextDecoder().decode(signature)
+            signature: bs58.encode(signature)
         };
     };
     const signMessage = async (message)=>{
@@ -139,52 +172,35 @@ const createSolanaSignerFromSolanaStandardWallet = (wallet)=>{
             signature: messages[0].signature
         };
     };
-    return {
-        addListener: ()=>{
-            throw new MethodNotImplementedError('addListener');
-        },
+    return _extends({}, createEmptyEventEmitter(), {
         connect,
         disconnect,
-        emit: ()=>{
-            throw new MethodNotImplementedError('emit');
-        },
-        eventNames: ()=>{
-            return [];
-        },
         get isConnected () {
             return isConnected();
         },
-        listenerCount: ()=>{
-            return 0;
-        },
-        listeners: ()=>{
-            return [];
-        },
-        off: ()=>{
-            throw new MethodNotImplementedError('off');
-        },
         on,
-        once: ()=>{
-            throw new MethodNotImplementedError('once');
-        },
         providers: [],
         get publicKey () {
             return getPublicKey();
         },
-        removeAllListeners: ()=>{
-            throw new MethodNotImplementedError('removeAllListeners');
-        },
-        removeListener: ()=>{
-            throw new MethodNotImplementedError('removeListener');
-        },
         signAllTransactions,
         signAndSendTransaction,
         signMessage,
         signTransaction
-    };
+    });
 };
 
-const createWalletProviderFromSolanaStandardWallet = ({ wallet })=>{
+const createWalletProviderFromSolanaStandardWallet = ({ dynamicClient, walletStandardWallet })=>{
+    const key = formatWalletProviderKey(walletStandardWallet.name, 'SOL');
+    const getActiveNetworkId = async ()=>getActiveNetworkIdFromLastKnownRegistry({
+            client: dynamicClient,
+            walletProviderKey: key
+        });
+    const switchActiveNetwork = async ({ networkId })=>switchActiveNetworkInLastKnownRegistry({
+            client: dynamicClient,
+            networkId,
+            walletProviderKey: key
+        });
     const connect = async ()=>{
         const signer = await getSigner();
         const result = await signer.connect();
@@ -204,45 +220,24 @@ const createWalletProviderFromSolanaStandardWallet = ({ wallet })=>{
             await signer.connect();
         }
         return {
-            addresses: wallet.accounts.map((account)=>account.address)
+            addresses: walletStandardWallet.accounts.map((account)=>account.address)
         };
     };
     const getSigner = async (walletAccount)=>{
         if (walletAccount) {
-            await assertWalletAccountSigningAvailability(walletAccount);
+            await assertWalletAccountSigningAvailability({
+                walletAccount
+            }, dynamicClient);
         }
-        return createSolanaSignerFromSolanaStandardWallet(wallet);
-    };
-    const proveOwnership = async (walletAccount)=>{
-        var _core_metadata;
-        const client = getClient(walletAccount);
-        const core = getCore(client);
-        const apiClient = createApiClient(client);
-        const appUrl = (_core_metadata = core.metadata) == null ? void 0 : _core_metadata.url;
-        assertDefined(appUrl, 'App URL is not set');
-        const url = new URL(appUrl);
-        const { nonce } = await apiClient.getNonce({
-            environmentId: core.environmentId
+        const { networkId } = await getActiveNetworkId();
+        const networkProvider = getNetworkProviderFromNetworkId({
+            chain: 'SOL',
+            networkId
+        }, dynamicClient);
+        return createSolanaSignerFromSolanaStandardWallet({
+            networkProvider,
+            walletStandardWallet
         });
-        assertDefined(nonce, 'Failed to get nonce');
-        const messageToSign = await formatSignInMessage({
-            address: walletAccount.address,
-            blockchainName: 'Solana',
-            domain: url.host,
-            issuedAt: new Date().toISOString(),
-            nonce,
-            requestId: core.environmentId,
-            uri: url.toString()
-        });
-        const signedMessage = await signMessage({
-            message: messageToSign,
-            walletAccount
-        });
-        return {
-            chain: ChainEnum.Sol,
-            messageToSign,
-            signedMessage: signedMessage.signature
-        };
     };
     const signMessage = async ({ message, walletAccount })=>{
         const signer = await getSigner(walletAccount);
@@ -253,22 +248,57 @@ const createWalletProviderFromSolanaStandardWallet = ({ wallet })=>{
             signature: bufferToBase64(signedMessage.signature)
         };
     };
-    return {
+    const getEventsFeature = ()=>{
+        const features = getFeaturesForSolanaStandardWallet(walletStandardWallet);
+        const eventsFeature = features['standard:events'];
+        return eventsFeature;
+    };
+    const { getEventEmitter, cleanupEventEmitter } = createWalletProviderEventEmitter({
+        removeEventListeners: ({ setupReturnValue })=>{
+            assertDefined(setupReturnValue, 'Setup return value not defined');
+            setupReturnValue();
+        },
+        setupEventListeners: ({ handleAccountsChanged })=>{
+            return getEventsFeature().on('change', ({ accounts })=>{
+                var _accounts_map;
+                handleAccountsChanged({
+                    addresses: (_accounts_map = accounts == null ? void 0 : accounts.map((account)=>account.address)) != null ? _accounts_map : []
+                });
+            });
+        },
+        supportedEvents: [
+            'accountsChanged'
+        ]
+    });
+    const terminate = async ()=>{
+        cleanupEventEmitter();
+    };
+    const walletProvider = {
         chain: 'SOL',
         connect,
         disconnect,
+        getActiveNetworkId,
         getConnectedAddresses,
         getSigner,
         getWalletProviderType: ()=>WalletProviderEnum.BrowserExtension,
-        groupKey: formatWalletProviderGroupKey(wallet.name),
-        key: formatWalletProviderKey(wallet.name, ChainEnum.Sol),
+        groupKey: formatWalletProviderGroupKey(walletStandardWallet.name),
+        key,
         metadata: {
-            displayName: wallet.name,
-            icon: wallet.icon
+            displayName: walletStandardWallet.name,
+            icon: walletStandardWallet.icon
         },
-        proveOwnership,
-        signMessage
+        signMessage,
+        switchActiveNetwork,
+        terminate
     };
+    // The provider will only implement events if this external wallet provider
+    // implements the standard:events feature
+    if (getEventsFeature()) {
+        Object.defineProperty(walletProvider, 'events', {
+            get: ()=>getEventEmitter()
+        });
+    }
+    return walletProvider;
 };
 
 const hasAllRequiredFeatures = (wallet)=>{
@@ -277,16 +307,30 @@ const hasAllRequiredFeatures = (wallet)=>{
 };
 
 const SOLANA_WALLET_STANDARD_EXTENSION_KEY = 'solanaWalletStandard';
-const addSolanaWalletStandardExtension = (client)=>{
-    if (hasExtension(client, SOLANA_WALLET_STANDARD_EXTENSION_KEY)) {
+/**
+ * Adds the Solana Wallet Standard extension to the Dynamic client.
+ *
+ * This extension enables integration with wallets that implement the Solana Wallet Standard,
+ * automatically detecting and registering compatible wallets for use with the Dynamic SDK.
+ *
+ * @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
+ */ const addSolanaWalletStandardExtension = (client = getDefaultClient())=>{
+    if (hasExtension({
+        extensionKey: SOLANA_WALLET_STANDARD_EXTENSION_KEY
+    }, client)) {
         return;
     }
+    registerExtension({
+        extensionKey: SOLANA_WALLET_STANDARD_EXTENSION_KEY
+    }, client);
+    registerSolanaNetworkProviderBuilder(client);
     const walletProviderRegistry = getWalletProviderRegistry(client);
-    const walletStandardWallet = getWallets().get().filter(hasAllRequiredFeatures);
-    walletStandardWallet.forEach((wallet)=>{
-        const walletProvider = assignClient(createWalletProviderFromSolanaStandardWallet({
-            wallet
-        }), client);
+    const walletStandardWallets = getWallets().get().filter(hasAllRequiredFeatures);
+    walletStandardWallets.forEach((walletStandardWallet)=>{
+        const walletProvider = createWalletProviderFromSolanaStandardWallet({
+            dynamicClient: client,
+            walletStandardWallet
+        });
         walletProviderRegistry.register({
             priority: WalletProviderPriority.WALLET_SELF_ANNOUNCEMENT_STANDARD,
             walletProvider

package/addWaasSolanaExtension.cjs.js

@@ -0,0 +1,176 @@
+'use strict';
+
+var core = require('@dynamic-labs-sdk/client/core');
+var isVersionedTransaction = require('./isVersionedTransaction.cjs.js');
+var client = require('@dynamic-labs-sdk/client');
+var core$1 = require('@dynamic-labs-sdk/client/waas/core');
+var sdkApiCore = require('@dynamic-labs/sdk-api-core');
+var web3_js = require('@solana/web3.js');
+var bs58 = require('bs58');
+
+/**
+ * Returns a new Solana connection for the given network provider.
+ *
+ * @example
+ * ```ts
+ * import { getActiveNetworkData } from '@dynamic-labs-sdk/client';
+ * import { isSolanaNetworkProvider, getSolanaConnection } from '@dynamic-labs-sdk/solana';
+ *
+ * const { networkData } = getActiveNetworkData({ walletAccount });
+ *
+ * if(!networkData) {
+ *   throw new Error('No network data found');
+ * }
+ *
+ * const connection = getSolanaConnection({
+ *   networkData,
+ * });
+ * ```
+ */ const getSolanaConnection = ({ networkData, commitmentOrConfig })=>{
+    return new web3_js.Connection(networkData.rpcUrls.http[0], commitmentOrConfig);
+};
+
+const createSolanaSignerFromSolanaWaasProvider = ({ networkData, waasProvider, walletAccount })=>{
+    const publicKey = new web3_js.PublicKey(walletAccount.address);
+    const signAndSendTransaction = async (transaction)=>{
+        const signedTransaction = await signTransaction(transaction);
+        const connection = getSolanaConnection({
+            networkData
+        });
+        const rawTransaction = signedTransaction.serialize();
+        const signature = await connection.sendRawTransaction(rawTransaction);
+        return {
+            signature
+        };
+    };
+    const signMessage = async (messageArrayBuffer)=>{
+        const message = bs58.encode(messageArrayBuffer);
+        const { signature } = await waasProvider.signMessage({
+            message,
+            walletAccount
+        });
+        return {
+            signature: bs58.decode(signature)
+        };
+    };
+    const signTransaction = async (transaction)=>{
+        const messageBytes = isVersionedTransaction.isVersionedTransaction(transaction) ? transaction.message.serialize() : transaction.serializeMessage();
+        const serializedTransaction = core.getBuffer().from(messageBytes).toString('hex');
+        const { signature } = await waasProvider.signSerializedTransaction({
+            serializedTransaction,
+            walletAccount
+        });
+        transaction.addSignature(publicKey, core.getBuffer().from(signature, 'hex'));
+        transaction.serialize({
+            requireAllSignatures: false,
+            verifySignatures: true
+        });
+        return transaction;
+    };
+    const signAllTransactions = async (transactions)=>{
+        return Promise.all(transactions.map(signTransaction));
+    };
+    return isVersionedTransaction._extends({}, isVersionedTransaction.createEmptyEventEmitter(), {
+        connect: ()=>{
+            throw new core.MethodNotImplementedError('connect');
+        },
+        disconnect: ()=>{
+            throw new core.MethodNotImplementedError('disconnect');
+        },
+        isConnected: true,
+        providers: [],
+        publicKey,
+        signAllTransactions,
+        signAndSendTransaction,
+        signMessage,
+        signTransaction
+    });
+};
+
+const createWalletProviderForWaasSolana = (sdkClient)=>{
+    const chain = 'SOL';
+    const key = core.formatWalletProviderKey(core$1.DYNAMIC_WAAS_METADATA.name, chain);
+    const waasProvider = core$1.createWaasProvider({
+        chain,
+        sdkClient
+    });
+    const getActiveNetworkId = async ()=>core.getActiveNetworkIdFromLastKnownRegistry({
+            client: sdkClient,
+            walletProviderKey: key
+        });
+    const switchActiveNetwork = async ({ networkId })=>core.switchActiveNetworkInLastKnownRegistry({
+            client: sdkClient,
+            networkId,
+            walletProviderKey: key
+        });
+    const getConnectedAddresses = async ()=>{
+        const waasSolanaAddresses = core$1.getAllUserWaasAddressesForChain({
+            chain
+        }, sdkClient);
+        return {
+            addresses: waasSolanaAddresses
+        };
+    };
+    const signMessage = async ({ message, walletAccount })=>{
+        core.assertDefined(walletAccount, 'Wallet account is required');
+        return waasProvider.signMessage({
+            message,
+            walletAccount
+        });
+    };
+    const getSigner = async (walletAccount)=>{
+        core.assertDefined(walletAccount, 'Wallet account is required');
+        const { networkData } = await client.getActiveNetworkData({
+            walletAccount
+        });
+        core.assertDefined(networkData, 'Network data is required');
+        return createSolanaSignerFromSolanaWaasProvider({
+            networkData,
+            waasProvider,
+            walletAccount
+        });
+    };
+    return isVersionedTransaction._extends({}, waasProvider, {
+        chain,
+        getActiveNetworkId,
+        getConnectedAddresses,
+        getSigner,
+        getWalletProviderType: ()=>sdkApiCore.WalletProviderEnum.EmbeddedWallet,
+        groupKey: core.formatWalletProviderGroupKey(core$1.DYNAMIC_WAAS_METADATA.name),
+        key,
+        metadata: {
+            displayName: core$1.DYNAMIC_WAAS_METADATA.name,
+            icon: core$1.DYNAMIC_WAAS_METADATA.icon
+        },
+        signMessage,
+        switchActiveNetwork
+    });
+};
+
+const WAAS_SOLANA_EXTENSION_KEY = 'waasSolana';
+/**
+ * Adds the Dynamic WaaS (Wallet as a Service) Solana extension to the Dynamic client.
+ *
+ * This extension enables embedded wallet functionality for Solana blockchain,
+ * allowing users to have wallets managed by Dynamic's infrastructure.
+ *
+ * @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
+ */ const addWaasSolanaExtension = (client = core.getDefaultClient())=>{
+    if (core.hasExtension({
+        extensionKey: WAAS_SOLANA_EXTENSION_KEY
+    }, client)) {
+        return;
+    }
+    core.registerExtension({
+        extensionKey: WAAS_SOLANA_EXTENSION_KEY
+    }, client);
+    const walletProviderRegistry = core.getWalletProviderRegistry(client);
+    const walletProvider = createWalletProviderForWaasSolana(client);
+    walletProviderRegistry.register({
+        priority: core.WalletProviderPriority.WALLET_SDK,
+        walletProvider
+    });
+};
+
+exports.addWaasSolanaExtension = addWaasSolanaExtension;
+exports.getSolanaConnection = getSolanaConnection;

package/addWaasSolanaExtension.esm.js

@@ -0,0 +1,173 @@
+import { MethodNotImplementedError, getBuffer, formatWalletProviderKey, formatWalletProviderGroupKey, switchActiveNetworkInLastKnownRegistry, getActiveNetworkIdFromLastKnownRegistry, assertDefined, getDefaultClient, hasExtension, registerExtension, getWalletProviderRegistry, WalletProviderPriority } from '@dynamic-labs-sdk/client/core';
+import { _ as _extends, c as createEmptyEventEmitter, i as isVersionedTransaction } from './isVersionedTransaction.esm.js';
+import { getActiveNetworkData } from '@dynamic-labs-sdk/client';
+import { DYNAMIC_WAAS_METADATA, createWaasProvider, getAllUserWaasAddressesForChain } from '@dynamic-labs-sdk/client/waas/core';
+import { WalletProviderEnum } from '@dynamic-labs/sdk-api-core';
+import { Connection, PublicKey } from '@solana/web3.js';
+import bs58 from 'bs58';
+
+/**
+ * Returns a new Solana connection for the given network provider.
+ *
+ * @example
+ * ```ts
+ * import { getActiveNetworkData } from '@dynamic-labs-sdk/client';
+ * import { isSolanaNetworkProvider, getSolanaConnection } from '@dynamic-labs-sdk/solana';
+ *
+ * const { networkData } = getActiveNetworkData({ walletAccount });
+ *
+ * if(!networkData) {
+ *   throw new Error('No network data found');
+ * }
+ *
+ * const connection = getSolanaConnection({
+ *   networkData,
+ * });
+ * ```
+ */ const getSolanaConnection = ({ networkData, commitmentOrConfig })=>{
+    return new Connection(networkData.rpcUrls.http[0], commitmentOrConfig);
+};
+
+const createSolanaSignerFromSolanaWaasProvider = ({ networkData, waasProvider, walletAccount })=>{
+    const publicKey = new PublicKey(walletAccount.address);
+    const signAndSendTransaction = async (transaction)=>{
+        const signedTransaction = await signTransaction(transaction);
+        const connection = getSolanaConnection({
+            networkData
+        });
+        const rawTransaction = signedTransaction.serialize();
+        const signature = await connection.sendRawTransaction(rawTransaction);
+        return {
+            signature
+        };
+    };
+    const signMessage = async (messageArrayBuffer)=>{
+        const message = bs58.encode(messageArrayBuffer);
+        const { signature } = await waasProvider.signMessage({
+            message,
+            walletAccount
+        });
+        return {
+            signature: bs58.decode(signature)
+        };
+    };
+    const signTransaction = async (transaction)=>{
+        const messageBytes = isVersionedTransaction(transaction) ? transaction.message.serialize() : transaction.serializeMessage();
+        const serializedTransaction = getBuffer().from(messageBytes).toString('hex');
+        const { signature } = await waasProvider.signSerializedTransaction({
+            serializedTransaction,
+            walletAccount
+        });
+        transaction.addSignature(publicKey, getBuffer().from(signature, 'hex'));
+        transaction.serialize({
+            requireAllSignatures: false,
+            verifySignatures: true
+        });
+        return transaction;
+    };
+    const signAllTransactions = async (transactions)=>{
+        return Promise.all(transactions.map(signTransaction));
+    };
+    return _extends({}, createEmptyEventEmitter(), {
+        connect: ()=>{
+            throw new MethodNotImplementedError('connect');
+        },
+        disconnect: ()=>{
+            throw new MethodNotImplementedError('disconnect');
+        },
+        isConnected: true,
+        providers: [],
+        publicKey,
+        signAllTransactions,
+        signAndSendTransaction,
+        signMessage,
+        signTransaction
+    });
+};
+
+const createWalletProviderForWaasSolana = (sdkClient)=>{
+    const chain = 'SOL';
+    const key = formatWalletProviderKey(DYNAMIC_WAAS_METADATA.name, chain);
+    const waasProvider = createWaasProvider({
+        chain,
+        sdkClient
+    });
+    const getActiveNetworkId = async ()=>getActiveNetworkIdFromLastKnownRegistry({
+            client: sdkClient,
+            walletProviderKey: key
+        });
+    const switchActiveNetwork = async ({ networkId })=>switchActiveNetworkInLastKnownRegistry({
+            client: sdkClient,
+            networkId,
+            walletProviderKey: key
+        });
+    const getConnectedAddresses = async ()=>{
+        const waasSolanaAddresses = getAllUserWaasAddressesForChain({
+            chain
+        }, sdkClient);
+        return {
+            addresses: waasSolanaAddresses
+        };
+    };
+    const signMessage = async ({ message, walletAccount })=>{
+        assertDefined(walletAccount, 'Wallet account is required');
+        return waasProvider.signMessage({
+            message,
+            walletAccount
+        });
+    };
+    const getSigner = async (walletAccount)=>{
+        assertDefined(walletAccount, 'Wallet account is required');
+        const { networkData } = await getActiveNetworkData({
+            walletAccount
+        });
+        assertDefined(networkData, 'Network data is required');
+        return createSolanaSignerFromSolanaWaasProvider({
+            networkData,
+            waasProvider,
+            walletAccount
+        });
+    };
+    return _extends({}, waasProvider, {
+        chain,
+        getActiveNetworkId,
+        getConnectedAddresses,
+        getSigner,
+        getWalletProviderType: ()=>WalletProviderEnum.EmbeddedWallet,
+        groupKey: formatWalletProviderGroupKey(DYNAMIC_WAAS_METADATA.name),
+        key,
+        metadata: {
+            displayName: DYNAMIC_WAAS_METADATA.name,
+            icon: DYNAMIC_WAAS_METADATA.icon
+        },
+        signMessage,
+        switchActiveNetwork
+    });
+};
+
+const WAAS_SOLANA_EXTENSION_KEY = 'waasSolana';
+/**
+ * Adds the Dynamic WaaS (Wallet as a Service) Solana extension to the Dynamic client.
+ *
+ * This extension enables embedded wallet functionality for Solana blockchain,
+ * allowing users to have wallets managed by Dynamic's infrastructure.
+ *
+ * @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
+ */ const addWaasSolanaExtension = (client = getDefaultClient())=>{
+    if (hasExtension({
+        extensionKey: WAAS_SOLANA_EXTENSION_KEY
+    }, client)) {
+        return;
+    }
+    registerExtension({
+        extensionKey: WAAS_SOLANA_EXTENSION_KEY
+    }, client);
+    const walletProviderRegistry = getWalletProviderRegistry(client);
+    const walletProvider = createWalletProviderForWaasSolana(client);
+    walletProviderRegistry.register({
+        priority: WalletProviderPriority.WALLET_SDK,
+        walletProvider
+    });
+};
+
+export { addWaasSolanaExtension as a, getSolanaConnection as g };