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

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

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.WrappedBrowserNode = void 0;
const vector_types_1 = require("@connext/vector-types");
const objects_1 = require("@interfaces/objects");
const errors_1 = require("@interfaces/objects/errors");
const neverthrow_1 = require("neverthrow");
class WrappedBrowserNode {
    constructor(browserNode) {
        this.browserNode = browserNode;
        this.toVectorError = (e) => {
            return new errors_1.VectorError(e);
        };
    }
    init(signature, account) {
        return objects_1.ResultAsync.fromPromise(this.browserNode.init({
            signature,
            signer: account,
        }), this.toVectorError);
    }
    reconcileDeposit(assetId, channelAddress) {
        return objects_1.ResultAsync.fromPromise(this.browserNode.reconcileDeposit({ assetId, channelAddress }), this.toVectorError).andThen((result) => {
            if (result.isError) {
                return neverthrow_1.errAsync(new errors_1.VectorError(result.getError()));
            }
            else {
                return neverthrow_1.okAsync(result.getValue().channelAddress);
            }
        });
    }
    withdraw(channelAddress, amount, assetId, recipient, fee, callTo, callData, meta) {
        return objects_1.ResultAsync.fromPromise(this.browserNode.withdraw({
            channelAddress,
            amount,
            assetId,
            recipient,
            fee,
            callTo,
            callData,
            meta,
        }), this.toVectorError).andThen((result) => {
            if (result.isError) {
                return neverthrow_1.errAsync(new errors_1.VectorError(result.getError()));
            }
            else {
                return neverthrow_1.okAsync(result.getValue());
            }
        });
    }
    getTransfer(transferId) {
        return objects_1.ResultAsync.fromPromise(this.browserNode.getTransfer({ transferId }), this.toVectorError).andThen((result) => {
            if (result.isError) {
                return neverthrow_1.errAsync(new errors_1.VectorError(result.getError()));
            }
            else {
                return neverthrow_1.okAsync(result.getValue());
            }
        });
    }
    getActiveTransfers(channelAddress) {
        return objects_1.ResultAsync.fromPromise(this.browserNode.getActiveTransfers({ channelAddress }), this.toVectorError).andThen((result) => {
            if (result.isError) {
                return neverthrow_1.errAsync(new errors_1.VectorError(result.getError()));
            }
            else {
                return neverthrow_1.okAsync(result.getValue());
            }
        });
    }
    getRegisteredTransfers(chainId) {
        return objects_1.ResultAsync.fromPromise(this.browserNode.getRegisteredTransfers({ chainId }), this.toVectorError).andThen((result) => {
            if (result.isError) {
                return neverthrow_1.errAsync(new errors_1.VectorError(result.getError()));
            }
            else {
                return neverthrow_1.okAsync(result.getValue());
            }
        });
    }
    getTransfers(startDate, endDate) {
        return objects_1.ResultAsync.fromPromise(this.browserNode.getTransfers({
            startDate: new Date(startDate),
            endDate: new Date(endDate),
        }), this.toVectorError).andThen((result) => {
            if (result.isError) {
                return neverthrow_1.errAsync(new errors_1.VectorError(result.getError()));
            }
            else {
                return neverthrow_1.okAsync(result.getValue());
            }
        });
    }
    signUtilityMessage(message) {
        return objects_1.ResultAsync.fromPromise(this.browserNode.signUtilityMessage({ message }), this.toVectorError).andThen((result) => {
            if (result.isError) {
                return neverthrow_1.errAsync(new errors_1.VectorError(result.getError()));
            }
            else {
                return neverthrow_1.okAsync(result.getValue().signedMessage);
            }
        });
    }
    resolveTransfer(channelAddress, transferId, transferResolver) {
        return objects_1.ResultAsync.fromPromise(this.browserNode.resolveTransfer({
            channelAddress,
            transferId,
            transferResolver,
        }), this.toVectorError).andThen((result) => {
            if (result.isError) {
                return neverthrow_1.errAsync(new errors_1.VectorError(result.getError()));
            }
            else {
                return neverthrow_1.okAsync(result.getValue());
            }
        });
    }
    conditionalTransfer(channelAddress, amount, assetId, type, details, recipient, recipientChainId, recipientAssetId, timeout, meta) {
        return objects_1.ResultAsync.fromPromise(this.browserNode.conditionalTransfer({
            channelAddress,
            amount,
            assetId,
            type,
            details,
            recipient,
            recipientChainId,
            recipientAssetId,
            timeout,
            meta,
        }), this.toVectorError).andThen((result) => {
            if (result.isError) {
                return neverthrow_1.errAsync(new errors_1.VectorError(result.getError()));
            }
            else {
                return neverthrow_1.okAsync(result.getValue());
            }
        });
    }
    getStateChannels() {
        return objects_1.ResultAsync.fromPromise(this.browserNode.getStateChannels(), this.toVectorError).andThen((result) => {
            if (result.isError) {
                return neverthrow_1.errAsync(new errors_1.VectorError(result.getError()));
            }
            else {
                return neverthrow_1.okAsync(result.getValue());
            }
        });
    }
    getStateChannel(channelAddress) {
        return objects_1.ResultAsync.fromPromise(this.browserNode.getStateChannel({ channelAddress }), this.toVectorError).andThen((result) => {
            if (result.isError) {
                return neverthrow_1.errAsync(new errors_1.VectorError(result.getError()));
            }
            else {
                return neverthrow_1.okAsync(result.getValue());
            }
        });
    }
    getStateChannelByParticipants(counterparty, chainId) {
        return objects_1.ResultAsync.fromPromise(this.browserNode.getStateChannelByParticipants({ counterparty, chainId }), this.toVectorError).andThen((result) => {
            if (result.isError) {
                return neverthrow_1.errAsync(new errors_1.VectorError(result.getError()));
            }
            else {
                return neverthrow_1.okAsync(result.getValue());
            }
        });
    }
    setup(counterpartyIdentifier, chainId, timeout, meta) {
        return objects_1.ResultAsync.fromPromise(this.browserNode.setup({ counterpartyIdentifier, chainId, timeout, meta }), this.toVectorError).andThen((result) => {
            if (result.isError) {
                return neverthrow_1.errAsync(new errors_1.VectorError(result.getError()));
            }
            else {
                return neverthrow_1.okAsync(result.getValue());
            }
        });
    }
    restoreState(counterpartyIdentifier, chainId) {
        return objects_1.ResultAsync.fromPromise(this.browserNode.restoreState({ counterpartyIdentifier, chainId }), this.toVectorError).map(() => { });
    }
    onConditionalTransferResolved(callback, filter) {
        return this.browserNode.on(vector_types_1.CONDITIONAL_TRANSFER_RESOLVED_EVENT, callback, filter);
    }
    onConditionalTransferCreated(callback, filter) {
        return this.browserNode.on(vector_types_1.CONDITIONAL_TRANSFER_CREATED_EVENT, callback, filter);
    }
    get publicIdentifier() {
        return this.browserNode.publicIdentifier;
    }
}
exports.WrappedBrowserNode = WrappedBrowserNode;
//# sourceMappingURL=WrappedBrowserNode.js.map