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

package/addSolanaWalletStandardExtension.cjs.js

@@ -24,6 +24,7 @@ const fetchSolBalance = async ({ address, rpcUrl })=>{
 
 const createSolanaNetworkProvider = (networkData)=>isVersionedTransaction._extends({}, core.createBaseNetworkProvider('SOL', networkData), {
         cluster: networkData.cluster,
+        genesisHash: networkData.genesisHash,
         getBalance: async ({ address })=>({
                 balance: await fetchSolBalance({
                     address,
@@ -45,36 +46,28 @@ const registerSolanaNetworkProviderBuilder = (client)=>{
     });
 };
 
+const getActiveNetworkCluster = async ({ walletAccount }, client$1)=>{
+    const { networkData } = await client.getActiveNetworkData({
+        walletAccount
+    }, client$1);
+    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 web3_js.PublicKey(walletStandardWallet.accounts[0].publicKey);
-    };
-    const getChain = ()=>{
-        core.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];
-        core.assertDefined(account, 'No connected accounts found');
-        return account;
-    };
+    const walletProviderType = sdkApiCore.WalletProviderEnum.BrowserExtension;
+    const key = core.formatWalletProviderKey({
+        chain: 'SOL',
+        displayName: walletStandardWallet.name,
+        walletProviderType
+    });
     const connect = async ()=>{
         var _features_standardconnect, _result_accounts;
         const autoConnectedAccounts = walletStandardWallet.accounts;
@@ -83,8 +76,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;
@@ -92,11 +89,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];
-        core.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 ()=>{
@@ -105,53 +105,58 @@ const createSolanaSignerFromSolanaStandardWallet = ({ networkProvider, walletSta
         core.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 ()=>core.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];
+        core.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;
-        core.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.isVersionedTransaction(transaction)) {
-            return web3_js.VersionedTransaction.deserialize(signedTransaction);
-        }
-        return web3_js.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 client.assertWalletAccountSigningAvailability({
+            walletAccount
+        }, dynamicClient);
         const signAndSendTransactionMethod = (_features_solanasignAndSendTransaction = features['solana:signAndSendTransaction']) == null ? void 0 : _features_solanasignAndSendTransaction.signAndSendTransaction;
         core.assertDefined(signAndSendTransactionMethod, 'signAndSendTransaction method not found in wallet features');
         const account = await getCurrentAccount();
+        const chain = await getActiveNetworkCluster({
+            walletAccount
+        }, dynamicClient);
+        core.assertDefined(chain, 'Could not get active chain for wallet account');
         const signedTransactions = await signAndSendTransactionMethod({
             account,
-            chain: getChain(),
+            chain,
             transaction: transaction.serialize({
                 requireAllSignatures: false
             })
@@ -161,107 +166,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;
         core.assertDefined(signMessageMethod, 'signMessage method not found in wallet features');
+        core.assertDefined(walletAccount, 'Wallet account not found');
+        await client.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: core.bufferToBase64(messages[0].signature)
         };
     };
-    return isVersionedTransaction._extends({}, isVersionedTransaction.createEmptyEventEmitter(), {
-        connect,
-        disconnect,
-        get isConnected () {
-            return isConnected();
-        },
-        on,
-        providers: [],
-        get publicKey () {
-            return getPublicKey();
-        },
-        signAllTransactions,
-        signAndSendTransaction,
-        signMessage,
-        signTransaction
-    });
-};
-
-const createWalletProviderFromSolanaStandardWallet = ({ dynamicClient, walletStandardWallet })=>{
-    const key = core.formatWalletProviderKey(walletStandardWallet.name, 'SOL');
-    const getActiveNetworkId = async ()=>core.getActiveNetworkIdFromLastKnownRegistry({
-            client: dynamicClient,
-            walletProviderKey: key
-        });
-    const switchActiveNetwork = async ({ networkId })=>core.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;
+        core.assertDefined(signMessageMethod, 'signTransaction method not found in wallet features');
+        await client.assertWalletAccountSigningAvailability({
+            walletAccount
+        }, dynamicClient);
+        const account = await getCurrentAccount();
+        const chain = await getActiveNetworkCluster({
+            walletAccount
+        }, dynamicClient);
+        core.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.isVersionedTransaction(transaction)) {
+            return {
+                signedTransaction: web3_js.VersionedTransaction.deserialize(signedTransaction)
+            };
         }
         return {
-            addresses: walletStandardWallet.accounts.map((account)=>account.address)
+            signedTransaction: web3_js.Transaction.from(signedTransaction)
         };
     };
-    const getSigner = async (walletAccount)=>{
-        if (walletAccount) {
-            await client.assertWalletAccountSigningAvailability({
-                walletAccount
-            }, dynamicClient);
-        }
-        const { networkId } = await getActiveNetworkId();
-        const networkProvider = core.getNetworkProviderFromNetworkId({
-            chain: 'SOL',
-            networkId
-        }, dynamicClient);
-        return createSolanaSignerFromSolanaStandardWallet({
-            networkProvider,
-            walletStandardWallet
+    const switchActiveNetwork = async ({ networkId })=>core.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');
-        core.assertDefined(signedMessage, 'Failed to sign message');
-        return {
-            signature: core.bufferToBase64(signedMessage.signature)
-        };
-    };
-    const getEventsFeature = ()=>{
-        const features = getFeaturesForSolanaStandardWallet(walletStandardWallet);
-        const eventsFeature = features['standard:events'];
-        return eventsFeature;
-    };
     const { getEventEmitter, cleanupEventEmitter } = core.createWalletProviderEventEmitter({
         removeEventListeners: ({ setupReturnValue })=>{
             core.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 : []
@@ -279,27 +243,25 @@ const createWalletProviderFromSolanaStandardWallet = ({ dynamicClient, walletSta
         chain: 'SOL',
         connect,
         disconnect,
+        get events () {
+            return getEventEmitter();
+        },
         getActiveNetworkId,
         getConnectedAddresses,
-        getSigner,
-        getWalletProviderType: ()=>sdkApiCore.WalletProviderEnum.BrowserExtension,
         groupKey: core.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;
 };