@dynamic-labs/sui-core 4.19.7

package/src/SuiWalletConnector.js

@@ -0,0 +1,302 @@
+'use client'
+import { __awaiter } from '../_virtual/_tslib.js';
+import { SuiClient } from '@mysten/sui/client';
+import { WalletConnectorBase } from '@dynamic-labs/wallet-connector-core';
+import { DynamicError } from '@dynamic-labs/utils';
+import { Logger } from '@dynamic-labs/logger';
+import { SuiWallet } from './wallet/SuiWallet.js';
+import { getSuiNetworkIdFromName, getPreferredRpcUrl } from './utils/network/networkHelpers.js';
+import { SuiUiTransaction } from './utils/SuiUiTransaction/SuiUiTransaction.js';
+
+class SuiWalletConnector extends WalletConnectorBase {
+    constructor(name, opts) {
+        super(opts);
+        this.name = 'Sui';
+        this.ChainWallet = SuiWallet;
+        this.connectedChain = 'SUI';
+        this.supportedChains = ['SUI'];
+        this.switchNetworkOnlyFromWallet = true;
+        /** required for metamask snap integration as MM snaps don't have event listeners */
+        this.canSetEventListeners = true;
+        /** Sui clients */
+        this.suiClients = {};
+        /** Whether the connector is currently attempting to connect */
+        this.isConnecting = false;
+        this.name = name;
+        this.wallet = opts.wallet;
+        this.chainRpcProviders = opts.chainRpcProviders;
+        this.suiNetworks = opts.suiNetworks;
+        this.logger = new Logger(this.name);
+    }
+    /** Helper to return the wallet features */
+    getFeatures() {
+        var _a;
+        return (_a = this.wallet) === null || _a === void 0 ? void 0 : _a.features;
+    }
+    /** Connect to the wallet using the standard:connect feature */
+    connect() {
+        return __awaiter(this, arguments, void 0, function* ({ silent } = {}) {
+            var _a, _b;
+            if (this.account || this.isConnecting) {
+                // Account is already connected or we're already connecting
+                return;
+            }
+            const connectFeature = (_a = this.getFeatures()) === null || _a === void 0 ? void 0 : _a['standard:connect'];
+            if (!connectFeature) {
+                if (silent) {
+                    return;
+                }
+                throw new DynamicError('Wallet does not support standard:connect');
+            }
+            // Start connecting
+            this.isConnecting = true;
+            this.logger.debug('[connect] Creating new connection');
+            try {
+                const response = yield connectFeature.connect(silent ? { silent } : undefined);
+                this.logger.debug(`[connect] Connection returned accounts: ${response === null || response === void 0 ? void 0 : response.accounts.length}`);
+                this.account = response === null || response === void 0 ? void 0 : response.accounts[0];
+                const primaryChain = (_b = this.account) === null || _b === void 0 ? void 0 : _b.chains[0];
+                if (primaryChain) {
+                    this.activeNetworkId = getSuiNetworkIdFromName(primaryChain, this.suiNetworks);
+                }
+            }
+            catch (error) {
+                this.logger.error(error);
+                if (silent) {
+                    return;
+                }
+                throw new DynamicError('Connection failed');
+            }
+            finally {
+                this.isConnecting = false;
+            }
+            this.setupEventListeners();
+        });
+    }
+    /** Get the wallet address by connecting to the current account */
+    getAddress() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.logger.debug('[getAddress] called, attempting to obtain the account address');
+            yield this.connect();
+            if (!this.account) {
+                throw new DynamicError('No account found');
+            }
+            return this.account.address;
+        });
+    }
+    /** Returns the network id of the account's active chain */
+    getNetwork() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.account) {
+                yield this.connect();
+            }
+            return this.activeNetworkId;
+        });
+    }
+    getConnectedAccounts() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            if (!this.account) {
+                yield this.connect({ silent: true });
+            }
+            const address = (_a = this.account) === null || _a === void 0 ? void 0 : _a.address;
+            if (address) {
+                return [address];
+            }
+            return [];
+        });
+    }
+    /**
+     * Helper to get the chain id from a [SuiChangeEvent].
+     *
+     * Some wallets set the event.chains objects but others use event.accounts.chains,
+     * so we need to deal with both cases.
+     *
+     * @param event - The [SuiChangeEvent] to get the chain id from
+     * @returns The dynamic chain id or '-1' if the chain id is not found
+     */
+    getChainFromEvent(event) {
+        var _a, _b, _c, _d, _e;
+        let suiChain = (_a = event.chains) === null || _a === void 0 ? void 0 : _a[0];
+        if (!suiChain) {
+            suiChain = (_d = (_c = (_b = event.accounts) === null || _b === void 0 ? void 0 : _b[0]) === null || _c === void 0 ? void 0 : _c.chains) === null || _d === void 0 ? void 0 : _d[0];
+        }
+        if (!suiChain) {
+            return '-1';
+        }
+        return (_e = getSuiNetworkIdFromName(suiChain, this.suiNetworks)) !== null && _e !== void 0 ? _e : '-1';
+    }
+    setupEventListeners() {
+        var _a;
+        if (!this.canSetEventListeners || this.eventsHandler)
+            return;
+        const eventsFeature = (_a = this.getFeatures()) === null || _a === void 0 ? void 0 : _a['standard:events'];
+        if (!eventsFeature) {
+            this.logger.debug('[setupEventListeners] Wallet not connected or does not support standard:events');
+            return;
+        }
+        this.eventsHandler = (event) => __awaiter(this, void 0, void 0, function* () {
+            var _b;
+            if (event.accounts) {
+                // If the event sets accounts but it's empty, we need to disconnect.
+                if (event.accounts.length === 0 && this.account) {
+                    this.account = undefined;
+                    this.emit('disconnect');
+                    return;
+                }
+                const [primaryAccount] = event.accounts;
+                if (primaryAccount.address !== ((_b = this.account) === null || _b === void 0 ? void 0 : _b.address)) {
+                    this.account = primaryAccount;
+                    this.emit('accountChange', { accounts: [primaryAccount.address] });
+                }
+            }
+            // Some events will leave out accounts but set the chains object, so we process those
+            // with the helper.
+            const suiChainId = this.getChainFromEvent(event);
+            if (suiChainId !== this.activeNetworkId) {
+                this.activeNetworkId = suiChainId;
+                this.emit('chainChange', { chain: suiChainId });
+            }
+        });
+        this.logger.debug('[setupEventListeners] Setting up sui wallet connector event listeners');
+        this.eventsUnsubscribeHandler = eventsFeature.on('change', this.eventsHandler);
+    }
+    /**
+     * Helper to get the Sui client for the current network
+     *
+     * The client will prefer the private customer rpc url if available.
+     */
+    getSuiClient(networkId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const clientNetworkId = networkId !== null && networkId !== void 0 ? networkId : (yield this.getNetwork());
+            if (!clientNetworkId) {
+                this.logger.error('[getSuiClient] Failed to get network id');
+                return undefined;
+            }
+            // Default to an existing client if available
+            if (this.suiClients[clientNetworkId]) {
+                return this.suiClients[clientNetworkId];
+            }
+            const network = this.getEnabledNetworks().find((network) => network.networkId === clientNetworkId);
+            const url = network ? getPreferredRpcUrl(network) : undefined;
+            if (!url) {
+                this.logger.error('[getSuiClient] Failed to get network url');
+                return undefined;
+            }
+            this.suiClients[clientNetworkId] = new SuiClient({
+                url: url,
+            });
+            return this.suiClients[clientNetworkId];
+        });
+    }
+    getBalance(address) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const client = yield this.getSuiClient();
+            if (!client) {
+                this.logger.error('[getBalance] Failed to get Sui client');
+                return undefined;
+            }
+            const balanceResult = yield client.getBalance({
+                owner: address,
+            });
+            // Balance comes back as MIST, 1 SUI = 1e9 MIST
+            const balance = Number(balanceResult === null || balanceResult === void 0 ? void 0 : balanceResult.totalBalance) / 1e9;
+            if (Number.isNaN(balance)) {
+                this.logger.error(`[getBalance] Failed to get balance for address: ${address}`);
+                return undefined;
+            }
+            return balance.toFixed(6);
+        });
+    }
+    signMessage(messageToSign) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            this.logger.debug('[signMessage] called, attempting to sign a message');
+            const signFeature = (_a = this.getFeatures()) === null || _a === void 0 ? void 0 : _a['sui:signPersonalMessage'];
+            if (!signFeature) {
+                throw new DynamicError('Wallet does not support sui:signPersonalMessage');
+            }
+            yield this.connect();
+            if (!this.account) {
+                throw new DynamicError('[signMessage] No account found');
+            }
+            let output;
+            try {
+                output = yield signFeature.signPersonalMessage({
+                    account: this.account,
+                    message: new TextEncoder().encode(messageToSign),
+                });
+            }
+            catch (error) {
+                this.logger.error(error);
+                throw new DynamicError('An error occured during signing');
+            }
+            if (!output || !output.signature) {
+                throw new DynamicError('[signMessage] Failed to sign message');
+            }
+            this.logger.debug(`[signMessage] Signed message: ${output.signature}`);
+            return output.signature;
+        });
+    }
+    getWalletAccount() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.account;
+        });
+    }
+    /** Function used to create transactions in the SDK interface */
+    createUiTransaction(from) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.validateActiveWallet(from);
+            const suiClient = yield this.getSuiClient();
+            if (!suiClient) {
+                throw new DynamicError('No Sui client available');
+            }
+            return new SuiUiTransaction({
+                client: suiClient,
+                from,
+                onSubmit: (transaction) => __awaiter(this, void 0, void 0, function* () {
+                    var _a, _b;
+                    if (!this.account || !transaction) {
+                        throw new DynamicError('No account or transaction found');
+                    }
+                    const result = yield ((_b = (_a = this.getFeatures()) === null || _a === void 0 ? void 0 : _a['sui:signAndExecuteTransaction']) === null || _b === void 0 ? void 0 : _b.signAndExecuteTransaction({
+                        account: this.account,
+                        chain: this.account.chains[0],
+                        transaction,
+                    }));
+                    return result;
+                }),
+            });
+        });
+    }
+    teardownEventListeners() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.eventsUnsubscribeHandler) {
+                this.eventsUnsubscribeHandler();
+                this.eventsUnsubscribeHandler = undefined;
+            }
+        });
+    }
+    endSession() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            this.teardownEventListeners();
+            this.account = undefined;
+            const disconnectFeature = (_a = this.getFeatures()) === null || _a === void 0 ? void 0 : _a['standard:disconnect'];
+            if (disconnectFeature) {
+                yield disconnectFeature.disconnect();
+                return;
+            }
+            if (this.wallet.disconnect) {
+                yield this.wallet.disconnect();
+                return;
+            }
+            throw new DynamicError('Wallet does not support disconnect');
+        });
+    }
+    getEnabledNetworks() {
+        return this.suiNetworks;
+    }
+}
+
+export { SuiWalletConnector };

package/src/index.cjs

@@ -0,0 +1,23 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var assertPackageVersion = require('@dynamic-labs/assert-package-version');
+var _package = require('../package.cjs');
+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 SuiUiTransaction = require('./utils/SuiUiTransaction/SuiUiTransaction.cjs');
+var fetchSuiInjectedWalletConnectors = require('./wallets/injected/fetchSuiInjectedWalletConnectors.cjs');
+
+/* eslint-disable @typescript-eslint/no-unused-vars */
+assertPackageVersion.assertPackageVersion('@dynamic-labs/sui-core', _package.version);
+
+exports.MIST_PER_SUI = constants.MIST_PER_SUI;
+exports.SuiWalletConnector = SuiWalletConnector.SuiWalletConnector;
+exports.SuiWallet = SuiWallet.SuiWallet;
+exports.isSuiWallet = isSuiWallet.isSuiWallet;
+exports.SuiUiTransaction = SuiUiTransaction.SuiUiTransaction;
+exports.fetchSuiInjectedWalletConnectors = fetchSuiInjectedWalletConnectors.fetchSuiInjectedWalletConnectors;

package/src/index.d.ts

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

package/src/index.js

@@ -0,0 +1,12 @@
+'use client'
+import { assertPackageVersion } from '@dynamic-labs/assert-package-version';
+import { version } from '../package.js';
+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 { SuiUiTransaction } from './utils/SuiUiTransaction/SuiUiTransaction.js';
+export { fetchSuiInjectedWalletConnectors } from './wallets/injected/fetchSuiInjectedWalletConnectors.js';
+
+/* eslint-disable @typescript-eslint/no-unused-vars */
+assertPackageVersion('@dynamic-labs/sui-core', version);

package/src/types.d.ts

@@ -0,0 +1,27 @@
+import { WalletWithFeatures, SuiWalletFeatures, IdentifierRecord, IdentifierArray, WalletAccount } from '@mysten/wallet-standard';
+import { IChainRpcProviders } from '@dynamic-labs/rpc-providers';
+import { NetworkConfiguration } from '@dynamic-labs/sdk-api-core';
+import { WalletBookSchema } from '@dynamic-labs/wallet-book';
+import { WalletMetadata } from '@dynamic-labs/wallet-connector-core';
+export type SuiWalletConnectorProps = {
+    chainRpcProviders: IChainRpcProviders;
+    suiNetworks: NetworkConfiguration[];
+    walletBook: WalletBookSchema;
+    metadata?: WalletMetadata;
+    wallet: WalletWithFeatures<SuiWalletFeatures>;
+    overrideKey?: string;
+};
+export type SuiChangeEvent = {
+    accounts: WalletAccount[];
+    chains: IdentifierArray;
+    features: IdentifierRecord<unknown>;
+};
+export type SuiWalletStandardEventHandler = (event: SuiChangeEvent) => Promise<void>;
+export type SuiSendBalanceProps = {
+    amount: string;
+    toAddress: string;
+    token?: {
+        address: string;
+        decimals?: number;
+    };
+};

package/src/utils/SuiUiTransaction/SuiUiTransaction.cjs

@@ -0,0 +1,125 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('../../../_virtual/_tslib.cjs');
+var transactions = require('@mysten/sui/transactions');
+var utils$1 = require('@mysten/sui/utils');
+var utils = require('@dynamic-labs/utils');
+var constants = require('../constants/constants.cjs');
+
+class SuiUiTransaction {
+    constructor({ onSubmit, from, client }) {
+        this.chain = 'SUI';
+        this.data = undefined;
+        this.fee = { gas: undefined };
+        this.formatNonNativeToken = (value, decimals) => (Number(value) / Number(Math.pow(10, decimals))).toString();
+        this.from = from;
+        this.onSubmit = onSubmit;
+        this.client = client;
+    }
+    /**
+     * Fetches the gas fee for the transaction by executing a dry run of the
+     * transaction and calculating the gas used.
+     *
+     * @returns The gas fee for the transaction
+     */
+    fetchFee() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            if (this.fee.gas)
+                return;
+            const transaction = yield this.createTransactionSafe();
+            if (!transaction) {
+                throw new Error('Could not create a valid SUI transaction, check your address and value');
+            }
+            const transactionBlock = yield transaction.build({ client: this.client });
+            const dryRunResult = yield this.client.dryRunTransactionBlock({
+                transactionBlock,
+            });
+            if (!dryRunResult) {
+                this.fee.gas = undefined;
+                throw new Error('Error accessing SUI network to calculate gas, please try again later');
+            }
+            const gasObject = dryRunResult.effects.gasUsed;
+            // net_gas_fees = computation_gas_fee + storage_gas_fee - storage_rebate
+            // https://docs.sui.io/concepts/tokenomics/gas-in-sui
+            const calculatedGas = BigInt(gasObject.computationCost) +
+                BigInt(gasObject.storageCost) -
+                BigInt(gasObject.storageRebate);
+            this.fee.gas = calculatedGas;
+            if (this.fee.gas <= BigInt(0)) {
+                this.fee.gas = undefined;
+            }
+        });
+    }
+    isGasSponsored() {
+        return false;
+    }
+    parse(input) {
+        const floatValue = parseFloat(input);
+        const mist = Math.round(floatValue * constants.MIST_PER_SUI);
+        return BigInt(mist);
+    }
+    parseNonNativeToken(input, decimals) {
+        return BigInt(Math.floor(Number(input) * Math.pow(10, decimals)));
+    }
+    format(value, { precision } = {}) {
+        const suiValue = Number(value) / constants.MIST_PER_SUI;
+        const decimalString = suiValue.toLocaleString('fullwide', {
+            maximumFractionDigits: 20,
+            minimumFractionDigits: 0,
+            useGrouping: false,
+        });
+        return utils.formatNumberText(decimalString, { precision });
+    }
+    submit() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            const sendTransaction = (yield this.createTransaction());
+            return this.onSubmit(sendTransaction);
+        });
+    }
+    getBalance() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            const balance = yield this.client.getBalance({
+                coinType: '0x2::sui::SUI',
+                owner: this.from,
+            });
+            return BigInt(balance.totalBalance);
+        });
+    }
+    validateAddressFormat(address) {
+        if (address === 'dyn_send_transaction.multiple_recipients') {
+            return true;
+        }
+        return utils$1.isValidSuiAddress(address);
+    }
+    createTransaction() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            const { value, to } = this;
+            if (!to) {
+                throw new Error('Destination is required');
+            }
+            if (!value) {
+                return undefined;
+            }
+            const sendTransaction = new transactions.Transaction();
+            sendTransaction.setSender(this.from);
+            const [coin] = sendTransaction.splitCoins(sendTransaction.gas, [value]);
+            sendTransaction.transferObjects([coin], to);
+            return sendTransaction;
+        });
+    }
+    createTransactionSafe() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            try {
+                return yield this.createTransaction();
+            }
+            catch (error) {
+                return undefined;
+            }
+        });
+    }
+}
+
+exports.SuiUiTransaction = SuiUiTransaction;

package/src/utils/SuiUiTransaction/SuiUiTransaction.d.ts

@@ -0,0 +1,47 @@
+import { Transaction } from '@mysten/sui/transactions';
+import { SuiClient } from '@mysten/sui/client';
+import { IUITransaction, IUITransactionFormatOptions } from '@dynamic-labs/types';
+type SuiUiTransactionProps = {
+    /** SUI Address of the sender */
+    from: string;
+    /** The [SuiClient] instance, needed to estimate gas fees */
+    client: SuiClient;
+    /** The function to call when the transaction is submitted */
+    onSubmit: (transaction?: Transaction) => Promise<any>;
+};
+export declare class SuiUiTransaction implements IUITransaction {
+    to: string | undefined;
+    from: string;
+    value: bigint | undefined;
+    chain: string;
+    receipt: string | undefined;
+    data: undefined;
+    fee: {
+        gas: bigint | undefined;
+    };
+    nonNativeAddress?: string;
+    nonNativeDecimal?: number;
+    nonNativeValue?: bigint;
+    nativePrice?: number;
+    private onSubmit;
+    private client;
+    constructor({ onSubmit, from, client }: SuiUiTransactionProps);
+    /**
+     * Fetches the gas fee for the transaction by executing a dry run of the
+     * transaction and calculating the gas used.
+     *
+     * @returns The gas fee for the transaction
+     */
+    fetchFee(): Promise<void>;
+    isGasSponsored(): boolean;
+    parse(input: string): bigint;
+    parseNonNativeToken(input: string, decimals: number): bigint;
+    formatNonNativeToken: (value: bigint, decimals: number) => string;
+    format(value: bigint, { precision }?: IUITransactionFormatOptions): string;
+    submit(): Promise<any>;
+    getBalance(): Promise<bigint>;
+    validateAddressFormat(address: string): boolean;
+    private createTransaction;
+    private createTransactionSafe;
+}
+export {};

package/src/utils/SuiUiTransaction/SuiUiTransaction.js

@@ -0,0 +1,121 @@
+'use client'
+import { __awaiter } from '../../../_virtual/_tslib.js';
+import { Transaction } from '@mysten/sui/transactions';
+import { isValidSuiAddress } from '@mysten/sui/utils';
+import { formatNumberText } from '@dynamic-labs/utils';
+import { MIST_PER_SUI } from '../constants/constants.js';
+
+class SuiUiTransaction {
+    constructor({ onSubmit, from, client }) {
+        this.chain = 'SUI';
+        this.data = undefined;
+        this.fee = { gas: undefined };
+        this.formatNonNativeToken = (value, decimals) => (Number(value) / Number(Math.pow(10, decimals))).toString();
+        this.from = from;
+        this.onSubmit = onSubmit;
+        this.client = client;
+    }
+    /**
+     * Fetches the gas fee for the transaction by executing a dry run of the
+     * transaction and calculating the gas used.
+     *
+     * @returns The gas fee for the transaction
+     */
+    fetchFee() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.fee.gas)
+                return;
+            const transaction = yield this.createTransactionSafe();
+            if (!transaction) {
+                throw new Error('Could not create a valid SUI transaction, check your address and value');
+            }
+            const transactionBlock = yield transaction.build({ client: this.client });
+            const dryRunResult = yield this.client.dryRunTransactionBlock({
+                transactionBlock,
+            });
+            if (!dryRunResult) {
+                this.fee.gas = undefined;
+                throw new Error('Error accessing SUI network to calculate gas, please try again later');
+            }
+            const gasObject = dryRunResult.effects.gasUsed;
+            // net_gas_fees = computation_gas_fee + storage_gas_fee - storage_rebate
+            // https://docs.sui.io/concepts/tokenomics/gas-in-sui
+            const calculatedGas = BigInt(gasObject.computationCost) +
+                BigInt(gasObject.storageCost) -
+                BigInt(gasObject.storageRebate);
+            this.fee.gas = calculatedGas;
+            if (this.fee.gas <= BigInt(0)) {
+                this.fee.gas = undefined;
+            }
+        });
+    }
+    isGasSponsored() {
+        return false;
+    }
+    parse(input) {
+        const floatValue = parseFloat(input);
+        const mist = Math.round(floatValue * MIST_PER_SUI);
+        return BigInt(mist);
+    }
+    parseNonNativeToken(input, decimals) {
+        return BigInt(Math.floor(Number(input) * Math.pow(10, decimals)));
+    }
+    format(value, { precision } = {}) {
+        const suiValue = Number(value) / MIST_PER_SUI;
+        const decimalString = suiValue.toLocaleString('fullwide', {
+            maximumFractionDigits: 20,
+            minimumFractionDigits: 0,
+            useGrouping: false,
+        });
+        return formatNumberText(decimalString, { precision });
+    }
+    submit() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const sendTransaction = (yield this.createTransaction());
+            return this.onSubmit(sendTransaction);
+        });
+    }
+    getBalance() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const balance = yield this.client.getBalance({
+                coinType: '0x2::sui::SUI',
+                owner: this.from,
+            });
+            return BigInt(balance.totalBalance);
+        });
+    }
+    validateAddressFormat(address) {
+        if (address === 'dyn_send_transaction.multiple_recipients') {
+            return true;
+        }
+        return isValidSuiAddress(address);
+    }
+    createTransaction() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { value, to } = this;
+            if (!to) {
+                throw new Error('Destination is required');
+            }
+            if (!value) {
+                return undefined;
+            }
+            const sendTransaction = new Transaction();
+            sendTransaction.setSender(this.from);
+            const [coin] = sendTransaction.splitCoins(sendTransaction.gas, [value]);
+            sendTransaction.transferObjects([coin], to);
+            return sendTransaction;
+        });
+    }
+    createTransactionSafe() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                return yield this.createTransaction();
+            }
+            catch (error) {
+                return undefined;
+            }
+        });
+    }
+}
+
+export { SuiUiTransaction };

package/src/utils/SuiUiTransaction/index.d.ts

@@ -0,0 +1 @@
+export * from './SuiUiTransaction';

package/src/utils/constants/constants.cjs

@@ -0,0 +1,8 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const MIST_PER_SUI = 1e9;
+
+exports.MIST_PER_SUI = MIST_PER_SUI;

package/src/utils/constants/constants.d.ts

@@ -0,0 +1 @@
+export declare const MIST_PER_SUI = 1000000000;