@ledgerhq/hw-transport-vault/lib-es/index.js

Ledger Vault transport

var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
import { log } from "@ledgerhq/logs";
import { TransportError } from "@ledgerhq/errors";
import WebSocketTransport from "@ledgerhq/hw-transport-http/lib-es/WebSocketTransport";
let sessionId = null;
export default class VaultTransport extends WebSocketTransport {
    constructor(hook) {
        super(hook);
        this.data = null;
    }
    setData(data) {
        this.data = data;
    }
    static open(url) {
        return __awaiter(this, void 0, void 0, function* () {
            const exchangeMethods = yield new Promise((resolve, reject) => {
                try {
                    const socket = new WebSocket(url);
                    const exchangeMethods = {
                        resolveExchange: (_b, _sessionId) => { },
                        rejectExchange: (_e) => { },
                        onDisconnect: () => { },
                        close: () => socket.close(),
                        send: msg => socket.send(msg),
                    };
                    socket.onopen = () => {
                        socket.send("open");
                    };
                    socket.onerror = e => {
                        exchangeMethods.onDisconnect();
                        reject(e);
                    };
                    socket.onclose = () => {
                        exchangeMethods.onDisconnect();
                        reject(new TransportError("OpenFailed", "OpenFailed"));
                    };
                    socket.onmessage = e => {
                        if (typeof e.data !== "string")
                            return;
                        const data = JSON.parse(e.data);
                        switch (data.type) {
                            case "opened":
                                return resolve(exchangeMethods);
                            case "error":
                                reject(new Error(data.error));
                                return exchangeMethods.rejectExchange(new TransportError(data.error, "WSError"));
                            case "response":
                                return exchangeMethods.resolveExchange(Buffer.from(data.data, "hex"), data.sessionId);
                        }
                    };
                }
                catch (e) {
                    reject(e);
                }
            });
            return new VaultTransport(exchangeMethods);
        });
    }
    exchange(apdu) {
        return __awaiter(this, void 0, void 0, function* () {
            const hex = apdu.toString("hex");
            log("apdu", "=> " + hex);
            const iv = setInterval(() => {
                this.hook.send("ping");
            }, 30e3);
            try {
                const res = yield new Promise((resolve, reject) => {
                    var _a, _c;
                    this.hook.rejectExchange = (e) => reject(e);
                    this.hook.resolveExchange = (b, _sessionId) => {
                        if (_sessionId) {
                            sessionId = _sessionId;
                        }
                        return resolve(b);
                    };
                    const data = {
                        sessionId,
                        workspace: (_a = this.data) === null || _a === void 0 ? void 0 : _a.workspace,
                        token: (_c = this.data) === null || _c === void 0 ? void 0 : _c.token,
                        apdu: hex,
                    };
                    this.hook.send(JSON.stringify(data));
                });
                log("apdu", "<= " + res.toString("hex"));
                return res;
            }
            finally {
                clearInterval(iv);
            }
        });
    }
}
//# sourceMappingURL=index.js.map