/// <reference types="node" />
import { Server } from "../../../server";
import { PermanentProver } from "../../../app/modules/prover/lib/permanentProver";
import { BlockDTO } from "../../../app/lib/dto/BlockDTO";
import * as stream from "stream";
import { RevocationDTO } from "../../../app/lib/dto/RevocationDTO";
import { IdentityDTO } from "../../../app/lib/dto/IdentityDTO";
import { PeerDTO } from "../../../app/lib/dto/PeerDTO";
import { BmaApi } from "../../../app/modules/bma/lib/network";
import { DBIdentity } from "../../../app/lib/dal/sqliteDAL/IdentityDAL";
import { CertificationDTO } from "../../../app/lib/dto/CertificationDTO";
import { BlockchainService } from "../../../app/service/BlockchainService";
import { PeeringService } from "../../../app/service/PeeringService";
import { ConfDTO } from "../../../app/lib/dto/ConfDTO";
import { FileDAL } from "../../../app/lib/dal/fileDAL";
import { MembershipDTO } from "../../../app/lib/dto/MembershipDTO";
import { TransactionDTO } from "../../../app/lib/dto/TransactionDTO";
import { Key } from "../../../app/lib/common-libs/crypto/keyring";
import { WS2PConnection } from "../../../app/modules/ws2p/lib/WS2PConnection";
import { WS2PMessageHandler } from "../../../app/modules/ws2p/lib/impl/WS2PMessageHandler";
import { WS2PCluster } from "../../../app/modules/ws2p/lib/WS2PCluster";
import { WS2PServer } from "../../../app/modules/ws2p/lib/WS2PServer";
import { TestUser } from "./TestUser";
import { WS2PClient } from "../../../app/modules/ws2p/lib/WS2PClient";
import { DBBlock } from "../../../app/lib/db/DBBlock";
import { DBPeer } from "../../../app/lib/db/DBPeer";
import { WS2PRequester } from "../../../app/modules/ws2p/lib/WS2PRequester";
import { ForcedBlockValues } from "../../../app/modules/prover/lib/blockGenerator";
import { LevelMIndexExpiresOnIndexer } from "../../../app/lib/dal/indexDAL/leveldb/indexers/LevelMIndexExpiresOnIndexer";
export declare const getNewTestingPort: () => number;
export declare const simpleUser: (uid: string, keyring: {
    pub: string;
    sec: string;
}, server: TestingServer) => TestUser;
export declare const simpleNetworkOf2NodesAnd2Users: (options: any) => Promise<{
    s1: TestingServer;
    s2: TestingServer;
    cat: TestUser;
    tac: TestUser;
}>;
export declare const simpleNodeWith2Users: (options: any) => Promise<{
    s1: TestingServer;
    cat: TestUser;
    tac: TestUser;
}>;
export declare const simpleNodeWith2otherUsers: (options: any) => Promise<{
    s1: TestingServer;
    tic: TestUser;
    toc: TestUser;
}>;
export declare const createUser: (uid: string, pub: string, sec: string, defaultServer: Server) => Promise<TestUser>;
export declare const fakeSyncServer: (currency: string, readBlocksMethod: any, readParticularBlockMethod: any, onPeersRequested: any) => Promise<{
    host: string;
    port: number;
}>;
/**
 * Creates a new memory duniter server for Unit Test purposes.
 * @param conf
 */
export declare const server: (conf: any) => TestingServer;
export declare const simpleTestingServer: (conf: any) => TestingServer;
export declare const NewTestingServer: (conf: any) => TestingServer;
export declare const serverWaitBlock: (server: Server, number: number) => Promise<void>;
export declare const waitToHaveBlock: (server: Server, number: number) => Promise<void>;
export declare const waitForkResolution: (server: Server, number: number) => Promise<void>;
export declare const waitForkWS2PConnection: (server: Server, pubkey: string) => Promise<void>;
export declare const waitForkWS2PDisconnection: (server: Server, pubkey: string) => Promise<void>;
export declare const waitForHeads: (server: Server, nbHeads: number) => Promise<unknown>;
export declare class TestingServer {
    private port;
    private server;
    private prover;
    permaProver: PermanentProver;
    bma: BmaApi;
    constructor(port: number, server: Server);
    get _server(): Server;
    get BlockchainService(): BlockchainService;
    get PeeringService(): PeeringService;
    get conf(): ConfDTO;
    get dal(): FileDAL;
    get logger(): any;
    get home(): string;
    initWithDAL(): Promise<Server>;
    revert(): Promise<DBBlock>;
    resolve(filterFunc?: (b: DBBlock) => boolean): Promise<BlockDTO>;
    resolveForError(): Promise<string | null>;
    getMindexExpiresOnIndexer(): LevelMIndexExpiresOnIndexer;
    resolveFork(): Promise<BlockDTO | null>;
    resetHome(): Promise<void>;
    on(event: string, f: any): Server;
    recomputeSelfPeer(): Promise<DBPeer | null>;
    writeBlock(obj: any): Promise<BlockDTO>;
    writeRawBlock(raw: string): Promise<BlockDTO>;
    writeIdentity(obj: any): Promise<DBIdentity>;
    writeCertification(obj: any): Promise<CertificationDTO>;
    writeMembership(obj: any): Promise<MembershipDTO>;
    writeRevocation(obj: any): Promise<RevocationDTO>;
    writeTransaction(obj: any): Promise<TransactionDTO>;
    writePeer(obj: any): Promise<PeerDTO>;
    pullingEvent(type: string, number: number): Promise<void>;
    exportAllDataAsZIP(): Promise<any>;
    unplugFileSystem(): Promise<void>;
    importAllDataFromZIP(zipFile: string): Promise<void>;
    push(chunk: any, encoding?: string): boolean;
    pipe(writable: stream.Writable): stream.Writable;
    initDalBmaConnections(): Promise<never[]>;
    url(uri: string): string;
    get(uri: string): any;
    post(uri: string, obj: any): any;
    expect(uri: string, expectations: any): Promise<any>;
    expectThat(uri: string, expectations: any): Promise<any>;
    expectJSON(uri: string, expectations: any): Promise<void>;
    expectError(uri: string, code: number, message?: string): Promise<void>;
    syncFrom(otherServer: Server, fromIncuded: number, toIncluded: number): any;
    until(type: string, count: number): Promise<unknown>;
    justCommit(options?: any): Promise<any>;
    commit(options?: ForcedBlockValues | null): Promise<BlockDTO>;
    resolveExistingBlock(filterFunc: (b: DBBlock) => boolean): Promise<BlockDTO>;
    generateNext(options: any): any;
    commitWaitError(options: any, expectedError: string): Promise<unknown>;
    commitExpectError(options: any): Promise<void>;
    lookup2identity(search: string): Promise<IdentityDTO>;
    readBlock(number: number): Promise<BlockDTO>;
    makeNext(overrideProps: any): Promise<BlockDTO>;
    sharePeeringWith(otherServer: TestingServer): Promise<void>;
    getPeer(): Promise<any>;
    waitToHaveBlock(number: number): Promise<void>;
    waitForHeads(nbHeads: number): Promise<unknown>;
    waitForkResolution(number: number): Promise<void>;
    postIdentity(idty: any): any;
    postCert(cert: any): any;
    postMembership(ms: any): any;
    postRevocation(rev: RevocationDTO): any;
    postBlock(block: BlockDTO): any;
    postRawTX(rawTX: any): any;
    postPeer(peer: any): any;
    prepareForNetwork(): Promise<void>;
    disableBMA(): Promise<void>;
    startBlockComputation(): void;
    stopBlockComputation(): Promise<void>;
    closeCluster(): Promise<void>;
    enableWS2P(port?: number): Promise<TestWS2PAPI>;
}
export interface TestWS2PAPI {
    connect: (pair: Key, ws2pId: string) => WS2PRequester;
    connectForSync: (pair: Key, ws2pId: string) => WS2PRequester;
    host: string;
    port: number;
}
export declare function newWS2PBidirectionnalConnection(currency: string, k1: Key, k2: Key, serverHandler: WS2PMessageHandler): Promise<{
    p1: WS2PConnection;
    p2: WS2PConnection;
    wss: any;
}>;
export declare const simpleWS2PNetwork: (s1: TestingServer, s2: TestingServer) => Promise<{
    w1: WS2PConnection;
    ws2pc: WS2PClient;
    wss: WS2PServer;
    cluster1: WS2PCluster;
    cluster2: WS2PCluster;
}>;
export declare function simpleTestingConf(now: number | undefined, pair: {
    pub: string;
    sec: string;
}): any;
export declare function catUser(server: TestingServer): TestUser;
export declare function tacUser(server: TestingServer): TestUser;
export declare function tocUser(server: TestingServer): TestUser;
export declare function ticUser(server: TestingServer): TestUser;