@test-org122/hypernet-core/dist/interfaces/utilities/IBrowserNode.d.ts

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

import { Address, Balance, FullTransferState, TransferName } from "@connext/vector-types";
import { EthereumAddress, PublicIdentifier, ResultAsync } from "@interfaces/objects";
import { VectorError } from "@interfaces/objects/errors";
import { MessageResolver, InsuranceResolver, ParameterizedResolver } from "@interfaces/types/typechain";
export interface IConditionalTransferResolvedPayload {
    aliceIdentifier: string;
    bobIdentifier: string;
    channelAddress: string;
    transfer: FullTransferState;
    channelBalance: Balance;
    conditionType: TransferName | Address;
    activeTransferIds?: string[];
}
export interface IConditionalTransferCreatedPayload {
    aliceIdentifier: string;
    bobIdentifier: string;
    channelAddress: string;
    transfer: FullTransferState;
    channelBalance: Balance;
    conditionType: TransferName | Address;
    activeTransferIds?: string[];
}
export interface IWithdrawResponse {
    channelAddress: EthereumAddress;
    transferId: string;
    transactionHash?: string;
}
export interface IBalance {
    to: string[];
    amount: string[];
}
export interface IChannelUpdate {
    channelAddress: EthereumAddress;
    fromIdentifier: PublicIdentifier;
    toIdentifier: PublicIdentifier;
    type: string;
    nonce: number;
    balance: IBalance;
    assetId: EthereumAddress;
    details: any;
    aliceSignature?: string | null;
    bobSignature?: string | null;
}
export interface INetworkContext {
    channelFactoryAddress: EthereumAddress;
    transferRegistryAddress: EthereumAddress;
    chainId: number;
    providerUrl: string;
}
export interface IFullTransferState<TTransferState = any> {
    balance: IBalance;
    assetId: EthereumAddress;
    channelAddress: EthereumAddress;
    inDispute: boolean;
    transferId: string;
    transferDefinition: EthereumAddress;
    transferTimeout: string;
    initialStateHash: string;
    initiator: EthereumAddress;
    responder: EthereumAddress;
    channelFactoryAddress: EthereumAddress;
    chainId: number;
    transferEncodings: string[];
    transferState: TTransferState;
    transferResolver?: any;
    meta?: any;
    channelNonce: number;
    initiatorIdentifier: PublicIdentifier;
    responderIdentifier: PublicIdentifier;
}
export interface IFullChannelState {
    assetIds: EthereumAddress[];
    balances: IBalance[];
    channelAddress: EthereumAddress;
    alice: EthereumAddress;
    bob: EthereumAddress;
    merkleRoot: string;
    nonce: number;
    processedDepositsA: string[];
    processedDepositsB: string[];
    timeout: string;
    aliceIdentifier: PublicIdentifier;
    bobIdentifier: PublicIdentifier;
    latestUpdate: IChannelUpdate;
    networkContext: INetworkContext;
    defundNonces: string[];
    inDispute: boolean;
}
export interface IRegisteredTransfer {
    name: string;
    stateEncoding: string;
    resolverEncoding: string;
    definition: EthereumAddress;
    encodedCancel: string;
}
export interface IBasicTransferResponse {
    channelAddress: EthereumAddress;
    transferId: string;
    routingId?: string;
}
export interface IBasicChannelResponse {
    channelAddress: EthereumAddress;
}
export interface IBrowserNode {
    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>;
    readonly publicIdentifier: PublicIdentifier;
    /**
     *
     * @param assetId
     * @param channelAddress
     * @returns channelAddress
     */
    reconcileDeposit(assetId: EthereumAddress, channelAddress: EthereumAddress): ResultAsync<string, VectorError>;
    withdraw(channelAddress: EthereumAddress, amount: string, assetId: EthereumAddress, recipient: EthereumAddress, fee: string, callTo?: string, callData?: string, meta?: any): ResultAsync<IWithdrawResponse, VectorError>;
    getTransfer(transferId: string): ResultAsync<IFullTransferState, VectorError>;
    getActiveTransfers(channelAddress: string): ResultAsync<IFullTransferState[], VectorError>;
    getTransfers(startDate: number, endDate: number): ResultAsync<IFullTransferState[], VectorError>;
    init(signature: string, account: string): ResultAsync<void, VectorError>;
    getRegisteredTransfers(chainId: number): ResultAsync<IRegisteredTransfer[], 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 | undefined, recipientChainId: number | undefined, recipientAssetId: EthereumAddress | undefined, timeout: string | undefined, meta: any | null | undefined): 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>;
}
//# sourceMappingURL=IBrowserNode.d.ts.map