@tokenz/tokens-smartcontract-sdk/lib/STODivident.js

Smart Contract SDK for Tokenz STO platform

const coreLib = require('./Core');


class STODivident{
    constructor(address){
        this.STODivident = new coreLib("STODivident" , address);
        this.setup = this.setup.bind(this);
        this.setup();

    }

    async setup () {
        return new Promise(async function (resolve, reject) {
            try {
                this.macContractAddress = await this.STODivident.callData("maCAddr", []);
                this.ruleEngineAddress = await this.STODivident.callData("ruCAddr", []);
                this.contractCategory = await this.STODivident.callData("contractCategory", []);
                this.contractType = await this.STODivident.callData("contractType", []);
                this.kycRegisAddress = await this.STODivident.callData("kycAddr", []);
                this.STOFactoryAddress = await this.STODivident.callData("stfAddr", []);
                this.STOTokenAddress = await this.STODivident.callData("STOAddress", []);
                this.STOTotalSupply = await this.STODivident.callData("stoSupply", []);

                resolve(0);
            } catch (err) {
                window.Sentry.captureException(err);
                console.log(err);
                reject(0)
            }
        }.bind(this))
    }


    async fetchAllocation( address ) {
        return new Promise(async function (resolve, reject) {
            try {
                let result = await this.STODivident.callData("allocation", []);
                resolve(result);
            } catch (err) {
                window.Sentry.captureException(err);
                reject(0)
            }
        }.bind(this))
    }

    async fetchAllocation( address ) {
        return new Promise(async function (resolve, reject) {
            try {
                let result = await this.STODivident.callData("allocation", []);
                resolve(result);
            } catch (err) {
                window.Sentry.captureException(err);
                reject(0)
            }
        }.bind(this))
    }

    async fetchContractState( ) {
        return new Promise(async function (resolve, reject) {
            try {
                let result = await this.STODivident.callData("state", []);
                resolve(result);
            } catch (err) {
                window.Sentry.captureException(err);
                reject(0)
            }
        }.bind(this))
    }

    async fetchDividentDistribution( ) {
        return new Promise(async function (resolve, reject) {
            try {
                let result = {
                    "totalAlloted" : await this.STODivident.callData("initDist", []),
                    "pendingDistribution" : await this.STODivident.callData("currentDist", []);
                }
                resolve(result);
            } catch (err) {
                window.Sentry.captureException(err);
                reject(0)
            }
        }.bind(this))
    }

    async allotDivident( address ) {
        return new Promise(async function (resolve, reject) {
            try {
                let result = await this.STODivident.sendTx("allotment", [ address ]);
                resolve(result);
            } catch (err) {
                window.Sentry.captureException(err);
                reject(0)
            }
        }.bind(this))
    }

    async depositDivident( amt ) {
        return new Promise(async function (resolve, reject) {
            try {
                let result = await this.STODivident.sendTx("deposit", [] , amt);
                resolve(result);
            } catch (err) {
                window.Sentry.captureException(err);
                reject(0)
            }
        }.bind(this))
    }

    async redeemDivident() {
        return new Promise(async function (resolve, reject) {
            try {
                let result = await this.STODivident.sendTx("redeem", []);
                resolve(result);
            } catch (err) {
                window.Sentry.captureException(err);
                reject(0)
            }
        }.bind(this))
    }

    async calculateDivident( address ) {
        return new Promise(async function (resolve, reject) {
            try {
                let result = await this.STODivident.callData("calculateR", [ address ]);
                resolve(result);
            } catch (err) {
                window.Sentry.captureException(err);
                reject(0)
            }
        }.bind(this))
    }

    async finalizeDividentContract( ) {
        return new Promise(async function (resolve, reject) {
            try {
                let result = await this.STODivident.sendTx("finalize", []);
                resolve(result);
            } catch (err) {
                window.Sentry.captureException(err);
                reject(0)
            }
        }.bind(this))
    }

    async withdraw( amt ) {
        return new Promise(async function (resolve, reject) {
            try {
                let result = await this.STODivident.sendTx("withdraw", [ amt ] , 0);
                resolve(result);
            } catch (err) {
                window.Sentry.captureException(err);
                reject(0)
            }
        }.bind(this))
    }


}

module.exports = STODivident;