@broxus/evm-connect 1.0.0

package/dist/esm/intl/index.js

@@ -0,0 +1,108 @@
+import { defineMessages } from 'react-intl';
+/* eslint-disable sort-keys */
+export default defineMessages({
+    EVM_CONNECT_AGREEMENTS_NOTE: {
+        defaultMessage: 'By connecting a wallet, you agree to Terms of Service and consent to its Privacy Policy.',
+        id: 'EVM_CONNECT_AGREEMENTS_NOTE',
+    },
+    EVM_CONNECT_NOT_CONNECTED_HINT: {
+        defaultMessage: 'Not connected',
+        id: 'EVM_CONNECT_NOT_CONNECTED_HINT',
+    },
+    EVM_CONNECT_INITIALIZING_HINT: {
+        defaultMessage: 'Initializing',
+        id: 'EVM_CONNECT_INITIALIZING_HINT',
+    },
+    EVM_CONNECT_CONNECT_BTN_TEXT: {
+        defaultMessage: 'Connect',
+        id: 'EVM_CONNECT_CONNECT_BTN_TEXT',
+    },
+    EVM_CONNECT_DISCONNECT_BTN_TEXT: {
+        defaultMessage: 'Disconnect',
+        id: 'EVM_CONNECT_DISCONNECT_BTN_TEXT',
+    },
+    EVM_CONNECT_CHANGE_NETWORK_BTN_TEXT: {
+        defaultMessage: 'Change network',
+        id: 'EVM_CONNECT_CHANGE_NETWORK_BTN_TEXT',
+    },
+    EVM_CONNECT_CHANGE_WALLET_BTN_TEXT: {
+        defaultMessage: 'Change wallet',
+        id: 'EVM_CONNECT_CHANGE_WALLET_BTN_TEXT',
+    },
+    EVM_CONNECT_UNSUPPORTED_NETWORK_WARNING: {
+        defaultMessage: 'Unsupported network',
+        id: 'EVM_CONNECT_UNSUPPORTED_NETWORK_WARNING',
+    },
+    EVM_CONNECT_CONNECTOR_BLOCKCHAIN_NAME: {
+        defaultMessage: 'Ethereum',
+        id: 'EVM_CONNECT_CONNECTOR_BLOCKCHAIN_NAME',
+    },
+    EVM_CONNECT_CONNECTOR_EXPLORER_HINT: {
+        defaultMessage: 'Open in {explorerTitle}',
+        id: 'EVM_CONNECT_CONNECTOR_EXPLORER_HINT',
+    },
+    EVM_CONNECT_INSTALL_PROVIDER: {
+        defaultMessage: 'Install {providerName}',
+        id: 'EVM_CONNECT_INSTALL_PROVIDER',
+    },
+    EVM_CONNECT_INSTALL_ANDROID_PLATFORM: {
+        defaultMessage: 'Install Android App',
+        id: 'EVM_CONNECT_INSTALL_ANDROID_PLATFORM',
+    },
+    EVM_CONNECT_INSTALL_IOS_PLATFORM: {
+        defaultMessage: 'Install iOS App',
+        id: 'EVM_CONNECT_INSTALL_IOS_PLATFORM',
+    },
+    EVM_CONNECT_INSTALL_CHROME_EXTENSION_PLATFORM: {
+        defaultMessage: 'Install Chrome extension',
+        id: 'EVM_CONNECT_INSTALL_CHROME_EXTENSION_PLATFORM',
+    },
+    EVM_CONNECT_INSTALL_FIREFOX_EXTENSION_PLATFORM: {
+        defaultMessage: 'Install Firefox extension',
+        id: 'EVM_CONNECT_INSTALL_FIREFOX_EXTENSION_PLATFORM',
+    },
+    EVM_CONNECT_INSTALL_SAFARI_EXTENSION_PLATFORM: {
+        defaultMessage: 'Install Safari extension',
+        id: 'EVM_CONNECT_INSTALL_SAFARI_EXTENSION_PLATFORM',
+    },
+    EVM_CONNECT_INSTALL_UNKNOWN_PLATFORM: {
+        defaultMessage: '—',
+        id: 'EVM_CONNECT_INSTALL_UNKNOWN_PLATFORM',
+    },
+    EVM_CONNECT_DISPATCHER_POPUP_TITLE: {
+        defaultMessage: 'Connect a wallet',
+        id: 'EVM_CONNECT_DISPATCHER_POPUP_TITLE',
+    },
+    EVM_CONNECT_DISPATCHER_POPUP_NOTE: {
+        defaultMessage: 'At the moment we only support the wallets below.',
+        id: 'EVM_CONNECT_DISPATCHER_POPUP_NOTE',
+    },
+    EVM_CONNECT_DISPATCHER_POPUP_REQUEST_TITLE: {
+        defaultMessage: 'Continue in {title}',
+        id: 'EVM_CONNECT_DISPATCHER_POPUP_REQUEST_TITLE',
+    },
+    EVM_CONNECT_DISPATCHER_POPUP_REQUEST_NOTE: {
+        defaultMessage: 'Accept connection request in the wallet',
+        id: 'EVM_CONNECT_DISPATCHER_POPUP_REQUEST_NOTE',
+    },
+    EVM_CONNECT_DISPATCHER_POPUP_REQUEST_FAILED_TITLE: {
+        defaultMessage: 'Connection failed',
+        id: 'EVM_CONNECT_DISPATCHER_POPUP_REQUEST_FAILED_TITLE',
+    },
+    EVM_CONNECT_DISPATCHER_POPUP_REQUEST_FAILED_NOTE: {
+        defaultMessage: 'Connection can be declined if a previous request is still active',
+        id: 'EVM_CONNECT_DISPATCHER_POPUP_REQUEST_FAILED_NOTE',
+    },
+    EVM_CONNECT_DISPATCHER_POPUP_REQUEST_TRY_AGAIN_BTN_TEXT: {
+        defaultMessage: 'Try again',
+        id: 'EVM_CONNECT_DISPATCHER_POPUP_REQUEST_TRY_AGAIN_BTN_TEXT',
+    },
+    EVM_CONNECT_DISPATCHER_POPUP_CONNECTED_HINT: {
+        defaultMessage: 'Connected',
+        id: 'EVM_CONNECT_DISPATCHER_POPUP_CONNECTED_HINT',
+    },
+    EVM_CONNECT_DISPATCHER_POPUP_RECENT_HINT: {
+        defaultMessage: 'Recent',
+        id: 'EVM_CONNECT_DISPATCHER_POPUP_RECENT_HINT',
+    },
+});

package/dist/esm/services/EvmWalletService.d.ts

@@ -0,0 +1,165 @@
+import { type EvmNetworkConfig } from '@broxus/js-bridge-essentials';
+import { AbstractStore, type NativeCurrency } from '@broxus/js-core';
+import { type IReactionDisposer } from 'mobx';
+import Web3 from 'web3';
+import { type EthereumConnector } from '../core';
+import { type AddEthereumChainParams, type EvmWalletProviderConfig } from '../types';
+export interface EvmWalletServiceCtorParams {
+    defaultNetworkId?: number;
+    /**
+     * List of supported networks
+     */
+    networks?: Readonly<EvmNetworkConfig[]>;
+    providerId?: string;
+    /**
+     * List of supported Providers
+     */
+    providers?: Readonly<EvmWalletProviderConfig[]>;
+}
+export interface EvmWalletServiceData {
+    balance?: string;
+    networks: Readonly<EvmNetworkConfig[]>;
+}
+export interface EvmWalletServiceState {
+    isSyncing?: boolean;
+    providerId?: string;
+}
+export declare class EvmWalletService extends AbstractStore<EvmWalletServiceData, EvmWalletServiceState> {
+    protected readonly params?: Readonly<EvmWalletServiceCtorParams> | undefined;
+    constructor(params?: Readonly<EvmWalletServiceCtorParams> | undefined);
+    /**
+     * Manually connect to the wallet
+     * @returns {Promise<void>}
+     */
+    connect(): Promise<void>;
+    /**
+     * Manually disconnect from the wallet
+     * @returns {Promise<void>}
+     */
+    disconnect(force?: boolean): Promise<void>;
+    /**
+     * Switch network or add a new one if not exists in the current connected wallet
+     * @param {number|AddEthereumChainParams} chainIdOrParams
+     * @returns {Promise<void>}
+     */
+    switchNetwork(chainIdOrParams: number | AddEthereumChainParams): Promise<void>;
+    /**
+     * Define current provider connector
+     * @returns {EthereumConnector|undefined}
+     */
+    get connector(): EthereumConnector | undefined;
+    /**
+     * An independent RPC connection that allows you to receive data from the blockchain without being
+     * able to send transactions.
+     *
+     * This connection does not require connection permissions and wrapped on `Web3` interface.
+     * @returns {Web3|undefined}
+     */
+    get connection(): Web3 | undefined;
+    /**
+     * Returns current Web3 Instance
+     */
+    get provider(): Web3 | undefined;
+    /**
+     * Returns computed wallet balance value
+     * @returns {EvmWalletServiceData["balance"]}
+     */
+    get balance(): EvmWalletServiceData['balance'];
+    /**
+     * List of the supported networks
+     * @returns {EvmWalletServiceData["networks"]}
+     */
+    get networks(): EvmWalletServiceData['networks'];
+    /**
+     * Returns `true` if wallet contract is updating
+     * @returns {EvmWalletServiceState["isSyncing"]}
+     */
+    get isSyncing(): EvmWalletServiceState['isSyncing'];
+    /**
+     A unique identifier of the connected wallet (provider)
+     * @returns {EvmWalletServiceState["providerId"]}
+     */
+    get providerId(): EvmWalletServiceState['providerId'];
+    /**
+     * Returns computed wallet address value
+     * @returns {string|undefined}
+     */
+    get address(): string | undefined;
+    /**
+     * Returns wallet native currency
+     * @returns {Readonly<NativeCurrency<string>>}
+     */
+    get currency(): Readonly<NativeCurrency<string>>;
+    /**
+     * Returns `true` if provider is available.
+     * That means extension is installed and activated, else `false`
+     * @returns {boolean}
+     */
+    get hasProvider(): boolean;
+    /**
+     * Returns `true` if wallet is connected
+     * @returns {boolean}
+     */
+    get isConnected(): boolean;
+    /**
+     * Returns `true` if wallet is initialized and connected
+     * @returns {boolean}
+     */
+    get isReady(): boolean;
+    /**
+     * Checks network support
+     * @returns {boolean}
+     */
+    get isUnsupportedNetwork(): boolean;
+    /**
+     * Returns current network config
+     * @returns {Readonly<EvmNetworkConfig|undefined>}
+     */
+    get network(): Readonly<EvmNetworkConfig | undefined>;
+    /**
+     Returns details about current connected provider
+     * @returns {EvmWalletProviderConfig["info"]|undefined}
+     */
+    get providerInfo(): EvmWalletProviderConfig['info'] | undefined;
+    /**
+     * The list of the supported providers
+     * @returns {Readonly<EvmWalletProviderConfig[]|undefined>}
+     */
+    get providers(): Readonly<EvmWalletProviderConfig[] | undefined>;
+    /**
+     * Returns current network chain id
+     * @returns {EthereumConnector["chainId"]}
+     */
+    get chainId(): EthereumConnector['chainId'];
+    /**
+     * Returns `true` if wallet is connecting
+     * @returns {EthereumConnector["isConnecting"]}
+     */
+    get isConnecting(): EthereumConnector['isConnecting'];
+    /**
+     * Returns `true` if wallet is disconnecting
+     * @returns {EthereumConnector["isDisconnecting"]}
+     */
+    get isDisconnecting(): EthereumConnector['isDisconnecting'];
+    /**
+     * Returns `true` if wallet is initialized
+     * @returns {EthereumConnector["isInitialized"]}
+     */
+    get isInitialized(): EthereumConnector['isInitialized'];
+    /**
+     * Returns `true` if wallet is initializing
+     * @returns {EthereumConnector["isInitializing"]}
+     */
+    get isInitializing(): EthereumConnector['isInitializing'];
+    /**
+     * Sync account balance
+     */
+    protected syncBalance(): Promise<void>;
+    /**
+     * Trying to resolve EVM Wallet connection
+     * @protected
+     */
+    protected init(): Promise<void>;
+    protected accountDisposer: IReactionDisposer | undefined;
+    protected networkDisposer: IReactionDisposer | undefined;
+}

package/dist/esm/services/EvmWalletService.js

@@ -0,0 +1,423 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { AbstractStore } from '@broxus/js-core';
+import { debounce, debug, error } from '@broxus/js-utils';
+import { action, computed, makeObservable, reaction } from 'mobx';
+import Web3 from 'web3';
+export class EvmWalletService extends AbstractStore {
+    params;
+    constructor(params) {
+        super();
+        this.params = params;
+        this.setData(() => ({
+            networks: params?.networks || [],
+        }));
+        this.setState(() => ({
+            isSyncing: undefined,
+            providerId: params?.providerId,
+        }));
+        makeObservable(this);
+        this.init().catch(reason => {
+            error('Wallet init failed with an error', reason);
+        });
+    }
+    /**
+     * Manually connect to the wallet
+     * @returns {Promise<void>}
+     */
+    async connect() {
+        if (this.isConnecting || this.isDisconnecting) {
+            return;
+        }
+        try {
+            const defaultNetworkId = this.params?.defaultNetworkId ?? this.network?.chainId ?? 1;
+            const chainParams = this.networks.find(network => network.chainId === defaultNetworkId?.toString());
+            await this.connector?.connect(chainParams ?? 1);
+        }
+        catch (e) {
+            error('EVM Wallet connect error', e);
+        }
+    }
+    /**
+     * Manually disconnect from the wallet
+     * @returns {Promise<void>}
+     */
+    async disconnect(force) {
+        if ((this.isConnecting || this.isDisconnecting) && !force) {
+            return;
+        }
+        try {
+            await this.connector?.disconnect();
+            this.setData('balance', undefined);
+            this.setState('providerId', undefined);
+        }
+        catch (e) {
+            error('EVM Wallet disconnect error', e);
+        }
+        finally {
+            //
+        }
+    }
+    /**
+     * Switch network or add a new one if not exists in the current connected wallet
+     * @param {number|AddEthereumChainParams} chainIdOrParams
+     * @returns {Promise<void>}
+     */
+    async switchNetwork(chainIdOrParams) {
+        await this.connector?.switchNetwork(chainIdOrParams);
+    }
+    /**
+     * Define current provider connector
+     * @returns {EthereumConnector|undefined}
+     */
+    get connector() {
+        return this.providers?.find(config => config.id === this.providerId)?.connector;
+    }
+    /**
+     * An independent RPC connection that allows you to receive data from the blockchain without being
+     * able to send transactions.
+     *
+     * This connection does not require connection permissions and wrapped on `Web3` interface.
+     * @returns {Web3|undefined}
+     */
+    get connection() {
+        return this.network?.rpcUrl ? new Web3(new Web3.providers.HttpProvider(this.network.rpcUrl)) : this.provider;
+    }
+    /**
+     * Returns current Web3 Instance
+     */
+    get provider() {
+        return this.connector?.provider != null ? new Web3(this.connector.provider) : undefined;
+    }
+    /**
+     * Returns computed wallet balance value
+     * @returns {EvmWalletServiceData["balance"]}
+     */
+    get balance() {
+        return this._data.balance ?? '0';
+    }
+    /**
+     * List of the supported networks
+     * @returns {EvmWalletServiceData["networks"]}
+     */
+    get networks() {
+        return this._data?.networks;
+    }
+    /**
+     * Returns `true` if wallet contract is updating
+     * @returns {EvmWalletServiceState["isSyncing"]}
+     */
+    get isSyncing() {
+        return this._state.isSyncing;
+    }
+    /**
+     A unique identifier of the connected wallet (provider)
+     * @returns {EvmWalletServiceState["providerId"]}
+     */
+    get providerId() {
+        return this._state.providerId;
+    }
+    /**
+     * Returns computed wallet address value
+     * @returns {string|undefined}
+     */
+    get address() {
+        return this.connector?.accounts?.[0];
+    }
+    /**
+     * Returns wallet native currency
+     * @returns {Readonly<NativeCurrency<string>>}
+     */
+    get currency() {
+        return {
+            balance: this.balance,
+            decimals: this.network?.currency.decimals ?? 18,
+            icon: this.network?.currency.icon,
+            name: this.network?.currency.name,
+            symbol: this.network?.currency.symbol || 'ETH',
+            wrappedCurrencyAddress: this.network?.currency.wrappedCurrencyAddress,
+        };
+    }
+    /**
+     * Returns `true` if provider is available.
+     * That means extension is installed and activated, else `false`
+     * @returns {boolean}
+     */
+    get hasProvider() {
+        return this.connector?.provider != null;
+    }
+    /**
+     * Returns `true` if wallet is connected
+     * @returns {boolean}
+     */
+    get isConnected() {
+        return this.address !== undefined;
+    }
+    /**
+     * Returns `true` if wallet is initialized and connected
+     * @returns {boolean}
+     */
+    get isReady() {
+        return (!this.isInitializing
+            && !this.isConnecting
+            && !this.isDisconnecting
+            && this.isInitialized === true
+            && this.isConnected);
+    }
+    /**
+     * Checks network support
+     * @returns {boolean}
+     */
+    get isUnsupportedNetwork() {
+        if (this.chainId == null) {
+            return false;
+        }
+        return !(this.networks?.map(network => network.chainId)?.includes(this.chainId.toString()) ?? false);
+    }
+    /**
+     * Returns current network config
+     * @returns {Readonly<EvmNetworkConfig|undefined>}
+     */
+    get network() {
+        return this.networks?.find(network => network.type === 'evm' && network.chainId === this.chainId?.toString());
+    }
+    /**
+     Returns details about current connected provider
+     * @returns {EvmWalletProviderConfig["info"]|undefined}
+     */
+    get providerInfo() {
+        return this.providers?.find(config => config.id === this.providerId)?.info;
+    }
+    /**
+     * The list of the supported providers
+     * @returns {Readonly<EvmWalletProviderConfig[]|undefined>}
+     */
+    get providers() {
+        return this.params?.providers;
+    }
+    /**
+     * Returns current network chain id
+     * @returns {EthereumConnector["chainId"]}
+     */
+    get chainId() {
+        return this.connector?.chainId;
+    }
+    /**
+     * Returns `true` if wallet is connecting
+     * @returns {EthereumConnector["isConnecting"]}
+     */
+    get isConnecting() {
+        return this.connector?.isConnecting;
+    }
+    /**
+     * Returns `true` if wallet is disconnecting
+     * @returns {EthereumConnector["isDisconnecting"]}
+     */
+    get isDisconnecting() {
+        return this.connector?.isDisconnecting;
+    }
+    /**
+     * Returns `true` if wallet is initialized
+     * @returns {EthereumConnector["isInitialized"]}
+     */
+    get isInitialized() {
+        return this.connector?.isInitialized;
+    }
+    /**
+     * Returns `true` if wallet is initializing
+     * @returns {EthereumConnector["isInitializing"]}
+     */
+    get isInitializing() {
+        return this.connector?.isInitializing;
+    }
+    /**
+     * Sync account balance
+     */
+    async syncBalance() {
+        if (!this.provider) {
+            return;
+        }
+        try {
+            if (this.address) {
+                this.setState('isSyncing', this.isSyncing === undefined);
+                const balance = await this.provider.eth.getBalance(this.address);
+                this.setData('balance', balance.toString());
+                debug(`Sync EVM balance: ${balance}`);
+            }
+        }
+        catch (e) {
+            error('Sync EVM balance failed with an error', e);
+            this.setData('balance', undefined);
+        }
+        finally {
+            this.setState('isSyncing', false);
+        }
+    }
+    /**
+     * Trying to resolve EVM Wallet connection
+     * @protected
+     */
+    async init() {
+        this.accountDisposer = reaction(() => this.address, async (address, prevAddress) => {
+            if (address?.toLowerCase() !== prevAddress?.toLowerCase()) {
+                this.setState('isSyncing', undefined);
+            }
+            await this.syncBalance();
+        });
+        this.networkDisposer = reaction(() => this.chainId, async (chainId, prevChainId) => {
+            if (chainId !== prevChainId) {
+                this.setState('isSyncing', undefined);
+            }
+            await this.syncBalance();
+        });
+        const handler = debounce(async () => {
+            await this.syncBalance();
+            handler();
+        }, 10_000);
+        handler();
+    }
+    accountDisposer;
+    networkDisposer;
+}
+__decorate([
+    action.bound,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], EvmWalletService.prototype, "connect", null);
+__decorate([
+    action.bound,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Boolean]),
+    __metadata("design:returntype", Promise)
+], EvmWalletService.prototype, "disconnect", null);
+__decorate([
+    action.bound,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], EvmWalletService.prototype, "switchNetwork", null);
+__decorate([
+    computed,
+    __metadata("design:type", Object),
+    __metadata("design:paramtypes", [])
+], EvmWalletService.prototype, "connector", null);
+__decorate([
+    computed,
+    __metadata("design:type", Object),
+    __metadata("design:paramtypes", [])
+], EvmWalletService.prototype, "connection", null);
+__decorate([
+    computed,
+    __metadata("design:type", Object),
+    __metadata("design:paramtypes", [])
+], EvmWalletService.prototype, "provider", null);
+__decorate([
+    computed,
+    __metadata("design:type", Object),
+    __metadata("design:paramtypes", [])
+], EvmWalletService.prototype, "balance", null);
+__decorate([
+    computed,
+    __metadata("design:type", Object),
+    __metadata("design:paramtypes", [])
+], EvmWalletService.prototype, "networks", null);
+__decorate([
+    computed,
+    __metadata("design:type", Object),
+    __metadata("design:paramtypes", [])
+], EvmWalletService.prototype, "isSyncing", null);
+__decorate([
+    computed,
+    __metadata("design:type", Object),
+    __metadata("design:paramtypes", [])
+], EvmWalletService.prototype, "providerId", null);
+__decorate([
+    computed,
+    __metadata("design:type", Object),
+    __metadata("design:paramtypes", [])
+], EvmWalletService.prototype, "address", null);
+__decorate([
+    computed,
+    __metadata("design:type", Object),
+    __metadata("design:paramtypes", [])
+], EvmWalletService.prototype, "currency", null);
+__decorate([
+    computed,
+    __metadata("design:type", Boolean),
+    __metadata("design:paramtypes", [])
+], EvmWalletService.prototype, "hasProvider", null);
+__decorate([
+    computed,
+    __metadata("design:type", Boolean),
+    __metadata("design:paramtypes", [])
+], EvmWalletService.prototype, "isConnected", null);
+__decorate([
+    computed,
+    __metadata("design:type", Boolean),
+    __metadata("design:paramtypes", [])
+], EvmWalletService.prototype, "isReady", null);
+__decorate([
+    computed,
+    __metadata("design:type", Boolean),
+    __metadata("design:paramtypes", [])
+], EvmWalletService.prototype, "isUnsupportedNetwork", null);
+__decorate([
+    computed,
+    __metadata("design:type", Object),
+    __metadata("design:paramtypes", [])
+], EvmWalletService.prototype, "network", null);
+__decorate([
+    computed,
+    __metadata("design:type", Object),
+    __metadata("design:paramtypes", [])
+], EvmWalletService.prototype, "providerInfo", null);
+__decorate([
+    computed,
+    __metadata("design:type", Object),
+    __metadata("design:paramtypes", [])
+], EvmWalletService.prototype, "providers", null);
+__decorate([
+    computed,
+    __metadata("design:type", Object),
+    __metadata("design:paramtypes", [])
+], EvmWalletService.prototype, "chainId", null);
+__decorate([
+    computed,
+    __metadata("design:type", Object),
+    __metadata("design:paramtypes", [])
+], EvmWalletService.prototype, "isConnecting", null);
+__decorate([
+    computed,
+    __metadata("design:type", Object),
+    __metadata("design:paramtypes", [])
+], EvmWalletService.prototype, "isDisconnecting", null);
+__decorate([
+    computed,
+    __metadata("design:type", Object),
+    __metadata("design:paramtypes", [])
+], EvmWalletService.prototype, "isInitialized", null);
+__decorate([
+    computed,
+    __metadata("design:type", Object),
+    __metadata("design:paramtypes", [])
+], EvmWalletService.prototype, "isInitializing", null);
+__decorate([
+    action.bound,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], EvmWalletService.prototype, "syncBalance", null);
+__decorate([
+    action.bound,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], EvmWalletService.prototype, "init", null);

package/dist/esm/services/index.d.ts

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

package/dist/esm/services/index.js

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