js-databox/cjs/metabox/metabox.js

databox & metabox

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.MetaBox = exports.mb_cid = void 0;
const metabox_1 = require("./did/metabox");
const agent_1 = require("@dfinity/agent");
const principal_1 = require("@dfinity/principal");
const utils_1 = require("../utils");
exports.mb_cid = "zbzr7-xyaaa-aaaan-qadeq-cai";
class MetaBox {
    constructor(agent) {
        this.metaBoxCai = exports.mb_cid;
        this.agent = agent;
        this.MetaBoxActor = agent_1.Actor.createActor(metabox_1.idlFactory, { agent, canisterId: this.metaBoxCai });
    }
    async isNotFirstDataBox() {
        try {
            const Actor = this.MetaBoxActor;
            return await Actor.isNotFirstDataBox();
        }
        catch (e) {
            throw e;
        }
    }
    async get_accountID() {
        const principal = await this.agent.getPrincipal();
        return (0, utils_1.getToAccountIdentifier)(principal_1.Principal.from(this.metaBoxCai), principal);
    }
    async createBoxFree(arg) {
        return new Promise(async (resolve, reject) => {
            try {
                const Actor = this.MetaBoxActor;
                const Arg = {
                    'metadata': arg
                };
                const res = await Actor.createDataBoxFree(Arg);
                if (Object.keys(res)[0] === "ok")
                    return resolve(res.ok);
                else
                    reject(`${Object.keys(res.err)[0]}`);
            }
            catch (e) {
                reject(e);
            }
        });
    }
    async createBoxFee(arg, is_need_refresh) {
        return new Promise(async (resolve, reject) => {
            try {
                const Actor = this.MetaBoxActor;
                const Arg = {
                    'metadata': arg
                };
                const res = await Actor.createDataBoxFee(Arg, is_need_refresh);
                if (Object.keys(res)[0] === "ok")
                    return resolve(res.ok);
                else
                    reject(`${Object.keys(res.err)[0]}`);
            }
            catch (e) {
                reject(e);
            }
        });
    }
    async getICP() {
        try {
            const Actor = this.MetaBoxActor;
            const res = await Actor.getIcp();
            return Number(res);
        }
        catch (e) {
            throw e;
        }
    }
    async getBoxes(principal) {
        try {
            return await this.MetaBoxActor.getBoxes(principal);
        }
        catch (e) {
            throw e;
        }
    }
    async deleteBox(delBoxArgs) {
        try {
            return await this.MetaBoxActor.deleteBox(delBoxArgs);
        }
        catch (e) {
            throw e;
        }
    }
    async transferDataboxOwner(canister_id, to) {
        try {
            return await this.MetaBoxActor.transferDataboxOwner(canister_id, to);
        }
        catch (e) {
            throw e;
        }
    }
    async startBox(boxInfo) {
        try {
            await this.MetaBoxActor.startBox(boxInfo);
        }
        catch (e) {
            throw e;
        }
    }
    async topUpBox(TopUpArgs) {
        try {
            return await this.MetaBoxActor.topUpBox(TopUpArgs);
        }
        catch (e) {
            throw e;
        }
    }
    async upgradeBox(UpgradeBoxArgs) {
        try {
            return await this.MetaBoxActor.upgradeBox(UpgradeBoxArgs);
        }
        catch (e) {
            throw e;
        }
    }
    async getDataBoxVersion() {
        try {
            return await this.MetaBoxActor.getDataBoxVersion();
        }
        catch (e) {
            throw e;
        }
    }
    async updateBoxInfo(BoxInfo__1) {
        try {
            return await this.MetaBoxActor.updateBoxInfo(BoxInfo__1);
        }
        catch (e) {
            throw e;
        }
    }
    createDataBoxControl(arg, is_need_refresh, controller) {
        return new Promise(async (resolve, reject) => {
            try {
                const Actor = this.MetaBoxActor;
                const arg_0 = {
                    metadata: arg
                };
                const res = await Actor.createDataBoxControl(arg_0, is_need_refresh, controller ? [controller] : []);
                if (Object.keys(res)[0] === "ok")
                    return resolve(res.ok);
                else
                    reject(`${Object.keys(res.err)[0]}`);
            }
            catch (e) {
                throw e;
            }
        });
    }
    async withDrawICP(to, amount) {
        try {
            const Actor = this.MetaBoxActor;
            const tmp1 = (0, utils_1.getUint8ArrayFromHex)(to);
            return await Actor.transferOutICP(tmp1, BigInt(amount * 1e8));
        }
        catch (e) {
            throw e;
        }
    }
}
exports.MetaBox = MetaBox;