@dynamic-labs/sui-core 4.48.0 → 4.48.2

package/src/index.cjs

@@ -9,6 +9,7 @@ var constants = require('./utils/constants/constants.cjs');
 var SuiWalletConnector = require('./SuiWalletConnector.cjs');
 var SuiWallet = require('./wallet/SuiWallet.cjs');
 var isSuiWallet = require('./wallet/isSuiWallet/isSuiWallet.cjs');
+var Slush = require('./wallets/slush/Slush.cjs');
 var SuiUiTransaction = require('./utils/SuiUiTransaction/SuiUiTransaction.cjs');
 var fetchSuiInjectedWalletConnectors = require('./wallets/injected/fetchSuiInjectedWalletConnectors.cjs');
 
@@ -19,5 +20,6 @@ exports.MIST_PER_SUI = constants.MIST_PER_SUI;
 exports.SuiWalletConnector = SuiWalletConnector.SuiWalletConnector;
 exports.SuiWallet = SuiWallet.SuiWallet;
 exports.isSuiWallet = isSuiWallet.isSuiWallet;
+exports.Slush = Slush.Slush;
 exports.SuiUiTransaction = SuiUiTransaction.SuiUiTransaction;
 exports.fetchSuiInjectedWalletConnectors = fetchSuiInjectedWalletConnectors.fetchSuiInjectedWalletConnectors;

package/src/index.d.ts

@@ -2,6 +2,7 @@ export * from './utils/constants';
 export { SuiWalletConnector } from './SuiWalletConnector';
 export { SuiWallet } from './wallet/SuiWallet';
 export { isSuiWallet } from './wallet/isSuiWallet';
+export { Slush } from './wallets/slush';
 export type { SuiWalletConnectorProps, SuiSendBalanceProps } from './types';
 export { SuiUiTransaction } from './utils/SuiUiTransaction/SuiUiTransaction';
 export { fetchSuiInjectedWalletConnectors } from './wallets/injected/fetchSuiInjectedWalletConnectors';

package/src/index.js

@@ -5,6 +5,7 @@ export { MIST_PER_SUI } from './utils/constants/constants.js';
 export { SuiWalletConnector } from './SuiWalletConnector.js';
 export { SuiWallet } from './wallet/SuiWallet.js';
 export { isSuiWallet } from './wallet/isSuiWallet/isSuiWallet.js';
+export { Slush } from './wallets/slush/Slush.js';
 export { SuiUiTransaction } from './utils/SuiUiTransaction/SuiUiTransaction.js';
 export { fetchSuiInjectedWalletConnectors } from './wallets/injected/fetchSuiInjectedWalletConnectors.js';
 

package/src/wallets/injected/fetchSuiInjectedWalletConnectors.cjs

@@ -6,22 +6,33 @@ Object.defineProperty(exports, '__esModule', { value: true });
 var walletStandard = require('@mysten/wallet-standard');
 var utils = require('@dynamic-labs/utils');
 var walletConnectorCore = require('@dynamic-labs/wallet-connector-core');
+var Slush = require('../slush/Slush.cjs');
 var injected = require('./injected.cjs');
 
+// Wallets with custom connectors that should not be auto-generated
+const walletsWithCustomConnectors = {
+    slush: Slush.Slush,
+};
+const getCustomConnectorForKey = (name) => {
+    var _a;
+    return (_a = Object.entries(walletsWithCustomConnectors).find(([key]) => name.toLowerCase().includes(key.toLowerCase()))) === null || _a === void 0 ? void 0 : _a[1];
+};
 const fetchSuiInjectedWalletConnectors = ({ walletBook, }) => {
     var _a;
     const walletStandardWallets = walletStandard.getWallets().get();
     const suiWalletStandardWallets = walletStandardWallets.filter((wallet) => walletStandard.isWalletWithRequiredFeatureSet(wallet, ['sui:signPersonalMessage']));
     const suiWalletsByKey = Object.fromEntries(suiWalletStandardWallets.map((wallet) => [wallet.name, wallet]));
     const walletBookConnectors = Object.entries((_a = walletBook === null || walletBook === void 0 ? void 0 : walletBook.wallets) !== null && _a !== void 0 ? _a : {})
-        .filter(([, wallet]) => {
+        .filter(([key, wallet]) => {
         var _a, _b;
         const injectedConfig = (_a = wallet.injectedConfig) === null || _a === void 0 ? void 0 : _a.find((config) => config.chain === 'sui');
         const isSuiWallet = Boolean(injectedConfig);
         const walletStandardName = (_b = injectedConfig === null || injectedConfig === void 0 ? void 0 : injectedConfig.walletStandard) === null || _b === void 0 ? void 0 : _b.name;
         // If the wallet is injected via wallet standard, use that over the wallet book entry
         const shouldBeFiltered = walletStandardName && suiWalletsByKey[walletStandardName];
-        return isSuiWallet && !shouldBeFiltered;
+        // Filter out wallets that have custom connectors
+        const hasCustomConnector = Boolean(getCustomConnectorForKey(key));
+        return isSuiWallet && !shouldBeFiltered && !hasCustomConnector;
     })
         .map(([key, wallet]) => {
         // Currently we only support wallet standard wallets
@@ -44,7 +55,21 @@ const fetchSuiInjectedWalletConnectors = ({ walletBook, }) => {
         .filter((wallet) => { var _a; return (_a = wallet.features) === null || _a === void 0 ? void 0 : _a['sui:signPersonalMessage']; })
         .map((wallet) => {
         const sanitizedName = utils.sanitizeName(wallet.name);
+        const customConnector = getCustomConnectorForKey(sanitizedName);
         const isInstalled = true;
+        if (customConnector) {
+            return class extends customConnector {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                constructor(props) {
+                    super(wallet.name, isInstalled, Object.assign({ metadata: {
+                            groupKey: sanitizedName,
+                            icon: wallet.icon,
+                            id: wallet.name,
+                            name: wallet.name,
+                        }, name: wallet.name, overrideKey: `${sanitizedName}sui`, wallet: wallet }, props));
+                }
+            };
+        }
         return class extends injected.Injected {
             // eslint-disable-next-line @typescript-eslint/no-explicit-any
             constructor(props) {

package/src/wallets/injected/fetchSuiInjectedWalletConnectors.js

@@ -2,22 +2,33 @@
 import { getWallets, isWalletWithRequiredFeatureSet } from '@mysten/wallet-standard';
 import { sanitizeName } from '@dynamic-labs/utils';
 import { getWalletMetadataFromWalletBook } from '@dynamic-labs/wallet-connector-core';
+import { Slush } from '../slush/Slush.js';
 import { Injected } from './injected.js';
 
+// Wallets with custom connectors that should not be auto-generated
+const walletsWithCustomConnectors = {
+    slush: Slush,
+};
+const getCustomConnectorForKey = (name) => {
+    var _a;
+    return (_a = Object.entries(walletsWithCustomConnectors).find(([key]) => name.toLowerCase().includes(key.toLowerCase()))) === null || _a === void 0 ? void 0 : _a[1];
+};
 const fetchSuiInjectedWalletConnectors = ({ walletBook, }) => {
     var _a;
     const walletStandardWallets = getWallets().get();
     const suiWalletStandardWallets = walletStandardWallets.filter((wallet) => isWalletWithRequiredFeatureSet(wallet, ['sui:signPersonalMessage']));
     const suiWalletsByKey = Object.fromEntries(suiWalletStandardWallets.map((wallet) => [wallet.name, wallet]));
     const walletBookConnectors = Object.entries((_a = walletBook === null || walletBook === void 0 ? void 0 : walletBook.wallets) !== null && _a !== void 0 ? _a : {})
-        .filter(([, wallet]) => {
+        .filter(([key, wallet]) => {
         var _a, _b;
         const injectedConfig = (_a = wallet.injectedConfig) === null || _a === void 0 ? void 0 : _a.find((config) => config.chain === 'sui');
         const isSuiWallet = Boolean(injectedConfig);
         const walletStandardName = (_b = injectedConfig === null || injectedConfig === void 0 ? void 0 : injectedConfig.walletStandard) === null || _b === void 0 ? void 0 : _b.name;
         // If the wallet is injected via wallet standard, use that over the wallet book entry
         const shouldBeFiltered = walletStandardName && suiWalletsByKey[walletStandardName];
-        return isSuiWallet && !shouldBeFiltered;
+        // Filter out wallets that have custom connectors
+        const hasCustomConnector = Boolean(getCustomConnectorForKey(key));
+        return isSuiWallet && !shouldBeFiltered && !hasCustomConnector;
     })
         .map(([key, wallet]) => {
         // Currently we only support wallet standard wallets
@@ -40,7 +51,21 @@ const fetchSuiInjectedWalletConnectors = ({ walletBook, }) => {
         .filter((wallet) => { var _a; return (_a = wallet.features) === null || _a === void 0 ? void 0 : _a['sui:signPersonalMessage']; })
         .map((wallet) => {
         const sanitizedName = sanitizeName(wallet.name);
+        const customConnector = getCustomConnectorForKey(sanitizedName);
         const isInstalled = true;
+        if (customConnector) {
+            return class extends customConnector {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                constructor(props) {
+                    super(wallet.name, isInstalled, Object.assign({ metadata: {
+                            groupKey: sanitizedName,
+                            icon: wallet.icon,
+                            id: wallet.name,
+                            name: wallet.name,
+                        }, name: wallet.name, overrideKey: `${sanitizedName}sui`, wallet: wallet }, props));
+                }
+            };
+        }
         return class extends Injected {
             // eslint-disable-next-line @typescript-eslint/no-explicit-any
             constructor(props) {

package/src/wallets/slush/Slush.cjs

@@ -0,0 +1,307 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('../../../_virtual/_tslib.cjs');
+var utils = require('@dynamic-labs/utils');
+var networkHelpers = require('../../utils/network/networkHelpers.cjs');
+var injected = require('../injected/injected.cjs');
+
+/**
+ * Slush Wallet Connector with Multi-Account Support
+ *
+ * This connector extends the base Injected connector to support multiple
+ * wallet accounts per connection prompt. Unlike other Sui wallets that only
+ * allow one account at a time, Slush wallet can connect multiple accounts
+ * simultaneously.
+ *
+ * Key features:
+ * - Tracks multiple wallet accounts (accounts array)
+ * - Filters new accounts to allow only one new address per connection
+ * - Supports setting a primary account for operations
+ * - Handles account switching for transactions and signing
+ */
+class Slush extends injected.Injected {
+    constructor() {
+        super(...arguments);
+        this.name = 'Slush — A Sui wallet';
+        this.overrideKey = 'slushsui';
+        /** Tracks all wallet accounts returned by the wallet */
+        this.accounts = [];
+    }
+    /** Tracks the primary/active wallet account (first account by default) */
+    getPrimaryAccount() {
+        return this.accounts[0];
+    }
+    /**
+     * Set a specific account as the primary account by address.
+     * This moves the specified account to the front of the accounts array.
+     * @param address - The address of the account to set as primary
+     * @returns true if the account was found and set as primary, false otherwise
+     */
+    setPrimaryAccount(account) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            if (!account) {
+                this.accounts = [];
+                return;
+            }
+            return this.setPrimaryAccountAddress(account.address);
+        });
+    }
+    setPrimaryAccountAddress(address) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const accountIndex = this.accounts.findIndex((acc) => acc.address === address);
+            if (accountIndex === -1) {
+                this.logger.error(`[setPrimaryAccount] Account with address ${address} not found for ${this.name}`);
+                return false;
+            }
+            if (accountIndex === 0) {
+                // Already primary
+                return true;
+            }
+            // Move the account to the front
+            this.logger.debug(`[${this.name}] [setPrimaryAccount] Moving account to primary position`, {
+                accountIndex,
+                address,
+                currentAccountAddresses: this.accounts.map((acc) => acc.address),
+            });
+            const [targetAccount] = this.accounts.splice(accountIndex, 1);
+            this.accounts.unshift(targetAccount);
+            this.logger.debug(`[setPrimaryAccount] Set account ${address} as primary account for ${this.name}`);
+            // Update the active network ID based on the new primary account
+            const primaryChain = (_a = this.getPrimaryAccount()) === null || _a === void 0 ? void 0 : _a.chains[0];
+            if (primaryChain) {
+                this.activeNetworkId = networkHelpers.getSuiNetworkIdFromName(primaryChain, this.suiNetworks);
+            }
+            return true;
+        });
+    }
+    /**
+     * Connect to the wallet using the standard:connect feature.
+     *
+     * Any currently connected wallet will be disconnected first.
+     * This happens because we want the user to reselect which wallets they want connected.
+     *
+     * We only allow adding one new wallet connection per manual user connection.
+     */
+    connect() {
+        return _tslib.__awaiter(this, arguments, void 0, function* ({ silent = false, } = {}) {
+            var _a, _b, _c;
+            this.logger.debug(`[${this.name}] [connect] Initiating connection`, {
+                isConnecting: this.isConnecting,
+                silent,
+            });
+            if (this.isConnecting) {
+                return;
+            }
+            const connectFeature = (_a = this.getFeatures()) === null || _a === void 0 ? void 0 : _a['standard:connect'];
+            if (!connectFeature) {
+                if (silent) {
+                    return;
+                }
+                throw new utils.DynamicError('Wallet does not support standard:connect');
+            }
+            // Start connecting
+            this.isConnecting = true;
+            try {
+                const disconnectFeature = (_b = this.getFeatures()) === null || _b === void 0 ? void 0 : _b['standard:disconnect'];
+                if (disconnectFeature) {
+                    yield disconnectFeature.disconnect();
+                }
+                const response = yield connectFeature.connect(silent ? { silent } : undefined);
+                this.logger.debug(`[${this.name}] [connect] Connection returned accounts: ${response === null || response === void 0 ? void 0 : response.accounts.length}`);
+                this.logger.debug(`[${this.name}] [connect] Received accounts from wallet`, {
+                    accountAddresses: response === null || response === void 0 ? void 0 : response.accounts.map((acc) => acc.address),
+                    accountCount: response === null || response === void 0 ? void 0 : response.accounts.length,
+                });
+                // Store all accounts returned by the wallet (create a mutable copy)
+                const newAccounts = (response === null || response === void 0 ? void 0 : response.accounts) ? [...response.accounts] : [];
+                if (this.hasAccountsChanged(newAccounts)) {
+                    const filteredAccounts = this.filterAccountsForSingleWalletConstraint({
+                        newAccounts,
+                    });
+                    this.logger.logVerboseTroubleshootingMessage(`[${this.name}] [connect] Accounts changed, applying filter`, {
+                        currentAccounts: this.accounts.map((acc) => acc.address),
+                        newAccounts: filteredAccounts.map((acc) => acc.address),
+                    });
+                    this.accounts = filteredAccounts;
+                }
+                const primaryChain = (_c = this.getPrimaryAccount()) === null || _c === void 0 ? void 0 : _c.chains[0];
+                if (primaryChain) {
+                    this.activeNetworkId = networkHelpers.getSuiNetworkIdFromName(primaryChain, this.suiNetworks);
+                }
+            }
+            catch (error) {
+                this.logger.error(error);
+                if (silent) {
+                    return;
+                }
+                throw new utils.DynamicError('Connection failed');
+            }
+            finally {
+                this.isConnecting = false;
+            }
+            this.setupEventListeners();
+        });
+    }
+    validateActiveWallet(expectedAddress) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            const addresses = yield this.getConnectedAccounts();
+            const isWalletActive = addresses.find((address) => address === expectedAddress);
+            if (isWalletActive) {
+                return;
+            }
+            return this.handleWalletNotActive({
+                activeAddress: (yield this.getConnectedAccounts())[0],
+                expectedAddress,
+            });
+        });
+    }
+    /** Get the wallet address by connecting to the current account */
+    getAddress() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            this.logger.debug(`[${this.name}] [getAddress] called, attempting to obtain the account address`);
+            if (this.handleInAppBrowserGetAddress()) {
+                return;
+            }
+            const previousAddresses = this.accounts.map((account) => account.address);
+            yield this.connect();
+            const newAddresses = this.accounts.map((account) => account.address);
+            // If there is a new account, return the new address
+            const newAddress = newAddresses.find((address) => !previousAddresses.includes(address));
+            if (newAddress) {
+                yield this.setPrimaryAccountAddress(newAddress);
+                this.logger.debug(`[${this.name}] [getAddress] New account added`, {
+                    accountAddresses: this.accounts.map((acc) => acc.address),
+                    newAddress,
+                });
+                return newAddress;
+            }
+            this.logger.logVerboseTroubleshootingMessage(`[${this.name}] [setupEventListeners] No new address to add`, {
+                accountAddresses: this.accounts.map((acc) => acc.address),
+                newAddresses,
+            });
+            if (newAddresses.length === 0) {
+                throw new utils.DynamicError('No account found');
+            }
+            return newAddresses[0];
+        });
+    }
+    getConnectedAccounts() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            if (this.accounts.length === 0) {
+                yield this.connect({ silent: true });
+            }
+            // Return all connected account addresses
+            return this.accounts.map((account) => account.address);
+        });
+    }
+    /**
+     * Helper to check if accounts have changed by comparing addresses.
+     * Accounts are compared in a sorted order to handle cases where the order changes.
+     *
+     * @param newAccounts - The new accounts to compare against current accounts
+     * @returns true if accounts have changed, false otherwise
+     */
+    hasAccountsChanged(newAccounts) {
+        const currentAddresses = this.accounts
+            .map((acc) => acc.address)
+            .sort()
+            .join(',');
+        const newAddresses = newAccounts
+            .map((acc) => acc.address)
+            .sort()
+            .join(',');
+        return currentAddresses !== newAddresses;
+    }
+    /**
+     * Filters new accounts to enforce the SDK's single-wallet connection constraint.
+     * The Dynamic SDK only supports connecting one wallet at a time.
+     * This method ensures that at most one NEW address is added to the existing accounts.
+     *
+     * @param newAccounts - The new accounts returned by the wallet
+     * @returns Filtered accounts with at most one new address added
+     */
+    filterAccountsForSingleWalletConstraint({ newAccounts, }) {
+        if (this.accounts.length === 0) {
+            return [newAccounts[0]];
+        }
+        // Keep all currently connected accounts that are still in the new accounts list
+        const currentAddresses = new Set(this.accounts.map((acc) => acc.address.toLowerCase()));
+        const filteredAccounts = newAccounts.filter((acc) => currentAddresses.has(acc.address.toLowerCase()));
+        // Find new accounts that aren't in the current list
+        const trulyNewAccounts = newAccounts.filter((acc) => !currentAddresses.has(acc.address.toLowerCase()));
+        // Allow at most one new account to be added
+        if (trulyNewAccounts.length > 0) {
+            filteredAccounts.push(trulyNewAccounts[0]);
+        }
+        return filteredAccounts;
+    }
+    handleAccountChange() {
+        // We intentionally ignore account change events from Slush wallets.
+        // Slush wallets support connecting multiple accounts simultaneously,
+        // but the Dynamic SDK only supports connecting one wallet at a time.
+        // To enforce this constraint, we only allow adding new accounts through the connect()
+        // method, where we can properly filter and ensure at most one new account is added.
+        // Account change events are therefore ignored to prevent bypassing this limitation.
+    }
+    signMessage(messageToSign_1) {
+        const _super = Object.create(null, {
+            signMessage: { get: () => super.signMessage }
+        });
+        return _tslib.__awaiter(this, arguments, void 0, function* (messageToSign, { address } = {}) {
+            if (address) {
+                yield this.setPrimaryAccountAddress(address);
+            }
+            return _super.signMessage.call(this, messageToSign);
+        });
+    }
+    /** Function used to create transactions in the SDK interface */
+    createUiTransaction(from) {
+        const _super = Object.create(null, {
+            createUiTransaction: { get: () => super.createUiTransaction }
+        });
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            if (this.accounts.length === 0) {
+                throw new utils.DynamicError('No account connected');
+            }
+            yield this.setPrimaryAccountAddress(from);
+            return _super.createUiTransaction.call(this, from);
+        });
+    }
+    signAndExecuteTransactionFeature(_a) {
+        const _super = Object.create(null, {
+            signAndExecuteTransactionFeature: { get: () => super.signAndExecuteTransactionFeature }
+        });
+        return _tslib.__awaiter(this, arguments, void 0, function* ({ transaction, legacyOptions, }) {
+            const { sender } = transaction.getData();
+            if (sender) {
+                yield this.setPrimaryAccountAddress(sender);
+            }
+            return _super.signAndExecuteTransactionFeature.call(this, {
+                legacyOptions,
+                transaction,
+            });
+        });
+    }
+    signTransactionFeature(_a) {
+        const _super = Object.create(null, {
+            signTransactionFeature: { get: () => super.signTransactionFeature }
+        });
+        return _tslib.__awaiter(this, arguments, void 0, function* ({ transaction, }) {
+            const { sender } = transaction.getData();
+            if (sender) {
+                yield this.setPrimaryAccountAddress(sender);
+            }
+            return _super.signTransactionFeature.call(this, { transaction });
+        });
+    }
+}
+Object.defineProperty(Slush, 'key', {
+    value: 'slushsui',
+    writable: false,
+});
+
+exports.Slush = Slush;

package/src/wallets/slush/Slush.d.ts

@@ -0,0 +1,82 @@
+import { SuiSignAndExecuteTransactionBlockOutput, SuiSignAndExecuteTransactionOutput, WalletAccount, SignedTransaction, SuiSignTransactionBlockOutput } from '@mysten/wallet-standard';
+import { Transaction } from '@mysten/sui/transactions';
+import { ExecuteTransactionRequestType, SuiTransactionBlockResponseOptions } from '@mysten/sui/client';
+import { Injected } from '../injected/injected';
+/**
+ * Slush Wallet Connector with Multi-Account Support
+ *
+ * This connector extends the base Injected connector to support multiple
+ * wallet accounts per connection prompt. Unlike other Sui wallets that only
+ * allow one account at a time, Slush wallet can connect multiple accounts
+ * simultaneously.
+ *
+ * Key features:
+ * - Tracks multiple wallet accounts (accounts array)
+ * - Filters new accounts to allow only one new address per connection
+ * - Supports setting a primary account for operations
+ * - Handles account switching for transactions and signing
+ */
+export declare class Slush extends Injected {
+    name: string;
+    overrideKey: string;
+    /** Tracks all wallet accounts returned by the wallet */
+    protected accounts: WalletAccount[];
+    /** Tracks the primary/active wallet account (first account by default) */
+    getPrimaryAccount(): WalletAccount | undefined;
+    /**
+     * Set a specific account as the primary account by address.
+     * This moves the specified account to the front of the accounts array.
+     * @param address - The address of the account to set as primary
+     * @returns true if the account was found and set as primary, false otherwise
+     */
+    setPrimaryAccount(account: WalletAccount | undefined): Promise<boolean | undefined>;
+    private setPrimaryAccountAddress;
+    /**
+     * Connect to the wallet using the standard:connect feature.
+     *
+     * Any currently connected wallet will be disconnected first.
+     * This happens because we want the user to reselect which wallets they want connected.
+     *
+     * We only allow adding one new wallet connection per manual user connection.
+     */
+    connect({ silent, }?: {
+        silent?: boolean;
+    }): Promise<void>;
+    validateActiveWallet(expectedAddress: string): Promise<void>;
+    /** Get the wallet address by connecting to the current account */
+    getAddress(): Promise<string | undefined>;
+    getConnectedAccounts(): Promise<string[]>;
+    /**
+     * Helper to check if accounts have changed by comparing addresses.
+     * Accounts are compared in a sorted order to handle cases where the order changes.
+     *
+     * @param newAccounts - The new accounts to compare against current accounts
+     * @returns true if accounts have changed, false otherwise
+     */
+    private hasAccountsChanged;
+    /**
+     * Filters new accounts to enforce the SDK's single-wallet connection constraint.
+     * The Dynamic SDK only supports connecting one wallet at a time.
+     * This method ensures that at most one NEW address is added to the existing accounts.
+     *
+     * @param newAccounts - The new accounts returned by the wallet
+     * @returns Filtered accounts with at most one new address added
+     */
+    private filterAccountsForSingleWalletConstraint;
+    handleAccountChange(): void;
+    signMessage(messageToSign: string, { address }?: {
+        address?: string;
+    }): Promise<string | undefined>;
+    /** Function used to create transactions in the SDK interface */
+    createUiTransaction(from: string): Promise<import("dist/packages/types/src").IUITransaction>;
+    signAndExecuteTransactionFeature({ transaction, legacyOptions, }: {
+        transaction: Transaction;
+        legacyOptions?: {
+            options?: SuiTransactionBlockResponseOptions;
+            requestType?: ExecuteTransactionRequestType;
+        };
+    }): Promise<SuiSignAndExecuteTransactionOutput | SuiSignAndExecuteTransactionBlockOutput>;
+    signTransactionFeature({ transaction, }: {
+        transaction: Transaction;
+    }): Promise<SignedTransaction | SuiSignTransactionBlockOutput>;
+}