vasku-tip3/dist/additional/Selector.js

TIP-3 Broxus contract

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.Selector = void 0;
const vasku_1 = require("vasku");
const SelectorContent_1 = __importDefault(require("./SelectorContent"));
class Selector extends vasku_1.Contract {
    _call;
    _run;
    _payload;
    constructor(config = {}, options = {}) {
        if (config.address === undefined)
            super({
                abi: SelectorContent_1.default.abi,
                initial: config.initial ?? {},
                keys: config.keys,
                tvc: SelectorContent_1.default.tvc
            }, options);
        else
            super({
                address: config.address,
                abi: SelectorContent_1.default.abi
            }, options);
        this._call = new SelectorCalls(this);
        this._run = new SelectorRuns(this);
        this._payload = new SelectorPayload(this);
    }
    async deploy(value, useGiver = true, timeout = 60000) {
        return await this._deploy(value, {}, useGiver, timeout);
    }
    get call() {
        return this._call;
    }
    get run() {
        return this._run;
    }
    get payload() {
        return this._payload;
    }
}
exports.Selector = Selector;
class SelectorCalls {
    contract;
    constructor(contract) {
        this.contract = contract;
    }
    async calculateAcceptTransferSelector(keys) {
        return await this.contract.callMethod('calculateAcceptTransferSelector', {}, keys);
    }
    async calculateAcceptMintSelector(keys) {
        return await this.contract.callMethod('calculateAcceptMintSelector', {}, keys);
    }
    async calculateAcceptBurnSelector(keys) {
        return await this.contract.callMethod('calculateAcceptBurnSelector', {}, keys);
    }
    async calculateTIP3TokenRootInterfaceID(keys) {
        return await this.contract.callMethod('calculateTIP3TokenRootInterfaceID', {}, keys);
    }
    async calculateTIP3TokenWalletInterfaceID(keys) {
        return await this.contract.callMethod('calculateTIP3TokenWalletInterfaceID', {}, keys);
    }
    async calculateSIDInterfaceID(keys) {
        return await this.contract.callMethod('calculateSIDInterfaceID', {}, keys);
    }
    async calculateVersionedInterfaceID(keys) {
        return await this.contract.callMethod('calculateVersionedInterfaceID', {}, keys);
    }
    async calculateTokenRootInterfaceID(keys) {
        return await this.contract.callMethod('calculateTokenRootInterfaceID', {}, keys);
    }
    async calculateTokenWalletInterfaceID(keys) {
        return await this.contract.callMethod('calculateTokenWalletInterfaceID', {}, keys);
    }
    async calculateBurnableTokenWalletInterfaceID(keys) {
        return await this.contract.callMethod('calculateBurnableTokenWalletInterfaceID', {}, keys);
    }
    async calculateBurnableByRootTokenRootInterfaceID(keys) {
        return await this.contract.callMethod('calculateBurnableByRootTokenRootInterfaceID', {}, keys);
    }
    async calculateBurnableByRootTokenWalletInterfaceID(keys) {
        return await this.contract.callMethod('calculateBurnableByRootTokenWalletInterfaceID', {}, keys);
    }
    async calculateDestroyableInterfaceID(keys) {
        return await this.contract.callMethod('calculateDestroyableInterfaceID', {}, keys);
    }
    async calculateDisableableMintTokenRootInterfaceID(keys) {
        return await this.contract.callMethod('calculateDisableableMintTokenRootInterfaceID', {}, keys);
    }
    async calculateTransferableOwnershipInterfaceID(keys) {
        return await this.contract.callMethod('calculateTransferableOwnershipInterfaceID', {}, keys);
    }
    async calculateBurnPausableTokenRootInterfaceID(keys) {
        return await this.contract.callMethod('calculateBurnPausableTokenRootInterfaceID', {}, keys);
    }
    async calculateTokenWalletUpgradeableInterfaceID(keys) {
        return await this.contract.callMethod('calculateTokenWalletUpgradeableInterfaceID', {}, keys);
    }
    async calculateTokenRootUpgradeableInterfaceID(keys) {
        return await this.contract.callMethod('calculateTokenRootUpgradeableInterfaceID', {}, keys);
    }
}
class SelectorRuns {
    contract;
    constructor(contract) {
        this.contract = contract;
    }
    async calculateAcceptTransferSelector() {
        return (await this.contract.runMethod('calculateAcceptTransferSelector')).value;
    }
    async calculateAcceptMintSelector() {
        return (await this.contract.runMethod('calculateAcceptMintSelector')).value;
    }
    async calculateAcceptBurnSelector() {
        return (await this.contract.runMethod('calculateAcceptBurnSelector')).value;
    }
    async calculateTIP3TokenRootInterfaceID() {
        return (await this.contract.runMethod('calculateTIP3TokenRootInterfaceID')).value;
    }
    async calculateTIP3TokenWalletInterfaceID() {
        return (await this.contract.runMethod('calculateTIP3TokenWalletInterfaceID')).value;
    }
    async calculateSIDInterfaceID() {
        return (await this.contract.runMethod('calculateSIDInterfaceID')).value;
    }
    async calculateVersionedInterfaceID() {
        return (await this.contract.runMethod('calculateVersionedInterfaceID')).value;
    }
    async calculateTokenRootInterfaceID() {
        return (await this.contract.runMethod('calculateTokenRootInterfaceID')).value;
    }
    async calculateTokenWalletInterfaceID() {
        return (await this.contract.runMethod('calculateTokenWalletInterfaceID')).value;
    }
    async calculateBurnableTokenWalletInterfaceID() {
        return (await this.contract.runMethod('calculateBurnableTokenWalletInterfaceID')).value;
    }
    async calculateBurnableByRootTokenRootInterfaceID() {
        return (await this.contract.runMethod('calculateBurnableByRootTokenRootInterfaceID')).value;
    }
    async calculateBurnableByRootTokenWalletInterfaceID() {
        return (await this.contract.runMethod('calculateBurnableByRootTokenWalletInterfaceID')).value;
    }
    async calculateDestroyableInterfaceID() {
        return (await this.contract.runMethod('calculateDestroyableInterfaceID')).value;
    }
    async calculateDisableableMintTokenRootInterfaceID() {
        return (await this.contract.runMethod('calculateDisableableMintTokenRootInterfaceID')).value;
    }
    async calculateTransferableOwnershipInterfaceID() {
        return (await this.contract.runMethod('calculateTransferableOwnershipInterfaceID')).value;
    }
    async calculateBurnPausableTokenRootInterfaceID() {
        return (await this.contract.runMethod('calculateBurnPausableTokenRootInterfaceID')).value;
    }
    async calculateTokenWalletUpgradeableInterfaceID() {
        return (await this.contract.runMethod('calculateTokenWalletUpgradeableInterfaceID')).value;
    }
    async calculateTokenRootUpgradeableInterfaceID() {
        return (await this.contract.runMethod('calculateTokenRootUpgradeableInterfaceID')).value;
    }
}
class SelectorPayload {
    contract;
    constructor(contract) {
        this.contract = contract;
    }
    async calculateAcceptTransferSelector() {
        return await this.contract.createPayload('calculateAcceptTransferSelector');
    }
    async calculateAcceptMintSelector() {
        return await this.contract.createPayload('calculateAcceptMintSelector');
    }
    async calculateAcceptBurnSelector() {
        return await this.contract.createPayload('calculateAcceptBurnSelector');
    }
    async calculateTIP3TokenRootInterfaceID() {
        return await this.contract.createPayload('calculateTIP3TokenRootInterfaceID');
    }
    async calculateTIP3TokenWalletInterfaceID() {
        return await this.contract.createPayload('calculateTIP3TokenWalletInterfaceID');
    }
    async calculateSIDInterfaceID() {
        return await this.contract.createPayload('calculateSIDInterfaceID');
    }
    async calculateVersionedInterfaceID() {
        return await this.contract.createPayload('calculateVersionedInterfaceID');
    }
    async calculateTokenRootInterfaceID() {
        return await this.contract.createPayload('calculateTokenRootInterfaceID');
    }
    async calculateTokenWalletInterfaceID() {
        return await this.contract.createPayload('calculateTokenWalletInterfaceID');
    }
    async calculateBurnableTokenWalletInterfaceID() {
        return await this.contract.createPayload('calculateBurnableTokenWalletInterfaceID');
    }
    async calculateBurnableByRootTokenRootInterfaceID() {
        return await this.contract.createPayload('calculateBurnableByRootTokenRootInterfaceID');
    }
    async calculateBurnableByRootTokenWalletInterfaceID() {
        return await this.contract.createPayload('calculateBurnableByRootTokenWalletInterfaceID');
    }
    async calculateDestroyableInterfaceID() {
        return await this.contract.createPayload('calculateDestroyableInterfaceID');
    }
    async calculateDisableableMintTokenRootInterfaceID() {
        return await this.contract.createPayload('calculateDisableableMintTokenRootInterfaceID');
    }
    async calculateTransferableOwnershipInterfaceID() {
        return await this.contract.createPayload('calculateTransferableOwnershipInterfaceID');
    }
    async calculateBurnPausableTokenRootInterfaceID() {
        return await this.contract.createPayload('calculateBurnPausableTokenRootInterfaceID');
    }
    async calculateTokenWalletUpgradeableInterfaceID() {
        return await this.contract.createPayload('calculateTokenWalletUpgradeableInterfaceID');
    }
    async calculateTokenRootUpgradeableInterfaceID() {
        return await this.contract.createPayload('calculateTokenRootUpgradeableInterfaceID');
    }
}