@test-org122/hypernet-core/dist/implementations/utilities/WrappedBrowserNode.d.ts

Hypernet Core. Represents the SDK for running the Hypernet Protocol.

import { BrowserNode } from "@connext/vector-browser-node";
import { EthereumAddress, PublicIdentifier, ResultAsync } from "@interfaces/objects";
import { VectorError } from "@interfaces/objects/errors";
import { InsuranceResolver, MessageResolver, ParameterizedResolver } from "@interfaces/types/typechain";
import { IBasicChannelResponse, IBasicTransferResponse, IBrowserNode, IConditionalTransferCreatedPayload, IConditionalTransferResolvedPayload, IFullChannelState, IFullTransferState, IRegisteredTransfer, IWithdrawResponse } from "@interfaces/utilities";
export declare class WrappedBrowserNode implements IBrowserNode {
    protected browserNode: BrowserNode;
    protected toVectorError: (e: unknown) => VectorError;
    constructor(browserNode: BrowserNode);
    init(signature: string, account: string): ResultAsync<void, VectorError>;
    reconcileDeposit(assetId: EthereumAddress, channelAddress: EthereumAddress): ResultAsync<string, VectorError>;
    withdraw(channelAddress: EthereumAddress, amount: string, assetId: string, recipient: string, fee: string, callTo?: string, callData?: string, meta?: any): ResultAsync<IWithdrawResponse, VectorError>;
    getTransfer(transferId: string): ResultAsync<IFullTransferState, VectorError>;
    getActiveTransfers(channelAddress: string): ResultAsync<IFullTransferState[], VectorError>;
    getRegisteredTransfers(chainId: number): ResultAsync<IRegisteredTransfer[], VectorError>;
    getTransfers(startDate: number, endDate: number): ResultAsync<IFullTransferState[], VectorError>;
    signUtilityMessage(message: string): ResultAsync<string, VectorError>;
    resolveTransfer(channelAddress: EthereumAddress, transferId: string, transferResolver: MessageResolver | ParameterizedResolver | InsuranceResolver): ResultAsync<IBasicTransferResponse, VectorError>;
    conditionalTransfer(channelAddress: EthereumAddress, amount: string, assetId: EthereumAddress, type: string, details: any, recipient?: PublicIdentifier, recipientChainId?: number, recipientAssetId?: EthereumAddress, timeout?: string, meta?: any): ResultAsync<IBasicTransferResponse, VectorError>;
    getStateChannels(): ResultAsync<EthereumAddress[], VectorError>;
    getStateChannel(channelAddress: EthereumAddress): ResultAsync<IFullChannelState | undefined, VectorError>;
    getStateChannelByParticipants(counterparty: PublicIdentifier, chainId: number): ResultAsync<IFullChannelState | undefined, VectorError>;
    setup(counterpartyIdentifier: PublicIdentifier, chainId: number, timeout: string, meta?: any): ResultAsync<IBasicChannelResponse, VectorError>;
    restoreState(counterpartyIdentifier: PublicIdentifier, chainId: number): ResultAsync<void, VectorError>;
    onConditionalTransferResolved(callback: (payload: IConditionalTransferResolvedPayload) => void | Promise<void>, filter?: (payload: IConditionalTransferResolvedPayload) => boolean): Promise<void>;
    onConditionalTransferCreated(callback: (payload: IConditionalTransferCreatedPayload) => void | Promise<void>, filter?: (payload: IConditionalTransferCreatedPayload) => boolean): Promise<void>;
    get publicIdentifier(): string;
}
//# sourceMappingURL=WrappedBrowserNode.d.ts.map