vasku-tip3/dist/TokenRootUpgradeable.d.ts

TIP-3 Broxus contract

import { type CompiledContractConfig, Contract, type ContractOptions, type ResultOfCall } from 'vasku';
import { type KeyPair, type ResultOfProcessMessage } from '@eversdk/core';
type constructorIn = {
    initialSupplyTo: string;
    initialSupply: string | number | bigint;
    deployWalletValue: string | number | bigint;
    mintDisabled: boolean;
    burnByRootDisabled: boolean;
    burnPaused: boolean;
    remainingGasTo: string;
};
type supportsInterfaceIn = {
    answerId: string | number | bigint;
    interfaceID: string | number | bigint;
};
type supportsInterfaceOut = {
    value0: string;
};
type walletVersionIn = {
    answerId: string | number | bigint;
};
type walletVersionOut = {
    value0: string;
};
type platformCodeIn = {
    answerId: string | number | bigint;
};
type platformCodeOut = {
    value0: string;
};
type requestUpgradeWalletIn = {
    currentVersion: string | number | bigint;
    walletOwner: string;
    remainingGasTo: string;
};
type setWalletCodeIn = {
    code: string;
};
type upgradeIn = {
    code: string;
};
type disableMintIn = {
    answerId: string | number | bigint;
};
type disableMintOut = {
    value0: string;
};
type mintDisabledIn = {
    answerId: string | number | bigint;
};
type mintDisabledOut = {
    value0: string;
};
type burnTokensIn = {
    amount: string | number | bigint;
    walletOwner: string;
    remainingGasTo: string;
    callbackTo: string;
    payload: string;
};
type disableBurnByRootIn = {
    answerId: string | number | bigint;
};
type disableBurnByRootOut = {
    value0: string;
};
type burnByRootDisabledIn = {
    answerId: string | number | bigint;
};
type burnByRootDisabledOut = {
    value0: string;
};
type burnPausedIn = {
    answerId: string | number | bigint;
};
type burnPausedOut = {
    value0: string;
};
type setBurnPausedIn = {
    answerId: string | number | bigint;
    paused: boolean;
};
type setBurnPausedOut = {
    value0: string;
};
type transferOwnershipIn = {
    newOwner: string;
    remainingGasTo: string;
    callbacks: {
        [key: string | number]: {
            value: string | number | bigint;
            payload: string;
        };
    };
};
type nameIn = {
    answerId: string | number | bigint;
};
type nameOut = {
    value0: string;
};
type symbolIn = {
    answerId: string | number | bigint;
};
type symbolOut = {
    value0: string;
};
type decimalsIn = {
    answerId: string | number | bigint;
};
type decimalsOut = {
    value0: string;
};
type totalSupplyIn = {
    answerId: string | number | bigint;
};
type totalSupplyOut = {
    value0: string;
};
type walletCodeIn = {
    answerId: string | number | bigint;
};
type walletCodeOut = {
    value0: string;
};
type rootOwnerIn = {
    answerId: string | number | bigint;
};
type rootOwnerOut = {
    value0: string;
};
type walletOfIn = {
    answerId: string | number | bigint;
    walletOwner: string;
};
type walletOfOut = {
    value0: string;
};
type deployWalletIn = {
    answerId: string | number | bigint;
    walletOwner: string;
    deployWalletValue: string | number | bigint;
};
type deployWalletOut = {
    tokenWallet: string;
};
type mintIn = {
    amount: string | number | bigint;
    recipient: string;
    deployWalletValue: string | number | bigint;
    remainingGasTo: string;
    notify: boolean;
    payload: string;
};
type acceptBurnIn = {
    amount: string | number | bigint;
    walletOwner: string;
    remainingGasTo: string;
    callbackTo: string;
    payload: string;
};
type sendSurplusGasIn = {
    to: string;
};
export declare class TokenRootUpgradeable extends Contract {
    private readonly _call;
    private readonly _run;
    private readonly _payload;
    constructor(config?: CompiledContractConfig, options?: ContractOptions);
    deploy(value: string | number | bigint, input: constructorIn, useGiver?: boolean, timeout?: number): Promise<ResultOfProcessMessage>;
    get call(): TokenRootUpgradeableCalls;
    get run(): TokenRootUpgradeableRuns;
    get payload(): TokenRootUpgradeablePayload;
}
declare class TokenRootUpgradeableCalls {
    private readonly contract;
    constructor(contract: Contract);
    supportsInterface(input: supportsInterfaceIn, keys?: KeyPair): Promise<ResultOfCall & {
        out: supportsInterfaceOut;
    }>;
    walletVersion(input: walletVersionIn, keys?: KeyPair): Promise<ResultOfCall & {
        out: walletVersionOut;
    }>;
    platformCode(input: platformCodeIn, keys?: KeyPair): Promise<ResultOfCall & {
        out: platformCodeOut;
    }>;
    requestUpgradeWallet(input: requestUpgradeWalletIn, keys?: KeyPair): Promise<ResultOfCall>;
    setWalletCode(input: setWalletCodeIn, keys?: KeyPair): Promise<ResultOfCall>;
    upgrade(input: upgradeIn, keys?: KeyPair): Promise<ResultOfCall>;
    disableMint(input: disableMintIn, keys?: KeyPair): Promise<ResultOfCall & {
        out: disableMintOut;
    }>;
    mintDisabled(input: mintDisabledIn, keys?: KeyPair): Promise<ResultOfCall & {
        out: mintDisabledOut;
    }>;
    burnTokens(input: burnTokensIn, keys?: KeyPair): Promise<ResultOfCall>;
    disableBurnByRoot(input: disableBurnByRootIn, keys?: KeyPair): Promise<ResultOfCall & {
        out: disableBurnByRootOut;
    }>;
    burnByRootDisabled(input: burnByRootDisabledIn, keys?: KeyPair): Promise<ResultOfCall & {
        out: burnByRootDisabledOut;
    }>;
    burnPaused(input: burnPausedIn, keys?: KeyPair): Promise<ResultOfCall & {
        out: burnPausedOut;
    }>;
    setBurnPaused(input: setBurnPausedIn, keys?: KeyPair): Promise<ResultOfCall & {
        out: setBurnPausedOut;
    }>;
    transferOwnership(input: transferOwnershipIn, keys?: KeyPair): Promise<ResultOfCall>;
    name(input: nameIn, keys?: KeyPair): Promise<ResultOfCall & {
        out: nameOut;
    }>;
    symbol(input: symbolIn, keys?: KeyPair): Promise<ResultOfCall & {
        out: symbolOut;
    }>;
    decimals(input: decimalsIn, keys?: KeyPair): Promise<ResultOfCall & {
        out: decimalsOut;
    }>;
    totalSupply(input: totalSupplyIn, keys?: KeyPair): Promise<ResultOfCall & {
        out: totalSupplyOut;
    }>;
    walletCode(input: walletCodeIn, keys?: KeyPair): Promise<ResultOfCall & {
        out: walletCodeOut;
    }>;
    rootOwner(input: rootOwnerIn, keys?: KeyPair): Promise<ResultOfCall & {
        out: rootOwnerOut;
    }>;
    walletOf(input: walletOfIn, keys?: KeyPair): Promise<ResultOfCall & {
        out: walletOfOut;
    }>;
    deployWallet(input: deployWalletIn, keys?: KeyPair): Promise<ResultOfCall & {
        out: deployWalletOut;
    }>;
    mint(input: mintIn, keys?: KeyPair): Promise<ResultOfCall>;
    acceptBurn(input: acceptBurnIn, keys?: KeyPair): Promise<ResultOfCall>;
    sendSurplusGas(input: sendSurplusGasIn, keys?: KeyPair): Promise<ResultOfCall>;
}
declare class TokenRootUpgradeableRuns {
    private readonly contract;
    constructor(contract: Contract);
    supportsInterface(input: supportsInterfaceIn): Promise<supportsInterfaceOut>;
    walletVersion(input: walletVersionIn): Promise<walletVersionOut>;
    platformCode(input: platformCodeIn): Promise<platformCodeOut>;
    disableMint(input: disableMintIn): Promise<disableMintOut>;
    mintDisabled(input: mintDisabledIn): Promise<mintDisabledOut>;
    disableBurnByRoot(input: disableBurnByRootIn): Promise<disableBurnByRootOut>;
    burnByRootDisabled(input: burnByRootDisabledIn): Promise<burnByRootDisabledOut>;
    burnPaused(input: burnPausedIn): Promise<burnPausedOut>;
    setBurnPaused(input: setBurnPausedIn): Promise<setBurnPausedOut>;
    name(input: nameIn): Promise<nameOut>;
    symbol(input: symbolIn): Promise<symbolOut>;
    decimals(input: decimalsIn): Promise<decimalsOut>;
    totalSupply(input: totalSupplyIn): Promise<totalSupplyOut>;
    walletCode(input: walletCodeIn): Promise<walletCodeOut>;
    rootOwner(input: rootOwnerIn): Promise<rootOwnerOut>;
    walletOf(input: walletOfIn): Promise<walletOfOut>;
    deployWallet(input: deployWalletIn): Promise<deployWalletOut>;
}
declare class TokenRootUpgradeablePayload {
    private readonly contract;
    constructor(contract: Contract);
    supportsInterface(input: supportsInterfaceIn): Promise<string>;
    walletVersion(input: walletVersionIn): Promise<string>;
    platformCode(input: platformCodeIn): Promise<string>;
    requestUpgradeWallet(input: requestUpgradeWalletIn): Promise<string>;
    setWalletCode(input: setWalletCodeIn): Promise<string>;
    upgrade(input: upgradeIn): Promise<string>;
    disableMint(input: disableMintIn): Promise<string>;
    mintDisabled(input: mintDisabledIn): Promise<string>;
    burnTokens(input: burnTokensIn): Promise<string>;
    disableBurnByRoot(input: disableBurnByRootIn): Promise<string>;
    burnByRootDisabled(input: burnByRootDisabledIn): Promise<string>;
    burnPaused(input: burnPausedIn): Promise<string>;
    setBurnPaused(input: setBurnPausedIn): Promise<string>;
    transferOwnership(input: transferOwnershipIn): Promise<string>;
    name(input: nameIn): Promise<string>;
    symbol(input: symbolIn): Promise<string>;
    decimals(input: decimalsIn): Promise<string>;
    totalSupply(input: totalSupplyIn): Promise<string>;
    walletCode(input: walletCodeIn): Promise<string>;
    rootOwner(input: rootOwnerIn): Promise<string>;
    walletOf(input: walletOfIn): Promise<string>;
    deployWallet(input: deployWalletIn): Promise<string>;
    mint(input: mintIn): Promise<string>;
    acceptBurn(input: acceptBurnIn): Promise<string>;
    sendSurplusGas(input: sendSurplusGasIn): Promise<string>;
}
export {};
//# sourceMappingURL=TokenRootUpgradeable.d.ts.map