@nimiq/network-client/dist/src/NetworkClient.d.ts

import { EventCallback } from '@nimiq/rpc-events';
type PlainNimiqTransaction = ReturnType<import('@nimiq/core-web').Transaction["toPlain"]>;
type PlainNimiqTransactionReceipt = ReturnType<import('@nimiq/core-web').TransactionReceipt["toPlain"]>;
type PlainNimiqTransactionDetails = ReturnType<import('@nimiq/core-web').Client.TransactionDetails["toPlain"]>;
type PlainNimiqVestingContract = ReturnType<import('@nimiq/core-web').VestingContract["toPlain"]>;
type ConsensusState = import('@nimiq/core-web').Client.ConsensusState;
export declare type TransactionListener = (transaction: PlainNimiqTransactionDetails) => any;
export declare type ConsensusChangedListener = (consensusState: ConsensusState) => any;
export declare type PlainTransaction = {
    sender: string;
    senderPubKey: Uint8Array;
    recipient: string;
    value: number;
    fee: number;
    validityStartHeight: number;
    signature: Uint8Array;
    extraData?: string | Uint8Array;
};
export declare type DetailedPlainTransaction = {
    sender: string;
    recipient: string;
    value: number;
    fee: number;
    extraData: Uint8Array;
    hash: string;
    blockHeight: number;
    blockHash?: string;
    timestamp: number;
    validityStartHeight: number;
};
export declare type PlainVestingContract = {
    address: string;
    owner: string;
    start: number;
    stepAmount: number;
    stepBlocks: number;
    totalAmount: number;
};
export declare type PlainAddressInfo = {
    banned: boolean;
    connected: boolean;
    netAddress: {
        ip: Uint8Array;
        reliable: boolean;
    } | null;
    peerAddress: string;
    peerId: string;
    services: Array<'FULL_BLOCKS' | 'BLOCK_HISTORY' | 'BLOCK_PROOF' | 'CHAIN_PROOF' | 'ACCOUNTS_PROOF' | 'ACCOUNTS_CHUNKS' | 'MEMPOOL' | 'TRANSACTION_INDEX' | 'BODY_PROOF'>;
};
declare class NetworkClient {
    static readonly DEFAULT_ENDPOINT: "https://network.nimiq.com" | "https://network.nimiq-testnet.com";
    static createInstance(endPoint?: string): NetworkClient;
    static hasInstance(): boolean;
    static readonly Instance: NetworkClient;
    private static _instance;
    private static getAllowedOrigin;
    private static _createIframe;
    private readonly _endpoint;
    private _eventClient;
    private $iframe;
    private _initializationPromise?;
    private _apiLoadingState;
    private _consensusState;
    private _peerCount;
    private _headInfo;
    private _balances;
    private _pendingTransactions;
    private _expiredTransactions;
    private _minedTransactions;
    private _relayedTransactions;
    private constructor();
    init(): Promise<void>;
    on(event: NetworkClient.Events, callback: EventCallback): Promise<void>;
    off(event: NetworkClient.Events, callback: EventCallback): Promise<void>;
    connect(): Promise<boolean>;
    disconnect(reason?: string): Promise<boolean>;
    relayTransaction(txObj: PlainTransaction): Promise<object>;
    getTransactionSize(txObj: PlainTransaction): Promise<number>;
    subscribe(addresses: string | string[]): Promise<boolean>;
    getBalance(addresses: string | string[]): Promise<Map<string, number>>;
    forgetBalances(addresses: string | string[]): Promise<boolean>;
    getAccounts(addresses: string | string[]): Promise<Array<ReturnType<import('@nimiq/core-web').Account["toPlain"]> & {
        address: string;
    }>>;
    getAccountTypeString(address: string): Promise<string | false>;
    requestTransactionHistory(addresses: string | string[], // userfriendly addresses
    knownReceipts: Map<string, string>, // Map<txhash (base64), blockhash (base64)>
    fromHeight?: number): Promise<{
        newTransactions: DetailedPlainTransaction[];
        wasRateLimited: boolean;
    }>;
    requestTransactionReceipts(addresses: string, limit?: number): Promise<PlainNimiqTransactionReceipt[]>;
    getGenesisVestingContracts(): Promise<PlainVestingContract[]>;
    getGenesisVestingContracts(modern: true): Promise<PlainNimiqVestingContract[]>;
    removeTxFromMempool(txObj: PlainTransaction): Promise<boolean>;
    getPeerAddresses(): Promise<PlainAddressInfo[]>;
    sendTransaction(tx: PlainNimiqTransaction | string): Promise<PlainNimiqTransactionDetails>;
    getTransactionsByAddress(address: string, sinceHeight?: number, knownDetails?: PlainNimiqTransactionDetails[], limit?: number): Promise<PlainNimiqTransactionDetails[]>;
    addTransactionListener(listener: TransactionListener, addresses: string[]): Promise<number>;
    addConsensusChangedListener(listener: ConsensusChangedListener): Promise<number>;
    resetConsensus(): Promise<void>;
    removeListener(handle: number): Promise<void>;
    readonly apiLoadingState: 'not-started' | 'ready' | 'failed';
    readonly consensusState: 'connecting' | 'syncing' | 'established' | 'lost';
    readonly peerCount: number;
    readonly headInfo: {
        height: number;
        globalHashrate: number;
    };
    readonly balances: Map<string, number>;
    readonly pendingTransactions: Iterable<Partial<DetailedPlainTransaction>>;
    readonly minedTransactions: Iterable<DetailedPlainTransaction>;
    readonly relayedTransactions: Iterable<Partial<DetailedPlainTransaction>>;
    /** @returns base64 transaction hashes */
    readonly expiredTransactions: Iterable<string>;
    private _evictCachedTransactions;
}
declare namespace NetworkClient {
    enum Events {
        API_READY = "nimiq-api-ready",
        API_FAIL = "nimiq-api-fail",
        CONSENSUS_SYNCING = "nimiq-consensus-syncing",
        CONSENSUS_ESTABLISHED = "nimiq-consensus-established",
        CONSENSUS_LOST = "nimiq-consensus-lost",
        PEERS_CHANGED = "nimiq-peer-count",
        BALANCES_CHANGED = "nimiq-balances",
        TRANSACTION_PENDING = "nimiq-transaction-pending",
        TRANSACTION_EXPIRED = "nimiq-transaction-expired",
        TRANSACTION_MINED = "nimiq-transaction-mined",
        TRANSACTION_RELAYED = "nimiq-transaction-relayed",
        HEAD_CHANGE = "nimiq-head-change",
        HEAD_HEIGHT = "head-height",
        CONSENSUS = "consensus",
        BALANCES = "balances",
        TRANSACTION = "transaction",
        PEER_COUNT = "peer-count",
        PEER_ADDRESSES_ADDED = "peer-addresses-added"
    }
}
export { NetworkClient };