vasku-tip3/dist/TokenWallet.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.TokenWallet = void 0;
const vasku_1 = require("vasku");
const TokenWalletContent_1 = __importDefault(require("./TokenWalletContent"));
class TokenWallet extends vasku_1.Contract {
    _call;
    _run;
    _payload;
    constructor(config = {}, options = {}) {
        if (config.address === undefined)
            super({
                abi: TokenWalletContent_1.default.abi,
                initial: config.initial ?? {},
                keys: config.keys,
                tvc: TokenWalletContent_1.default.tvc
            }, options);
        else
            super({
                address: config.address,
                abi: TokenWalletContent_1.default.abi
            }, options);
        this._call = new TokenWalletCalls(this);
        this._run = new TokenWalletRuns(this);
        this._payload = new TokenWalletPayload(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.TokenWallet = TokenWallet;
class TokenWalletCalls {
    contract;
    constructor(contract) {
        this.contract = contract;
    }
    async supportsInterface(input, keys) {
        return await this.contract.callMethod('supportsInterface', input, keys);
    }
    async destroy(input, keys) {
        return await this.contract.callMethod('destroy', input, keys);
    }
    async burnByRoot(input, keys) {
        return await this.contract.callMethod('burnByRoot', input, keys);
    }
    async burn(input, keys) {
        return await this.contract.callMethod('burn', input, keys);
    }
    async balance(input, keys) {
        return await this.contract.callMethod('balance', input, keys);
    }
    async owner(input, keys) {
        return await this.contract.callMethod('owner', input, keys);
    }
    async root(input, keys) {
        return await this.contract.callMethod('root', input, keys);
    }
    async walletCode(input, keys) {
        return await this.contract.callMethod('walletCode', input, keys);
    }
    async transfer(input, keys) {
        return await this.contract.callMethod('transfer', input, keys);
    }
    async transferToWallet(input, keys) {
        return await this.contract.callMethod('transferToWallet', input, keys);
    }
    async acceptTransfer(input, keys) {
        return await this.contract.callMethod('acceptTransfer', input, keys);
    }
    async acceptMint(input, keys) {
        return await this.contract.callMethod('acceptMint', input, keys);
    }
    async sendSurplusGas(input, keys) {
        return await this.contract.callMethod('sendSurplusGas', input, keys);
    }
}
class TokenWalletRuns {
    contract;
    constructor(contract) {
        this.contract = contract;
    }
    async supportsInterface(input) {
        return (await this.contract.runMethod('supportsInterface', input)).value;
    }
    async balance(input) {
        return (await this.contract.runMethod('balance', input)).value;
    }
    async owner(input) {
        return (await this.contract.runMethod('owner', input)).value;
    }
    async root(input) {
        return (await this.contract.runMethod('root', input)).value;
    }
    async walletCode(input) {
        return (await this.contract.runMethod('walletCode', input)).value;
    }
}
class TokenWalletPayload {
    contract;
    constructor(contract) {
        this.contract = contract;
    }
    async supportsInterface(input) {
        return await this.contract.createPayload('supportsInterface', input);
    }
    async destroy(input) {
        return await this.contract.createPayload('destroy', input);
    }
    async burnByRoot(input) {
        return await this.contract.createPayload('burnByRoot', input);
    }
    async burn(input) {
        return await this.contract.createPayload('burn', input);
    }
    async balance(input) {
        return await this.contract.createPayload('balance', input);
    }
    async owner(input) {
        return await this.contract.createPayload('owner', input);
    }
    async root(input) {
        return await this.contract.createPayload('root', input);
    }
    async walletCode(input) {
        return await this.contract.createPayload('walletCode', input);
    }
    async transfer(input) {
        return await this.contract.createPayload('transfer', input);
    }
    async transferToWallet(input) {
        return await this.contract.createPayload('transferToWallet', input);
    }
    async acceptTransfer(input) {
        return await this.contract.createPayload('acceptTransfer', input);
    }
    async acceptMint(input) {
        return await this.contract.createPayload('acceptMint', input);
    }
    async sendSurplusGas(input) {
        return await this.contract.createPayload('sendSurplusGas', input);
    }
}