vasku/build/contract/samples/SafeMultisigWallet/index.d.ts

TVM-Solidity contract development framework

import { type CompiledContractConfig, Contract, type ContractOptions, type ResultOfCall } from '../../index';
import { type KeyPair, type ResultOfProcessMessage } from '@eversdk/core';
type DeployIn = {
    owners: string[] | number[] | bigint[];
    reqConfirms: string | number | bigint;
};
type SendTransactionIn = {
    dest: string;
    value: string | number | bigint;
    bounce: boolean;
    flags: string | number | bigint;
    payload: string;
};
type AcceptTransferIn = {
    payload: string;
};
type SubmitTransactionIn = {
    dest: string;
    value: string | number | bigint;
    bounce: boolean;
    flags: string | number | bigint;
    payload: string;
};
type SubmitTransactionOut = {
    transId: string;
};
type ConfirmTransactionIn = {
    transactionId: string | number | bigint;
};
type IsConfirmedIn = {
    mask: string | number | bigint;
    index: string | number | bigint;
};
type IsConfirmedOut = {
    confirmed: boolean;
};
type GetParametersOut = {
    maxQueuedTransactions: string;
    maxCustodianCount: string;
    expirationTime: string;
    minValue: string;
    requiredTxnConfirms: string;
};
type GetTransactionIn = {
    transactionId: string | number | bigint;
};
type GetTransactionOut = {
    trans: {
        id: string;
        confirmationsMask: string;
        signsRequired: string;
        signsReceived: string;
        creator: string;
        index: string;
        dest: string;
        value: string;
        sendFlags: string;
        payload: string;
        bounce: boolean;
    };
};
type GetTransactionsOut = {
    trans: Array<{
        id: string;
        confirmationsMask: string;
        signsRequired: string;
        signsReceived: string;
        creator: string;
        index: string;
        dest: string;
        value: string;
        sendFlags: string;
        payload: string;
        bounce: boolean;
    }>;
};
type GetTransactionIdsOut = {
    ids: string[];
};
type GetCustodiansOut = {
    index: string;
    name: string;
};
export declare class SafeMultisigWallet extends Contract {
    private readonly _call;
    private readonly _run;
    private readonly _payload;
    constructor(config?: CompiledContractConfig, options?: ContractOptions);
    deploy(value: string | number | bigint, input: DeployIn, useGiver?: boolean, timeout?: number): Promise<ResultOfProcessMessage>;
    get call(): SafeMultisigWalletCalls;
    get run(): SafeMultisigWalletRuns;
    get payload(): SafeMultisigWalletPayload;
}
declare class SafeMultisigWalletCalls {
    private readonly contract;
    constructor(contract: Contract);
    acceptTransfer(input: AcceptTransferIn, keys?: KeyPair): Promise<ResultOfCall>;
    sendTransaction(input: SendTransactionIn, keys?: KeyPair): Promise<ResultOfCall>;
    submitTransaction(input: SubmitTransactionIn, keys?: KeyPair): Promise<ResultOfCall & {
        out: SubmitTransactionOut;
    }>;
    confirmTransaction(input: ConfirmTransactionIn, keys?: KeyPair): Promise<ResultOfCall>;
    isConfirmed(input: IsConfirmedIn, keys?: KeyPair): Promise<ResultOfCall & {
        out: IsConfirmedOut;
    }>;
    getParameters(keys?: KeyPair): Promise<ResultOfCall & {
        out: GetParametersOut;
    }>;
    getTransaction(input: GetTransactionIn, keys?: KeyPair): Promise<ResultOfCall & {
        out: GetTransactionOut;
    }>;
    getTransactions(keys?: KeyPair): Promise<ResultOfCall & {
        out: GetTransactionsOut;
    }>;
    getTransactionIds(keys?: KeyPair): Promise<ResultOfCall & {
        out: GetTransactionIdsOut;
    }>;
    getCustodians(keys?: KeyPair): Promise<ResultOfCall & {
        out: GetCustodiansOut;
    }>;
}
declare class SafeMultisigWalletRuns {
    private readonly contract;
    constructor(contract: Contract);
    submitTransaction(input: SubmitTransactionIn): Promise<SubmitTransactionOut>;
    isConfirmed(input: IsConfirmedIn): Promise<IsConfirmedOut>;
    getParameters(): Promise<GetParametersOut>;
    getTransaction(input: GetTransactionIn): Promise<GetTransactionOut>;
    getTransactions(): Promise<GetTransactionsOut>;
    getTransactionIds(): Promise<GetTransactionIdsOut>;
    getCustodians(): Promise<GetCustodiansOut>;
}
declare class SafeMultisigWalletPayload {
    private readonly contract;
    constructor(contract: Contract);
    acceptTransfer(input: AcceptTransferIn): Promise<string>;
    sendTransaction(input: SendTransactionIn): Promise<string>;
    submitTransaction(input: SubmitTransactionIn): Promise<string>;
    confirmTransaction(input: ConfirmTransactionIn): Promise<string>;
    isConfirmed(input: IsConfirmedIn): Promise<string>;
    getParameters(): Promise<string>;
    getTransaction(input: GetTransactionIn): Promise<string>;
    getTransactions(): Promise<string>;
    getTransactionIds(): Promise<string>;
    getCustodians(): Promise<string>;
}
export {};
//# sourceMappingURL=index.d.ts.map