web3.service.ts

import Web3 from 'web3';
import SlpAbi from '../../../../assets/json/contracts/SLP.json';
import StakingAbi from '../../../../assets/json/contracts/STAKING.json';
import OnsenAbi from '../../../../assets/json/contracts/ONSEN.json';
import {
    ETHEREUM,
    METAMASK_ERRORS,
    METAMASK_LINK,
    WEB3,
    STAKING_CONTRACT_ADDRESS_MAIN_NET, ONSEN_CONTRACT_ADDRESS_MAIN_NET, SLP_TOKEN_ADDRESS_MAIN_NET, INFURA_PROVIDER_ADDRESS
} from '../../dictionaries/meta-mask.dictionary';
import {from, Observable, throwError} from 'rxjs';
import {catchError, map} from 'rxjs/operators';
import {Contract} from 'web3-eth-contract';

export class Web3Service {

    private messageResult: string;

    constructor() {}

    public isMetaMaskInstalled(): boolean {
        return !!window[ETHEREUM];
    }

    public connectToMetaMask(): Observable<string> {
        if (!this.isMetaMaskInstalled()) {
            window.open(METAMASK_LINK, '_blank');
            return throwError(METAMASK_ERRORS.notInstalled);
        }
        window[WEB3] = new Web3(window[ETHEREUM]);
        return from(this.setMetamaskProvider())
            .pipe(
                map((accounts) => accounts[0]),
                catchError(() => {
                    return throwError(METAMASK_ERRORS.noAccount);
                }));
    }

    public setMetamaskProvider(): Promise<any> {
        window[WEB3] = new Web3(window[ETHEREUM]);
        return window[ETHEREUM].enable();
    }

    public setInfuraProvider(): Promise<void> {
        return new Promise((resolve) => {
            window[WEB3] = new Web3(new Web3.providers.HttpProvider(INFURA_PROVIDER_ADDRESS));
            resolve();
        });
    }

    public loadBlockChainData(): Promise<string> {
        return new Promise((resolve, reject) => {
            const web3 = window[WEB3];
            const account = web3.eth.getAccounts();
            if (account !== undefined) {
                resolve(account);
            } else {
                this.messageResult = METAMASK_ERRORS.noAccount;
                reject(this.messageResult);
            }
        });
    }

    public getStakingContract(): Promise<Contract> {
        return new Promise((resolve) => {
            const web3 = window[WEB3];
            const contract = new web3.eth.Contract(StakingAbi, STAKING_CONTRACT_ADDRESS_MAIN_NET);
            resolve(contract);
        });
    }

    public getOnsenContract(): Promise<Contract> {
        return new Promise((resolve) => {
            const web3 = window[WEB3];
            const contract = new web3.eth.Contract(OnsenAbi, ONSEN_CONTRACT_ADDRESS_MAIN_NET);
            resolve(contract);
        });
    }

    public getSlpContract(): Promise<Contract> {
        return new Promise((resolve) => {
            const web3 = window[WEB3];
            const contract = new web3.eth.Contract(SlpAbi, SLP_TOKEN_ADDRESS_MAIN_NET);
            resolve(contract);
        });
    }
}