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

Ledger Vault transport

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
const logs_1 = require("@ledgerhq/logs");
const errors_1 = require("@ledgerhq/errors");
const WebSocketTransport_1 = __importDefault(require("@ledgerhq/hw-transport-http/WebSocketTransport"));
let sessionId = null;
class VaultTransport extends WebSocketTransport_1.default {
    data;
    constructor(hook) {
        super(hook);
        this.data = null;
    }
    setData(data) {
        this.data = data;
    }
    static async open(url) {
        const exchangeMethods = await 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 errors_1.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 errors_1.TransportError(data.error, "WSError"));
                        case "response":
                            return exchangeMethods.resolveExchange(Buffer.from(data.data, "hex"), data.sessionId);
                    }
                };
            }
            catch (e) {
                reject(e);
            }
        });
        return new VaultTransport(exchangeMethods);
    }
    async exchange(apdu) {
        const hex = apdu.toString("hex");
        (0, logs_1.log)("apdu", "=> " + hex);
        const iv = setInterval(() => {
            this.hook.send("ping");
        }, 30e3);
        try {
            const res = await new Promise((resolve, reject) => {
                this.hook.rejectExchange = (e) => reject(e);
                this.hook.resolveExchange = (b, _sessionId) => {
                    if (_sessionId) {
                        sessionId = _sessionId;
                    }
                    return resolve(b);
                };
                const data = {
                    sessionId,
                    workspace: this.data?.workspace,
                    token: this.data?.token,
                    apdu: hex,
                };
                this.hook.send(JSON.stringify(data));
            });
            (0, logs_1.log)("apdu", "<= " + res.toString("hex"));
            return res;
        }
        finally {
            clearInterval(iv);
        }
    }
}
exports.default = VaultTransport;
//# sourceMappingURL=index.js.map