@broxus/evm-connect 1.0.0

package/dist/cjs/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/cjs/services/EvmWalletService.js

@@ -0,0 +1,430 @@
+"use strict";
+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);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EvmWalletService = void 0;
+const js_core_1 = require("@broxus/js-core");
+const js_utils_1 = require("@broxus/js-utils");
+const mobx_1 = require("mobx");
+const web3_1 = __importDefault(require("web3"));
+class EvmWalletService extends js_core_1.AbstractStore {
+    params;
+    constructor(params) {
+        super();
+        this.params = params;
+        this.setData(() => ({
+            networks: params?.networks || [],
+        }));
+        this.setState(() => ({
+            isSyncing: undefined,
+            providerId: params?.providerId,
+        }));
+        (0, mobx_1.makeObservable)(this);
+        this.init().catch(reason => {
+            (0, js_utils_1.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) {
+            (0, js_utils_1.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) {
+            (0, js_utils_1.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_1.default(new web3_1.default.providers.HttpProvider(this.network.rpcUrl)) : this.provider;
+    }
+    /**
+     * Returns current Web3 Instance
+     */
+    get provider() {
+        return this.connector?.provider != null ? new web3_1.default(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());
+                (0, js_utils_1.debug)(`Sync EVM balance: ${balance}`);
+            }
+        }
+        catch (e) {
+            (0, js_utils_1.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 = (0, mobx_1.reaction)(() => this.address, async (address, prevAddress) => {
+            if (address?.toLowerCase() !== prevAddress?.toLowerCase()) {
+                this.setState('isSyncing', undefined);
+            }
+            await this.syncBalance();
+        });
+        this.networkDisposer = (0, mobx_1.reaction)(() => this.chainId, async (chainId, prevChainId) => {
+            if (chainId !== prevChainId) {
+                this.setState('isSyncing', undefined);
+            }
+            await this.syncBalance();
+        });
+        const handler = (0, js_utils_1.debounce)(async () => {
+            await this.syncBalance();
+            handler();
+        }, 10_000);
+        handler();
+    }
+    accountDisposer;
+    networkDisposer;
+}
+exports.EvmWalletService = EvmWalletService;
+__decorate([
+    mobx_1.action.bound,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], EvmWalletService.prototype, "connect", null);
+__decorate([
+    mobx_1.action.bound,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Boolean]),
+    __metadata("design:returntype", Promise)
+], EvmWalletService.prototype, "disconnect", null);
+__decorate([
+    mobx_1.action.bound,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], EvmWalletService.prototype, "switchNetwork", null);
+__decorate([
+    mobx_1.computed,
+    __metadata("design:type", Object),
+    __metadata("design:paramtypes", [])
+], EvmWalletService.prototype, "connector", null);
+__decorate([
+    mobx_1.computed,
+    __metadata("design:type", Object),
+    __metadata("design:paramtypes", [])
+], EvmWalletService.prototype, "connection", null);
+__decorate([
+    mobx_1.computed,
+    __metadata("design:type", Object),
+    __metadata("design:paramtypes", [])
+], EvmWalletService.prototype, "provider", null);
+__decorate([
+    mobx_1.computed,
+    __metadata("design:type", Object),
+    __metadata("design:paramtypes", [])
+], EvmWalletService.prototype, "balance", null);
+__decorate([
+    mobx_1.computed,
+    __metadata("design:type", Object),
+    __metadata("design:paramtypes", [])
+], EvmWalletService.prototype, "networks", null);
+__decorate([
+    mobx_1.computed,
+    __metadata("design:type", Object),
+    __metadata("design:paramtypes", [])
+], EvmWalletService.prototype, "isSyncing", null);
+__decorate([
+    mobx_1.computed,
+    __metadata("design:type", Object),
+    __metadata("design:paramtypes", [])
+], EvmWalletService.prototype, "providerId", null);
+__decorate([
+    mobx_1.computed,
+    __metadata("design:type", Object),
+    __metadata("design:paramtypes", [])
+], EvmWalletService.prototype, "address", null);
+__decorate([
+    mobx_1.computed,
+    __metadata("design:type", Object),
+    __metadata("design:paramtypes", [])
+], EvmWalletService.prototype, "currency", null);
+__decorate([
+    mobx_1.computed,
+    __metadata("design:type", Boolean),
+    __metadata("design:paramtypes", [])
+], EvmWalletService.prototype, "hasProvider", null);
+__decorate([
+    mobx_1.computed,
+    __metadata("design:type", Boolean),
+    __metadata("design:paramtypes", [])
+], EvmWalletService.prototype, "isConnected", null);
+__decorate([
+    mobx_1.computed,
+    __metadata("design:type", Boolean),
+    __metadata("design:paramtypes", [])
+], EvmWalletService.prototype, "isReady", null);
+__decorate([
+    mobx_1.computed,
+    __metadata("design:type", Boolean),
+    __metadata("design:paramtypes", [])
+], EvmWalletService.prototype, "isUnsupportedNetwork", null);
+__decorate([
+    mobx_1.computed,
+    __metadata("design:type", Object),
+    __metadata("design:paramtypes", [])
+], EvmWalletService.prototype, "network", null);
+__decorate([
+    mobx_1.computed,
+    __metadata("design:type", Object),
+    __metadata("design:paramtypes", [])
+], EvmWalletService.prototype, "providerInfo", null);
+__decorate([
+    mobx_1.computed,
+    __metadata("design:type", Object),
+    __metadata("design:paramtypes", [])
+], EvmWalletService.prototype, "providers", null);
+__decorate([
+    mobx_1.computed,
+    __metadata("design:type", Object),
+    __metadata("design:paramtypes", [])
+], EvmWalletService.prototype, "chainId", null);
+__decorate([
+    mobx_1.computed,
+    __metadata("design:type", Object),
+    __metadata("design:paramtypes", [])
+], EvmWalletService.prototype, "isConnecting", null);
+__decorate([
+    mobx_1.computed,
+    __metadata("design:type", Object),
+    __metadata("design:paramtypes", [])
+], EvmWalletService.prototype, "isDisconnecting", null);
+__decorate([
+    mobx_1.computed,
+    __metadata("design:type", Object),
+    __metadata("design:paramtypes", [])
+], EvmWalletService.prototype, "isInitialized", null);
+__decorate([
+    mobx_1.computed,
+    __metadata("design:type", Object),
+    __metadata("design:paramtypes", [])
+], EvmWalletService.prototype, "isInitializing", null);
+__decorate([
+    mobx_1.action.bound,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], EvmWalletService.prototype, "syncBalance", null);
+__decorate([
+    mobx_1.action.bound,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], EvmWalletService.prototype, "init", null);

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

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

package/dist/cjs/services/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("../services/EvmWalletService"), exports);