squid-js/src/ocean/Account.ts

import BigNumber from "bignumber.js"
import Balance from "../models/Balance"

import { Instantiable, InstantiableConfig } from "../Instantiable.abstract"

/**
 * Account information.
 */
export default class Account extends Instantiable {
    private password?: string
    private token?: string

    constructor(private id: string = "0x0", config?: InstantiableConfig) {
        super()
        if (config) {
            this.setInstanceConfig(config)
        }
    }

    public getId() {
        return this.id
    }

    public setId(id) {
        this.id = id
    }

    /**
     * Set account password.
     * @param {string} password Password for account.
     */
    public setPassword(password: string): void {
        this.password = password
    }

    /**
     * Returns account password.
     * @return {string} Account password.
     */
    public getPassword(): string {
        return this.password
    }

    /**
     * Set account token.
     * @param {string} token Token for account.
     */
    public setToken(token: string): void {
        this.token = token
    }

    /**
     * Returns account token.
     * @return {Promise<string>} Account token.
     */
    public async getToken(): Promise<string> {
        return this.token || await this.ocean.auth.restore(this)
    }

    /**
     * Returns if account token is stored.
     * @return {Promise<boolean>} Is stored.
     */
    public isTokenStored(): Promise<boolean> {
        return this.ocean.auth.isStored(this)
    }

    /**
     * Authenticate the account.
     */
    public authenticate() {
        return this.ocean.auth.store(this)
    }

    /**
     * Balance of Ocean Token.
     * @return {Promise<number>}
     */
    public async getOceanBalance(): Promise<number> {
        const token = this.ocean.keeper.token
        return await token.balanceOf(this.id) / (10 ** await token.decimals())
    }

    /**
     * Balance of Ether.
     * @return {Promise<number>}
     */
    public async getEtherBalance(): Promise<number> {
        return this.web3
            .eth
            .getBalance(this.id, "latest")
            .then((balance: string): number => {
                return new BigNumber(balance).toNumber()
            })
    }

    /**
     * Balances of Ether and Ocean Token.
     * @return {Promise<Balance>}
     */
    public async getBalance(): Promise<Balance> {
        return {
            eth: await this.getEtherBalance(),
            ocn: await this.getOceanBalance(),
        }
    }

    /**
     * Request Ocean Tokens.
     * @param  {number} amount Tokens to be requested.
     * @return {Promise<number>}
     */
    public async requestTokens(amount: number | string): Promise<string> {
        amount = String(amount)
        try {
            await this.ocean.keeper
                .dispenser
                .requestTokens(amount, this.id)
        } catch (e) {
            this.logger.error(e)
            throw new Error("Error requesting tokens")

        }
        return amount
    }
}