@dynamic-labs-sdk/solana 0.1.0-alpha.3 → 0.1.0-alpha.30

package/addSolanaWalletStandardExtension.esm.js

@@ -1,8 +1,8 @@
-import { createBaseNetworkProvider, getNetworkProviderBuilderRegistry, assertDefined, formatWalletProviderKey, createWalletProviderEventEmitter, formatWalletProviderGroupKey, switchActiveNetworkInLastKnownRegistry, getActiveNetworkIdFromLastKnownRegistry, bufferToBase64, getNetworkProviderFromNetworkId, getDefaultClient, hasExtension, registerExtension, getWalletProviderRegistry, WalletProviderPriority } from '@dynamic-labs-sdk/client/core';
+import { createBaseNetworkProvider, getNetworkProviderBuilderRegistry, formatWalletProviderKey, createWalletProviderEventEmitter, assertDefined, formatWalletProviderGroupKey, switchActiveNetworkInLastKnownRegistry, getActiveNetworkIdFromLastKnownRegistry, bufferToBase64, 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 { _ as _extends, i as isVersionedTransaction } from './isVersionedTransaction.esm.js';
 import { Connection, PublicKey, VersionedTransaction, Transaction } from '@solana/web3.js';
-import { assertWalletAccountSigningAvailability } from '@dynamic-labs-sdk/client';
+import { getActiveNetworkData, assertWalletAccountSigningAvailability } from '@dynamic-labs-sdk/client';
 import { WalletProviderEnum } from '@dynamic-labs/sdk-api-core';
 import bs58 from 'bs58';
 
@@ -22,6 +22,7 @@ const fetchSolBalance = async ({ address, rpcUrl })=>{
 
 const createSolanaNetworkProvider = (networkData)=>_extends({}, createBaseNetworkProvider('SOL', networkData), {
         cluster: networkData.cluster,
+        genesisHash: networkData.genesisHash,
         getBalance: async ({ address })=>({
                 balance: await fetchSolBalance({
                     address,
@@ -43,36 +44,28 @@ const registerSolanaNetworkProviderBuilder = (client)=>{
     });
 };
 
+const getActiveNetworkCluster = async ({ walletAccount }, client)=>{
+    const { networkData } = await getActiveNetworkData({
+        walletAccount
+    }, client);
+    if (!(networkData == null ? void 0 : networkData.cluster)) {
+        return;
+    }
+    return `solana:${networkData.cluster}`;
+};
+
 const getFeaturesForSolanaStandardWallet = (wallet)=>{
     return wallet.features;
 };
 
-const createSolanaSignerFromSolanaStandardWallet = ({ networkProvider, walletStandardWallet })=>{
+const createWalletProviderFromSolanaStandardWallet = ({ dynamicClient, walletStandardWallet })=>{
     const features = getFeaturesForSolanaStandardWallet(walletStandardWallet);
-    const getPublicKey = ()=>{
-        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(walletStandardWallet.accounts[0].publicKey);
-    };
-    const getChain = ()=>{
-        assertDefined(networkProvider.cluster, `Cluster was not defined for network provider ${networkProvider.displayName} (networkId: ${networkProvider.networkId})`);
-        return `solana:${networkProvider.cluster}`;
-    };
-    const isConnected = ()=>{
-        var _walletStandardWallet_accounts;
-        return ((_walletStandardWallet_accounts = walletStandardWallet.accounts) == null ? void 0 : _walletStandardWallet_accounts.length) > 0;
-    };
-    const getCurrentAccount = async ()=>{
-        var _walletStandardWallet_accounts;
-        if (!isConnected()) {
-            await connect();
-        }
-        const account = (_walletStandardWallet_accounts = walletStandardWallet.accounts) == null ? void 0 : _walletStandardWallet_accounts[0];
-        assertDefined(account, 'No connected accounts found');
-        return account;
-    };
+    const walletProviderType = WalletProviderEnum.BrowserExtension;
+    const key = formatWalletProviderKey({
+        chain: 'SOL',
+        displayName: walletStandardWallet.name,
+        walletProviderType
+    });
     const connect = async ()=>{
         var _features_standardconnect, _result_accounts;
         const autoConnectedAccounts = walletStandardWallet.accounts;
@@ -81,8 +74,12 @@ const createSolanaSignerFromSolanaStandardWallet = ({ networkProvider, walletSta
         // so we need to check for that first
         if ((autoConnectedAccounts == null ? void 0 : autoConnectedAccounts.length) && autoConnectedAccounts[0].publicKey && autoConnectedAccounts[0].address) {
             return {
-                address: autoConnectedAccounts[0].address,
-                publicKey: autoConnectedAccounts[0].publicKey
+                addresses: [
+                    {
+                        address: autoConnectedAccounts[0].address,
+                        publicKey: autoConnectedAccounts[0].publicKey.toString()
+                    }
+                ]
             };
         }
         const connectMethod = (_features_standardconnect = features['standard:connect']) == null ? void 0 : _features_standardconnect.connect;
@@ -90,11 +87,14 @@ const createSolanaSignerFromSolanaStandardWallet = ({ networkProvider, walletSta
         const result = await connectMethod({
             silent: false
         });
-        const connectedAccount = result == null ? void 0 : (_result_accounts = result.accounts) == null ? void 0 : _result_accounts[0];
-        assertDefined(connectedAccount, 'No connected accounts');
         return {
-            address: connectedAccount.address,
-            publicKey: connectedAccount.publicKey
+            addresses: (_result_accounts = result.accounts) == null ? void 0 : _result_accounts.map((account)=>{
+                var _account_publicKey;
+                return {
+                    address: account.address,
+                    publicKey: (_account_publicKey = account.publicKey) == null ? void 0 : _account_publicKey.toString()
+                };
+            })
         };
     };
     const disconnect = async ()=>{
@@ -103,53 +103,58 @@ const createSolanaSignerFromSolanaStandardWallet = ({ networkProvider, walletSta
         assertDefined(disconnectMethod, 'disconnect method not found in wallet features');
         await disconnectMethod();
     };
-    const on = (event, listener)=>{
-        var _features_standardevents;
-        const onMethod = (_features_standardevents = features['standard:events']) == null ? void 0 : _features_standardevents.on;
-        if (!onMethod) {
-            return;
+    const getActiveNetworkId = async ()=>getActiveNetworkIdFromLastKnownRegistry({
+            client: dynamicClient,
+            walletProviderKey: key
+        });
+    const getCurrentAccount = async ()=>{
+        var _walletStandardWallet_accounts;
+        if (!isConnected() && connect) {
+            await connect();
         }
-        if (event !== 'accountChanged') {
-            return;
+        const account = (_walletStandardWallet_accounts = walletStandardWallet.accounts) == null ? void 0 : _walletStandardWallet_accounts[0];
+        assertDefined(account, 'No connected accounts found');
+        return account;
+    };
+    const isConnected = ()=>{
+        var _walletStandardWallet_accounts;
+        return ((_walletStandardWallet_accounts = walletStandardWallet.accounts) == null ? void 0 : _walletStandardWallet_accounts.length) > 0;
+    };
+    const getConnectedAddresses = async ()=>{
+        if (!isConnected() && connect) {
+            await connect();
         }
-        const wrappedListener = (prop)=>{
-            var _prop_accounts_, _prop_accounts;
-            const publicKey = (_prop_accounts = prop.accounts) == null ? void 0 : (_prop_accounts_ = _prop_accounts[0]) == null ? void 0 : _prop_accounts_.publicKey;
-            if (publicKey) {
-                listener(new TextDecoder().decode(publicKey));
-            }
+        return {
+            addresses: walletStandardWallet.accounts.map((account)=>account.address)
         };
-        // 'change' is the only event that is supported by the wallet standard
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        return onMethod('change', wrappedListener);
     };
-    const signTransaction = async (transaction)=>{
-        var _features_solanasignTransaction;
-        const signMessageMethod = (_features_solanasignTransaction = features['solana:signTransaction']) == null ? void 0 : _features_solanasignTransaction.signTransaction;
-        assertDefined(signMessageMethod, 'signTransaction method not found in wallet features');
-        const account = await getCurrentAccount();
-        const signTransactionResult = await signMessageMethod({
-            account,
-            chain: getChain(),
-            transaction: transaction.serialize({
-                requireAllSignatures: false
-            })
-        });
-        const signedTransaction = signTransactionResult[0].signedTransaction;
-        if (isVersionedTransaction(transaction)) {
-            return VersionedTransaction.deserialize(signedTransaction);
-        }
-        return Transaction.from(signedTransaction);
+    const signAllTransactions = async ({ transactions, walletAccount })=>{
+        const signedTransactions = await Promise.all(transactions.map(async (transaction)=>{
+            const { signedTransaction } = await signTransaction({
+                transaction,
+                walletAccount
+            });
+            return signedTransaction;
+        }));
+        return {
+            signedTransactions
+        };
     };
-    const signAllTransactions = async (transactions)=>Promise.all(transactions.map(signTransaction));
-    const signAndSendTransaction = async (transaction)=>{
+    const signAndSendTransaction = async ({ transaction, walletAccount })=>{
         var _features_solanasignAndSendTransaction;
+        await assertWalletAccountSigningAvailability({
+            walletAccount
+        }, dynamicClient);
         const signAndSendTransactionMethod = (_features_solanasignAndSendTransaction = features['solana:signAndSendTransaction']) == null ? void 0 : _features_solanasignAndSendTransaction.signAndSendTransaction;
         assertDefined(signAndSendTransactionMethod, 'signAndSendTransaction method not found in wallet features');
         const account = await getCurrentAccount();
+        const chain = await getActiveNetworkCluster({
+            walletAccount
+        }, dynamicClient);
+        assertDefined(chain, 'Could not get active chain for wallet account');
         const signedTransactions = await signAndSendTransactionMethod({
             account,
-            chain: getChain(),
+            chain,
             transaction: transaction.serialize({
                 requireAllSignatures: false
             })
@@ -159,107 +164,66 @@ const createSolanaSignerFromSolanaStandardWallet = ({ networkProvider, walletSta
             signature: bs58.encode(signature)
         };
     };
-    const signMessage = async (message)=>{
+    const signMessage = async ({ message, walletAccount })=>{
         var _features_solanasignMessage;
         const signMessageMethod = (_features_solanasignMessage = features['solana:signMessage']) == null ? void 0 : _features_solanasignMessage.signMessage;
         assertDefined(signMessageMethod, 'signMessage method not found in wallet features');
+        assertDefined(walletAccount, 'Wallet account not found');
+        await assertWalletAccountSigningAvailability({
+            walletAccount
+        }, dynamicClient);
+        const encodedMessage = new TextEncoder().encode(message);
         const account = await getCurrentAccount();
         const messages = await signMessageMethod({
             account,
-            message
+            message: encodedMessage
         });
         return {
-            signature: messages[0].signature
+            signature: bufferToBase64(messages[0].signature)
         };
     };
-    return _extends({}, createEmptyEventEmitter(), {
-        connect,
-        disconnect,
-        get isConnected () {
-            return isConnected();
-        },
-        on,
-        providers: [],
-        get publicKey () {
-            return getPublicKey();
-        },
-        signAllTransactions,
-        signAndSendTransaction,
-        signMessage,
-        signTransaction
-    });
-};
-
-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 signTransaction = async ({ transaction, walletAccount })=>{
+        var _features_solanasignTransaction;
+        const signMessageMethod = (_features_solanasignTransaction = features['solana:signTransaction']) == null ? void 0 : _features_solanasignTransaction.signTransaction;
+        assertDefined(signMessageMethod, 'signTransaction method not found in wallet features');
+        await assertWalletAccountSigningAvailability({
+            walletAccount
+        }, dynamicClient);
+        const account = await getCurrentAccount();
+        const chain = await getActiveNetworkCluster({
+            walletAccount
+        }, dynamicClient);
+        assertDefined(chain, 'Could not get active chain for wallet account');
+        const signTransactionResult = await signMessageMethod({
+            account,
+            chain,
+            transaction: transaction.serialize({
+                requireAllSignatures: false
+            })
         });
-    const connect = async ()=>{
-        const signer = await getSigner();
-        const result = await signer.connect();
-        return {
-            addresses: (result == null ? void 0 : result.address) ? [
-                result.address
-            ] : []
-        };
-    };
-    const disconnect = async ()=>{
-        const signer = await getSigner();
-        await signer.disconnect();
-    };
-    const getConnectedAddresses = async ()=>{
-        const signer = await getSigner();
-        if (!signer.isConnected) {
-            await signer.connect();
+        const signedTransaction = signTransactionResult[0].signedTransaction;
+        if (isVersionedTransaction(transaction)) {
+            return {
+                signedTransaction: VersionedTransaction.deserialize(signedTransaction)
+            };
         }
         return {
-            addresses: walletStandardWallet.accounts.map((account)=>account.address)
+            signedTransaction: Transaction.from(signedTransaction)
         };
     };
-    const getSigner = async (walletAccount)=>{
-        if (walletAccount) {
-            await assertWalletAccountSigningAvailability({
-                walletAccount
-            }, dynamicClient);
-        }
-        const { networkId } = await getActiveNetworkId();
-        const networkProvider = getNetworkProviderFromNetworkId({
-            chain: 'SOL',
-            networkId
-        }, dynamicClient);
-        return createSolanaSignerFromSolanaStandardWallet({
-            networkProvider,
-            walletStandardWallet
+    const switchActiveNetwork = async ({ networkId })=>switchActiveNetworkInLastKnownRegistry({
+            client: dynamicClient,
+            networkId,
+            walletProviderKey: key
         });
-    };
-    const signMessage = async ({ message, walletAccount })=>{
-        const signer = await getSigner(walletAccount);
-        const encodedMessage = new TextEncoder().encode(message);
-        const signedMessage = await signer.signMessage(encodedMessage, 'utf8');
-        assertDefined(signedMessage, 'Failed to sign message');
-        return {
-            signature: bufferToBase64(signedMessage.signature)
-        };
-    };
-    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 })=>{
+            const eventsFeature = features['standard:events'];
+            return eventsFeature.on('change', ({ accounts })=>{
                 var _accounts_map;
                 handleAccountsChanged({
                     addresses: (_accounts_map = accounts == null ? void 0 : accounts.map((account)=>account.address)) != null ? _accounts_map : []
@@ -277,27 +241,25 @@ const createWalletProviderFromSolanaStandardWallet = ({ dynamicClient, walletSta
         chain: 'SOL',
         connect,
         disconnect,
+        get events () {
+            return getEventEmitter();
+        },
         getActiveNetworkId,
         getConnectedAddresses,
-        getSigner,
-        getWalletProviderType: ()=>WalletProviderEnum.BrowserExtension,
         groupKey: formatWalletProviderGroupKey(walletStandardWallet.name),
         key,
         metadata: {
             displayName: walletStandardWallet.name,
             icon: walletStandardWallet.icon
         },
+        signAllTransactions,
+        signAndSendTransaction,
         signMessage,
+        signTransaction,
         switchActiveNetwork,
-        terminate
+        terminate,
+        walletProviderType
     };
-    // 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;
 };
 

package/addWaasSolanaExtension.cjs.js

@@ -6,7 +6,6 @@ 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.
@@ -30,66 +29,14 @@ var bs58 = require('bs58');
     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 walletProviderType = sdkApiCore.WalletProviderEnum.EmbeddedWallet;
+    const key = core.formatWalletProviderKey({
+        chain,
+        displayName: core$1.DYNAMIC_WAAS_METADATA.displayName,
+        walletProviderType
+    });
     const waasProvider = core$1.createWaasProvider({
         chain,
         sdkClient
@@ -111,22 +58,59 @@ const createWalletProviderForWaasSolana = (sdkClient)=>{
             addresses: waasSolanaAddresses
         };
     };
-    const signMessage = async ({ message, walletAccount })=>{
-        core.assertDefined(walletAccount, 'Wallet account is required');
-        return waasProvider.signMessage({
-            message,
+    const signAndSendTransaction = async ({ transaction, walletAccount })=>{
+        const { signedTransaction } = await signTransaction({
+            transaction,
             walletAccount
         });
-    };
-    const getSigner = async (walletAccount)=>{
-        core.assertDefined(walletAccount, 'Wallet account is required');
         const { networkData } = await client.getActiveNetworkData({
             walletAccount
         }, sdkClient);
         core.assertDefined(networkData, 'Network data is required');
-        return createSolanaSignerFromSolanaWaasProvider({
-            networkData,
-            waasProvider,
+        const connection = getSolanaConnection({
+            networkData
+        });
+        const rawTransaction = signedTransaction.serialize();
+        const signature = await connection.sendRawTransaction(rawTransaction);
+        return {
+            signature
+        };
+    };
+    const signTransaction = async ({ transaction, walletAccount })=>{
+        const messageBytes = isVersionedTransaction.isVersionedTransaction(transaction) ? transaction.message.serialize() : transaction.serializeMessage();
+        const serializedTransaction = core.getBuffer()// eslint-disable-next-line @typescript-eslint/no-explicit-any
+        .from(messageBytes).toString('hex');
+        const { signature } = await waasProvider.signSerializedTransaction({
+            serializedTransaction,
+            walletAccount
+        });
+        const publicKey = new web3_js.PublicKey(walletAccount.address);
+        transaction.addSignature(publicKey, // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        core.getBuffer().from(signature, 'hex'));
+        transaction.serialize({
+            requireAllSignatures: false,
+            verifySignatures: true
+        });
+        return {
+            signedTransaction: transaction
+        };
+    };
+    const signAllTransactions = async ({ transactions, walletAccount })=>{
+        const signedTransactions = await Promise.all(transactions.map(async (transaction)=>{
+            const { signedTransaction } = await signTransaction({
+                transaction,
+                walletAccount
+            });
+            return signedTransaction;
+        }));
+        return {
+            signedTransactions
+        };
+    };
+    const signMessage = async ({ message, walletAccount })=>{
+        core.assertDefined(walletAccount, 'Wallet account is required');
+        return waasProvider.signMessage({
+            message,
             walletAccount
         });
     };
@@ -134,16 +118,18 @@ const createWalletProviderForWaasSolana = (sdkClient)=>{
         chain,
         getActiveNetworkId,
         getConnectedAddresses,
-        getSigner,
-        getWalletProviderType: ()=>sdkApiCore.WalletProviderEnum.EmbeddedWallet,
-        groupKey: core.formatWalletProviderGroupKey(core$1.DYNAMIC_WAAS_METADATA.name),
+        groupKey: core.formatWalletProviderGroupKey(core$1.DYNAMIC_WAAS_METADATA.displayName),
         key,
         metadata: {
-            displayName: core$1.DYNAMIC_WAAS_METADATA.name,
+            displayName: core$1.DYNAMIC_WAAS_METADATA.displayName,
             icon: core$1.DYNAMIC_WAAS_METADATA.icon
         },
+        signAllTransactions,
+        signAndSendTransaction,
         signMessage,
-        switchActiveNetwork
+        signTransaction,
+        switchActiveNetwork,
+        walletProviderType
     });
 };