@dynamic-labs-sdk/sui 0.1.0-alpha.29 → 0.1.0-alpha.30

package/CHANGELOG.md

@@ -1,3 +1,11 @@
+## 0.1.0-alpha.30 (2025-11-19)
+
+### 🚀 Features
+
+- allow social account unlinking ([#618](https://github.com/dynamic-labs/dynamic-sdk/pull/618))
+- add support for Sui external wallets ([#643](https://github.com/dynamic-labs/dynamic-sdk/pull/643))
+- add support for Sui embedded wallets ([#652](https://github.com/dynamic-labs/dynamic-sdk/pull/652))
+
 ## 0.1.0-alpha.29 (2025-11-12)
 
 ### 🚀 Features

package/README.md

@@ -12,24 +12,10 @@ pnpm add @dynamic-labs-sdk/sui
 
 ```ts
 import { addSuiExtension } from '@dynamic-labs-sdk/sui';
+import { createDynamicClient } from '@dynamic-labs-sdk/client';
 
-// Assuming you have a DynamicClient instance
+const dynamicClient = createDynamicClient({
+  environmentId: '123',
+});
 addSuiExtension(dynamicClient);
 ```
-
-This will register all SUI-compatible wallets that implement the wallet standard with your Dynamic client.
-
-## Features
-
-- SUI wallet provider integration
-- SUI wallet standard support
-- Easy extension for Dynamic SDK
-
-## Requirements
-
-- [@dynamic-labs-sdk/client](https://www.npmjs.com/package/@dynamic-labs-sdk/client)
-- [@mysten/wallet-standard](https://www.npmjs.com/package/@mysten/wallet-standard)
-
-## License
-
-MIT

package/_extends.cjs.js

@@ -0,0 +1,19 @@
+'use strict';
+
+var name = "@dynamic-labs-sdk/sui";
+var version = "0.1.0-alpha.30";
+
+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);
+}
+
+exports._extends = _extends;
+exports.name = name;
+exports.version = version;

package/_extends.esm.js

@@ -0,0 +1,15 @@
+var name = "@dynamic-labs-sdk/sui";
+var version = "0.1.0-alpha.30";
+
+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);
+}
+
+export { _extends as _, name as n, version as v };

package/addSuiWalletStandardExtension.cjs.js

@@ -0,0 +1,303 @@
+'use strict';
+
+var core = require('@dynamic-labs-sdk/client/core');
+var walletStandard = require('@mysten/wallet-standard');
+var _extends = require('./_extends.cjs.js');
+var client = require('@mysten/sui/client');
+var utils = require('@mysten/sui/utils');
+var client$1 = require('@dynamic-labs-sdk/client');
+var sdkApiCore = require('@dynamic-labs/sdk-api-core');
+
+const fetchSuiBalance = async ({ address, rpcUrl })=>{
+    // Create a SuiClient using the provided RPC URL.
+    const suiClient = new client.SuiClient({
+        url: rpcUrl
+    });
+    const balanceInMist = await suiClient.getBalance({
+        owner: address
+    });
+    // Balance comes back as MIST, 1 SUI = 1e9 MIST
+    const balance = Number(balanceInMist.totalBalance) / Number(utils.MIST_PER_SUI);
+    if (Number.isNaN(balance)) {
+        return null;
+    }
+    return balance.toString();
+};
+
+const createSuiNetworkProvider = (networkData)=>_extends._extends({}, core.createBaseNetworkProvider('SUI', networkData), {
+        getBalance: async ({ address })=>({
+                balance: await fetchSuiBalance({
+                    address,
+                    rpcUrl: networkData.rpcUrls.http[0]
+                })
+            })
+    });
+
+const registerSuiNetworkProviderBuilder = (client)=>{
+    const networkProviderBuilderRegistry = core.getNetworkProviderBuilderRegistry(client);
+    /**
+   * If the Sui network provider builder is already registered, return.
+   */ if (networkProviderBuilderRegistry.get().get('SUI')) {
+        return;
+    }
+    networkProviderBuilderRegistry.register({
+        builder: createSuiNetworkProvider,
+        chain: 'SUI'
+    });
+};
+
+const createWalletProviderFromSuiStandardWallet = ({ dynamicClient, walletStandardWallet })=>{
+    const features = walletStandardWallet.features;
+    const walletProviderType = sdkApiCore.WalletProviderEnum.BrowserExtension;
+    const key = core.formatWalletProviderKey({
+        chain: 'SUI',
+        displayName: walletStandardWallet.name,
+        walletProviderType
+    });
+    const runConnectFeature = async ({ silent = false } = {})=>{
+        var _features_standardconnect, _result_accounts;
+        const connectMethod = (_features_standardconnect = features['standard:connect']) == null ? void 0 : _features_standardconnect.connect;
+        core.assertDefined(connectMethod, 'connect method not found in wallet features');
+        const result = await connectMethod({
+            silent
+        });
+        return {
+            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 connect = async ()=>{
+        const autoConnectedAccounts = walletStandardWallet.accounts;
+        if ((autoConnectedAccounts == null ? void 0 : autoConnectedAccounts.length) && autoConnectedAccounts[0].address) {
+            var _autoConnectedAccounts__publicKey;
+            return {
+                addresses: [
+                    {
+                        address: autoConnectedAccounts[0].address,
+                        publicKey: (_autoConnectedAccounts__publicKey = autoConnectedAccounts[0].publicKey) == null ? void 0 : _autoConnectedAccounts__publicKey.toString()
+                    }
+                ]
+            };
+        }
+        return runConnectFeature();
+    };
+    const disconnect = async ()=>{
+        var _features_standarddisconnect;
+        const disconnectMethod = (_features_standarddisconnect = features['standard:disconnect']) == null ? void 0 : _features_standarddisconnect.disconnect;
+        core.assertDefined(disconnectMethod, 'disconnect method not found in wallet features');
+        await disconnectMethod();
+    };
+    const getActiveNetworkId = async ()=>core.getActiveNetworkIdFromLastKnownRegistry({
+            client: dynamicClient,
+            walletProviderKey: key
+        });
+    const getCurrentAccount = async ()=>{
+        var _walletStandardWallet_accounts;
+        if (!isConnected()) {
+            await runConnectFeature({
+                silent: true
+            });
+        }
+        const account = (_walletStandardWallet_accounts = walletStandardWallet.accounts) == null ? void 0 : _walletStandardWallet_accounts[0];
+        core.assertDefined(account, 'No connected accounts found');
+        return account;
+    };
+    const getSuiClient = async ({ walletAccount })=>{
+        var _activeNetworkData_networkData;
+        const activeNetworkData = await client$1.getActiveNetworkData({
+            walletAccount
+        }, dynamicClient);
+        core.assertDefined(activeNetworkData, 'No active network data found');
+        const url = (_activeNetworkData_networkData = activeNetworkData.networkData) == null ? void 0 : _activeNetworkData_networkData.rpcUrls.http[0];
+        core.assertDefined(url, 'No RPC URL found for active network');
+        const client$2 = new client.SuiClient({
+            url
+        });
+        return client$2;
+    };
+    const isConnected = ()=>{
+        var _walletStandardWallet_accounts;
+        return ((_walletStandardWallet_accounts = walletStandardWallet.accounts) == null ? void 0 : _walletStandardWallet_accounts.length) > 0;
+    };
+    const getConnectedAddresses = async ()=>{
+        if (!isConnected()) {
+            await runConnectFeature({
+                silent: true
+            });
+        }
+        return {
+            addresses: walletStandardWallet.accounts.map((account)=>account.address)
+        };
+    };
+    const signAndExecuteTransaction = async ({ transaction, walletAccount })=>{
+        var _features_suisignAndExecuteTransaction;
+        await client$1.assertWalletAccountSigningAvailability({
+            walletAccount
+        }, dynamicClient);
+        const signAndExecuteTransactionMethod = (_features_suisignAndExecuteTransaction = features['sui:signAndExecuteTransaction']) == null ? void 0 : _features_suisignAndExecuteTransaction.signAndExecuteTransaction;
+        core.assertDefined(signAndExecuteTransactionMethod, 'signAndExecuteTransaction method not found in wallet features');
+        const account = await getCurrentAccount();
+        return signAndExecuteTransactionMethod({
+            account,
+            chain: account.chains[0],
+            transaction
+        });
+    };
+    /* This method is deprecated, but still required by some wallets for backwards compatibility. */ const signAndExecuteTransactionBlock = async ({ options, requestType, transactionBlock, walletAccount })=>{
+        var _features_suisignAndExecuteTransactionBlock;
+        await client$1.assertWalletAccountSigningAvailability({
+            walletAccount
+        }, dynamicClient);
+        const signAndExecuteTransactionBlockMethod = (_features_suisignAndExecuteTransactionBlock = features['sui:signAndExecuteTransactionBlock']) == null ? void 0 : _features_suisignAndExecuteTransactionBlock.signAndExecuteTransactionBlock;
+        core.assertDefined(signAndExecuteTransactionBlockMethod, 'signAndExecuteTransactionBlock method not found in wallet features');
+        const account = await getCurrentAccount();
+        return signAndExecuteTransactionBlockMethod({
+            account,
+            chain: account.chains[0],
+            options,
+            requestType,
+            transactionBlock
+        });
+    };
+    const signMessage = async ({ message, walletAccount })=>{
+        var _features_suisignPersonalMessage;
+        const signMessageMethod = (_features_suisignPersonalMessage = features['sui:signPersonalMessage']) == null ? void 0 : _features_suisignPersonalMessage.signPersonalMessage;
+        core.assertDefined(signMessageMethod, 'signPersonalMessage method not found in wallet features');
+        core.assertDefined(walletAccount, 'Wallet account not found');
+        await client$1.assertWalletAccountSigningAvailability({
+            walletAccount
+        }, dynamicClient);
+        const encodedMessage = new TextEncoder().encode(message);
+        const account = await getCurrentAccount();
+        const { signature } = await signMessageMethod({
+            account,
+            message: encodedMessage
+        });
+        return {
+            signature
+        };
+    };
+    const signTransaction = async ({ transaction, walletAccount })=>{
+        var _features_suisignTransaction;
+        const signTransactionMethod = (_features_suisignTransaction = features['sui:signTransaction']) == null ? void 0 : _features_suisignTransaction.signTransaction;
+        core.assertDefined(signTransactionMethod, 'signTransaction method not found in wallet features');
+        await client$1.assertWalletAccountSigningAvailability({
+            walletAccount
+        }, dynamicClient);
+        const account = await getCurrentAccount();
+        return signTransactionMethod({
+            account,
+            chain: account.chains[0],
+            transaction
+        });
+    };
+    /* This method is deprecated, but still required by some wallets for backwards compatibility. */ const signTransactionBlock = async ({ transactionBlock, walletAccount })=>{
+        var _features_suisignTransactionBlock;
+        const signTransactionBlockMethod = (_features_suisignTransactionBlock = features['sui:signTransactionBlock']) == null ? void 0 : _features_suisignTransactionBlock.signTransactionBlock;
+        core.assertDefined(signTransactionBlockMethod, 'signTransactionBlock method not found in wallet features');
+        await client$1.assertWalletAccountSigningAvailability({
+            walletAccount
+        }, dynamicClient);
+        const account = await getCurrentAccount();
+        return signTransactionBlockMethod({
+            account,
+            chain: account.chains[0],
+            transactionBlock
+        });
+    };
+    const switchActiveNetwork = async ({ networkId })=>core.switchActiveNetworkInLastKnownRegistry({
+            client: dynamicClient,
+            networkId,
+            walletProviderKey: key
+        });
+    const { getEventEmitter, cleanupEventEmitter } = core.createWalletProviderEventEmitter({
+        removeEventListeners: ({ setupReturnValue })=>{
+            core.assertDefined(setupReturnValue, 'Setup return value not defined');
+            setupReturnValue();
+        },
+        setupEventListeners: ({ handleAccountsChanged })=>{
+            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 : []
+                });
+            });
+        },
+        supportedEvents: [
+            'accountsChanged'
+        ]
+    });
+    const terminate = async ()=>{
+        cleanupEventEmitter();
+    };
+    const walletProvider = {
+        chain: 'SUI',
+        connect,
+        disconnect,
+        get events () {
+            return getEventEmitter();
+        },
+        getActiveNetworkId,
+        getConnectedAddresses,
+        getSuiClient,
+        groupKey: core.formatWalletProviderGroupKey(walletStandardWallet.name),
+        key,
+        metadata: {
+            displayName: walletStandardWallet.name,
+            icon: walletStandardWallet.icon
+        },
+        signAndExecuteTransaction,
+        signAndExecuteTransactionBlock,
+        signMessage,
+        signTransaction,
+        signTransactionBlock,
+        switchActiveNetwork,
+        terminate,
+        walletProviderType
+    };
+    return walletProvider;
+};
+
+const SUI_WALLET_STANDARD_EXTENSION_KEY = 'suiWalletStandard';
+/**
+ * Adds the Sui Wallet Standard extension to the Dynamic client.
+ *
+ * This extension enables integration with wallets that implement the Sui 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 addSuiWalletStandardExtension = (client = core.getDefaultClient())=>{
+    if (core.hasExtension({
+        extensionKey: SUI_WALLET_STANDARD_EXTENSION_KEY
+    }, client)) {
+        return;
+    }
+    core.registerExtension({
+        extensionKey: SUI_WALLET_STANDARD_EXTENSION_KEY
+    }, client);
+    registerSuiNetworkProviderBuilder(client);
+    const walletProviderRegistry = core.getWalletProviderRegistry(client);
+    const walletStandardWallets = walletStandard.getWallets().get().filter((wallet)=>walletStandard.isWalletWithRequiredFeatureSet(wallet, [
+            'standard:events',
+            'standard:connect',
+            'sui:signPersonalMessage'
+        ]));
+    walletStandardWallets.forEach((walletStandardWallet)=>{
+        const walletProvider = createWalletProviderFromSuiStandardWallet({
+            dynamicClient: client,
+            walletStandardWallet
+        });
+        walletProviderRegistry.register({
+            priority: core.WalletProviderPriority.WALLET_SELF_ANNOUNCEMENT_STANDARD,
+            walletProvider
+        });
+    });
+};
+
+exports.addSuiWalletStandardExtension = addSuiWalletStandardExtension;

package/addSuiWalletStandardExtension.esm.js

@@ -0,0 +1,301 @@
+import { createBaseNetworkProvider, getNetworkProviderBuilderRegistry, formatWalletProviderKey, createWalletProviderEventEmitter, assertDefined, formatWalletProviderGroupKey, switchActiveNetworkInLastKnownRegistry, getActiveNetworkIdFromLastKnownRegistry, getDefaultClient, hasExtension, registerExtension, getWalletProviderRegistry, WalletProviderPriority } from '@dynamic-labs-sdk/client/core';
+import { getWallets, isWalletWithRequiredFeatureSet } from '@mysten/wallet-standard';
+import { _ as _extends } from './_extends.esm.js';
+import { SuiClient } from '@mysten/sui/client';
+import { MIST_PER_SUI } from '@mysten/sui/utils';
+import { assertWalletAccountSigningAvailability, getActiveNetworkData } from '@dynamic-labs-sdk/client';
+import { WalletProviderEnum } from '@dynamic-labs/sdk-api-core';
+
+const fetchSuiBalance = async ({ address, rpcUrl })=>{
+    // Create a SuiClient using the provided RPC URL.
+    const suiClient = new SuiClient({
+        url: rpcUrl
+    });
+    const balanceInMist = await suiClient.getBalance({
+        owner: address
+    });
+    // Balance comes back as MIST, 1 SUI = 1e9 MIST
+    const balance = Number(balanceInMist.totalBalance) / Number(MIST_PER_SUI);
+    if (Number.isNaN(balance)) {
+        return null;
+    }
+    return balance.toString();
+};
+
+const createSuiNetworkProvider = (networkData)=>_extends({}, createBaseNetworkProvider('SUI', networkData), {
+        getBalance: async ({ address })=>({
+                balance: await fetchSuiBalance({
+                    address,
+                    rpcUrl: networkData.rpcUrls.http[0]
+                })
+            })
+    });
+
+const registerSuiNetworkProviderBuilder = (client)=>{
+    const networkProviderBuilderRegistry = getNetworkProviderBuilderRegistry(client);
+    /**
+   * If the Sui network provider builder is already registered, return.
+   */ if (networkProviderBuilderRegistry.get().get('SUI')) {
+        return;
+    }
+    networkProviderBuilderRegistry.register({
+        builder: createSuiNetworkProvider,
+        chain: 'SUI'
+    });
+};
+
+const createWalletProviderFromSuiStandardWallet = ({ dynamicClient, walletStandardWallet })=>{
+    const features = walletStandardWallet.features;
+    const walletProviderType = WalletProviderEnum.BrowserExtension;
+    const key = formatWalletProviderKey({
+        chain: 'SUI',
+        displayName: walletStandardWallet.name,
+        walletProviderType
+    });
+    const runConnectFeature = async ({ silent = false } = {})=>{
+        var _features_standardconnect, _result_accounts;
+        const connectMethod = (_features_standardconnect = features['standard:connect']) == null ? void 0 : _features_standardconnect.connect;
+        assertDefined(connectMethod, 'connect method not found in wallet features');
+        const result = await connectMethod({
+            silent
+        });
+        return {
+            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 connect = async ()=>{
+        const autoConnectedAccounts = walletStandardWallet.accounts;
+        if ((autoConnectedAccounts == null ? void 0 : autoConnectedAccounts.length) && autoConnectedAccounts[0].address) {
+            var _autoConnectedAccounts__publicKey;
+            return {
+                addresses: [
+                    {
+                        address: autoConnectedAccounts[0].address,
+                        publicKey: (_autoConnectedAccounts__publicKey = autoConnectedAccounts[0].publicKey) == null ? void 0 : _autoConnectedAccounts__publicKey.toString()
+                    }
+                ]
+            };
+        }
+        return runConnectFeature();
+    };
+    const disconnect = async ()=>{
+        var _features_standarddisconnect;
+        const disconnectMethod = (_features_standarddisconnect = features['standard:disconnect']) == null ? void 0 : _features_standarddisconnect.disconnect;
+        assertDefined(disconnectMethod, 'disconnect method not found in wallet features');
+        await disconnectMethod();
+    };
+    const getActiveNetworkId = async ()=>getActiveNetworkIdFromLastKnownRegistry({
+            client: dynamicClient,
+            walletProviderKey: key
+        });
+    const getCurrentAccount = async ()=>{
+        var _walletStandardWallet_accounts;
+        if (!isConnected()) {
+            await runConnectFeature({
+                silent: true
+            });
+        }
+        const account = (_walletStandardWallet_accounts = walletStandardWallet.accounts) == null ? void 0 : _walletStandardWallet_accounts[0];
+        assertDefined(account, 'No connected accounts found');
+        return account;
+    };
+    const getSuiClient = async ({ walletAccount })=>{
+        var _activeNetworkData_networkData;
+        const activeNetworkData = await getActiveNetworkData({
+            walletAccount
+        }, dynamicClient);
+        assertDefined(activeNetworkData, 'No active network data found');
+        const url = (_activeNetworkData_networkData = activeNetworkData.networkData) == null ? void 0 : _activeNetworkData_networkData.rpcUrls.http[0];
+        assertDefined(url, 'No RPC URL found for active network');
+        const client = new SuiClient({
+            url
+        });
+        return client;
+    };
+    const isConnected = ()=>{
+        var _walletStandardWallet_accounts;
+        return ((_walletStandardWallet_accounts = walletStandardWallet.accounts) == null ? void 0 : _walletStandardWallet_accounts.length) > 0;
+    };
+    const getConnectedAddresses = async ()=>{
+        if (!isConnected()) {
+            await runConnectFeature({
+                silent: true
+            });
+        }
+        return {
+            addresses: walletStandardWallet.accounts.map((account)=>account.address)
+        };
+    };
+    const signAndExecuteTransaction = async ({ transaction, walletAccount })=>{
+        var _features_suisignAndExecuteTransaction;
+        await assertWalletAccountSigningAvailability({
+            walletAccount
+        }, dynamicClient);
+        const signAndExecuteTransactionMethod = (_features_suisignAndExecuteTransaction = features['sui:signAndExecuteTransaction']) == null ? void 0 : _features_suisignAndExecuteTransaction.signAndExecuteTransaction;
+        assertDefined(signAndExecuteTransactionMethod, 'signAndExecuteTransaction method not found in wallet features');
+        const account = await getCurrentAccount();
+        return signAndExecuteTransactionMethod({
+            account,
+            chain: account.chains[0],
+            transaction
+        });
+    };
+    /* This method is deprecated, but still required by some wallets for backwards compatibility. */ const signAndExecuteTransactionBlock = async ({ options, requestType, transactionBlock, walletAccount })=>{
+        var _features_suisignAndExecuteTransactionBlock;
+        await assertWalletAccountSigningAvailability({
+            walletAccount
+        }, dynamicClient);
+        const signAndExecuteTransactionBlockMethod = (_features_suisignAndExecuteTransactionBlock = features['sui:signAndExecuteTransactionBlock']) == null ? void 0 : _features_suisignAndExecuteTransactionBlock.signAndExecuteTransactionBlock;
+        assertDefined(signAndExecuteTransactionBlockMethod, 'signAndExecuteTransactionBlock method not found in wallet features');
+        const account = await getCurrentAccount();
+        return signAndExecuteTransactionBlockMethod({
+            account,
+            chain: account.chains[0],
+            options,
+            requestType,
+            transactionBlock
+        });
+    };
+    const signMessage = async ({ message, walletAccount })=>{
+        var _features_suisignPersonalMessage;
+        const signMessageMethod = (_features_suisignPersonalMessage = features['sui:signPersonalMessage']) == null ? void 0 : _features_suisignPersonalMessage.signPersonalMessage;
+        assertDefined(signMessageMethod, 'signPersonalMessage 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 { signature } = await signMessageMethod({
+            account,
+            message: encodedMessage
+        });
+        return {
+            signature
+        };
+    };
+    const signTransaction = async ({ transaction, walletAccount })=>{
+        var _features_suisignTransaction;
+        const signTransactionMethod = (_features_suisignTransaction = features['sui:signTransaction']) == null ? void 0 : _features_suisignTransaction.signTransaction;
+        assertDefined(signTransactionMethod, 'signTransaction method not found in wallet features');
+        await assertWalletAccountSigningAvailability({
+            walletAccount
+        }, dynamicClient);
+        const account = await getCurrentAccount();
+        return signTransactionMethod({
+            account,
+            chain: account.chains[0],
+            transaction
+        });
+    };
+    /* This method is deprecated, but still required by some wallets for backwards compatibility. */ const signTransactionBlock = async ({ transactionBlock, walletAccount })=>{
+        var _features_suisignTransactionBlock;
+        const signTransactionBlockMethod = (_features_suisignTransactionBlock = features['sui:signTransactionBlock']) == null ? void 0 : _features_suisignTransactionBlock.signTransactionBlock;
+        assertDefined(signTransactionBlockMethod, 'signTransactionBlock method not found in wallet features');
+        await assertWalletAccountSigningAvailability({
+            walletAccount
+        }, dynamicClient);
+        const account = await getCurrentAccount();
+        return signTransactionBlockMethod({
+            account,
+            chain: account.chains[0],
+            transactionBlock
+        });
+    };
+    const switchActiveNetwork = async ({ networkId })=>switchActiveNetworkInLastKnownRegistry({
+            client: dynamicClient,
+            networkId,
+            walletProviderKey: key
+        });
+    const { getEventEmitter, cleanupEventEmitter } = createWalletProviderEventEmitter({
+        removeEventListeners: ({ setupReturnValue })=>{
+            assertDefined(setupReturnValue, 'Setup return value not defined');
+            setupReturnValue();
+        },
+        setupEventListeners: ({ handleAccountsChanged })=>{
+            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 : []
+                });
+            });
+        },
+        supportedEvents: [
+            'accountsChanged'
+        ]
+    });
+    const terminate = async ()=>{
+        cleanupEventEmitter();
+    };
+    const walletProvider = {
+        chain: 'SUI',
+        connect,
+        disconnect,
+        get events () {
+            return getEventEmitter();
+        },
+        getActiveNetworkId,
+        getConnectedAddresses,
+        getSuiClient,
+        groupKey: formatWalletProviderGroupKey(walletStandardWallet.name),
+        key,
+        metadata: {
+            displayName: walletStandardWallet.name,
+            icon: walletStandardWallet.icon
+        },
+        signAndExecuteTransaction,
+        signAndExecuteTransactionBlock,
+        signMessage,
+        signTransaction,
+        signTransactionBlock,
+        switchActiveNetwork,
+        terminate,
+        walletProviderType
+    };
+    return walletProvider;
+};
+
+const SUI_WALLET_STANDARD_EXTENSION_KEY = 'suiWalletStandard';
+/**
+ * Adds the Sui Wallet Standard extension to the Dynamic client.
+ *
+ * This extension enables integration with wallets that implement the Sui 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 addSuiWalletStandardExtension = (client = getDefaultClient())=>{
+    if (hasExtension({
+        extensionKey: SUI_WALLET_STANDARD_EXTENSION_KEY
+    }, client)) {
+        return;
+    }
+    registerExtension({
+        extensionKey: SUI_WALLET_STANDARD_EXTENSION_KEY
+    }, client);
+    registerSuiNetworkProviderBuilder(client);
+    const walletProviderRegistry = getWalletProviderRegistry(client);
+    const walletStandardWallets = getWallets().get().filter((wallet)=>isWalletWithRequiredFeatureSet(wallet, [
+            'standard:events',
+            'standard:connect',
+            'sui:signPersonalMessage'
+        ]));
+    walletStandardWallets.forEach((walletStandardWallet)=>{
+        const walletProvider = createWalletProviderFromSuiStandardWallet({
+            dynamicClient: client,
+            walletStandardWallet
+        });
+        walletProviderRegistry.register({
+            priority: WalletProviderPriority.WALLET_SELF_ANNOUNCEMENT_STANDARD,
+            walletProvider
+        });
+    });
+};
+
+export { addSuiWalletStandardExtension as a };