vasku-tip3/dist/TokenWallet.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 supportsInterfaceIn = {
    answerId: string | number | bigint;
    interfaceID: string | number | bigint;
};
type supportsInterfaceOut = {
    value0: string;
};
type destroyIn = {
    remainingGasTo: string;
};
type burnByRootIn = {
    amount: string | number | bigint;
    remainingGasTo: string;
    callbackTo: string;
    payload: string;
};
type burnIn = {
    amount: string | number | bigint;
    remainingGasTo: string;
    callbackTo: string;
    payload: string;
};
type balanceIn = {
    answerId: string | number | bigint;
};
type balanceOut = {
    value0: string;
};
type ownerIn = {
    answerId: string | number | bigint;
};
type ownerOut = {
    value0: string;
};
type rootIn = {
    answerId: string | number | bigint;
};
type rootOut = {
    value0: string;
};
type walletCodeIn = {
    answerId: string | number | bigint;
};
type walletCodeOut = {
    value0: string;
};
type transferIn = {
    amount: string | number | bigint;
    recipient: string;
    deployWalletValue: string | number | bigint;
    remainingGasTo: string;
    notify: boolean;
    payload: string;
};
type transferToWalletIn = {
    amount: string | number | bigint;
    recipientTokenWallet: string;
    remainingGasTo: string;
    notify: boolean;
    payload: string;
};
type acceptTransferIn = {
    amount: string | number | bigint;
    sender: string;
    remainingGasTo: string;
    notify: boolean;
    payload: string;
};
type acceptMintIn = {
    amount: string | number | bigint;
    remainingGasTo: string;
    notify: boolean;
    payload: string;
};
type sendSurplusGasIn = {
    to: string;
};
export declare class TokenWallet extends Contract {
    private readonly _call;
    private readonly _run;
    private readonly _payload;
    constructor(config?: CompiledContractConfig, options?: ContractOptions);
    deploy(value: string | number | bigint, useGiver?: boolean, timeout?: number): Promise<ResultOfProcessMessage>;
    get call(): TokenWalletCalls;
    get run(): TokenWalletRuns;
    get payload(): TokenWalletPayload;
}
declare class TokenWalletCalls {
    private readonly contract;
    constructor(contract: Contract);
    supportsInterface(input: supportsInterfaceIn, keys?: KeyPair): Promise<ResultOfCall & {
        out: supportsInterfaceOut;
    }>;
    destroy(input: destroyIn, keys?: KeyPair): Promise<ResultOfCall>;
    burnByRoot(input: burnByRootIn, keys?: KeyPair): Promise<ResultOfCall>;
    burn(input: burnIn, keys?: KeyPair): Promise<ResultOfCall>;
    balance(input: balanceIn, keys?: KeyPair): Promise<ResultOfCall & {
        out: balanceOut;
    }>;
    owner(input: ownerIn, keys?: KeyPair): Promise<ResultOfCall & {
        out: ownerOut;
    }>;
    root(input: rootIn, keys?: KeyPair): Promise<ResultOfCall & {
        out: rootOut;
    }>;
    walletCode(input: walletCodeIn, keys?: KeyPair): Promise<ResultOfCall & {
        out: walletCodeOut;
    }>;
    transfer(input: transferIn, keys?: KeyPair): Promise<ResultOfCall>;
    transferToWallet(input: transferToWalletIn, keys?: KeyPair): Promise<ResultOfCall>;
    acceptTransfer(input: acceptTransferIn, keys?: KeyPair): Promise<ResultOfCall>;
    acceptMint(input: acceptMintIn, keys?: KeyPair): Promise<ResultOfCall>;
    sendSurplusGas(input: sendSurplusGasIn, keys?: KeyPair): Promise<ResultOfCall>;
}
declare class TokenWalletRuns {
    private readonly contract;
    constructor(contract: Contract);
    supportsInterface(input: supportsInterfaceIn): Promise<supportsInterfaceOut>;
    balance(input: balanceIn): Promise<balanceOut>;
    owner(input: ownerIn): Promise<ownerOut>;
    root(input: rootIn): Promise<rootOut>;
    walletCode(input: walletCodeIn): Promise<walletCodeOut>;
}
declare class TokenWalletPayload {
    private readonly contract;
    constructor(contract: Contract);
    supportsInterface(input: supportsInterfaceIn): Promise<string>;
    destroy(input: destroyIn): Promise<string>;
    burnByRoot(input: burnByRootIn): Promise<string>;
    burn(input: burnIn): Promise<string>;
    balance(input: balanceIn): Promise<string>;
    owner(input: ownerIn): Promise<string>;
    root(input: rootIn): Promise<string>;
    walletCode(input: walletCodeIn): Promise<string>;
    transfer(input: transferIn): Promise<string>;
    transferToWallet(input: transferToWalletIn): Promise<string>;
    acceptTransfer(input: acceptTransferIn): Promise<string>;
    acceptMint(input: acceptMintIn): Promise<string>;
    sendSurplusGas(input: sendSurplusGasIn): Promise<string>;
}
export {};
//# sourceMappingURL=TokenWallet.d.ts.map