@ledgerhq/hw-transport-http 6.24.1 → 6.25.1-alpha.3

package/lib-es/HttpTransport.js.flow

@@ -0,0 +1,74 @@
+//@flow
+import Transport from "@ledgerhq/hw-transport";
+import { TransportError } from "@ledgerhq/errors";
+import axios from "axios";
+import { log } from "@ledgerhq/logs";
+
+/**
+ * HTTP transport implementation
+ */
+export default class HttpTransport extends Transport<string> {
+  static isSupported = (): Promise<boolean> =>
+    Promise.resolve(typeof fetch === "function");
+
+  // this transport is not discoverable
+  static list = (): * => Promise.resolve([]);
+  static listen = (_observer: *) => ({
+    unsubscribe: () => {},
+  });
+
+  static check = async (url: string, timeout: number = 5000) => {
+    const response = await axios({ url, timeout });
+    if (response.status !== 200) {
+      throw new TransportError(
+        "failed to access HttpTransport(" +
+          url +
+          "): status " +
+          response.status,
+        "HttpTransportNotAccessible"
+      );
+    }
+  };
+
+  static async open(url: string, timeout?: number) {
+    await HttpTransport.check(url, timeout);
+    return new HttpTransport(url);
+  }
+
+  url: string;
+
+  constructor(url: string) {
+    super();
+    this.url = url;
+  }
+
+  async exchange(apdu: Buffer): Promise<Buffer> {
+    const apduHex = apdu.toString("hex");
+    log("apdu", "=> " + apduHex);
+    const response = await axios({
+      method: "POST",
+      url: this.url,
+      headers: {
+        Accept: "application/json",
+        "Content-Type": "application/json",
+      },
+      data: JSON.stringify({ apduHex }),
+    });
+    if (response.status !== 200) {
+      throw new TransportError(
+        "failed to communicate to server. code=" + response.status,
+        "HttpTransportStatus" + response.status
+      );
+    }
+    const body = await response.data;
+    if (body.error) throw body.error;
+    log("apdu", "<= " + body.data);
+    return Buffer.from(body.data, "hex");
+  }
+
+  setScrambleKey() {}
+
+  close(): Promise<void> {
+    return Promise.resolve();
+  }
+}

package/lib-es/WebSocketTransport.js.flow

@@ -0,0 +1,132 @@
+//@flow
+import Transport from "@ledgerhq/hw-transport";
+import { TransportError } from "@ledgerhq/errors";
+import { log } from "@ledgerhq/logs";
+
+const WebSocket = global.WebSocket || require("ws");
+
+/**
+ * WebSocket transport implementation
+ */
+export default class WebSocketTransport extends Transport<string> {
+  static isSupported = (): Promise<boolean> =>
+    Promise.resolve(typeof WebSocket === "function");
+
+  // this transport is not discoverable
+  static list = (): * => Promise.resolve([]);
+  static listen = (_observer: *) => ({
+    unsubscribe: () => {},
+  });
+
+  static check = async (url: string, timeout: number = 5000) =>
+    new Promise((resolve, reject) => {
+      const socket = new WebSocket(url);
+      let success = false;
+      setTimeout(() => {
+        socket.close();
+      }, timeout);
+      socket.onopen = () => {
+        success = true;
+        socket.close();
+      };
+      socket.onclose = () => {
+        if (success) resolve();
+        else {
+          reject(
+            new TransportError(
+              "failed to access WebSocketTransport(" + url + ")",
+              "WebSocketTransportNotAccessible"
+            )
+          );
+        }
+      };
+      socket.onerror = () => {
+        reject(
+          new TransportError(
+            "failed to access WebSocketTransport(" + url + "): error",
+            "WebSocketTransportNotAccessible"
+          )
+        );
+      };
+    });
+
+  static async open(url: string) {
+    const exchangeMethods = await new Promise((resolve, reject) => {
+      try {
+        const socket = new WebSocket(url);
+        const exchangeMethods = {
+          resolveExchange: (_b: Buffer) => {},
+          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")
+              );
+          }
+        };
+      } catch (e) {
+        reject(e);
+      }
+    });
+    return new WebSocketTransport(exchangeMethods);
+  }
+
+  hook: *;
+
+  constructor(hook: *) {
+    super();
+    this.hook = hook;
+    hook.onDisconnect = () => {
+      this.emit("disconnect");
+      this.hook.rejectExchange(
+        new TransportError("WebSocket disconnected", "WSDisconnect")
+      );
+    };
+  }
+
+  async exchange(apdu: Buffer): Promise<Buffer> {
+    const hex = apdu.toString("hex");
+    log("apdu", "=> " + hex);
+    const res = await new Promise((resolve, reject) => {
+      this.hook.rejectExchange = (e: *) => reject(e);
+      this.hook.resolveExchange = (b: Buffer) => resolve(b);
+      this.hook.send(hex);
+    });
+    log("apdu", "<= " + res.toString("hex"));
+    return res;
+  }
+
+  setScrambleKey() {}
+
+  async close() {
+    this.hook.close();
+    return new Promise((success) => {
+      setTimeout(success, 200);
+    });
+  }
+}

package/lib-es/withStaticURLs.js.flow

@@ -0,0 +1,83 @@
+// @flow
+import HttpTransport from "./HttpTransport";
+import WebSocketTransport from "./WebSocketTransport";
+import Transport from "@ledgerhq/hw-transport";
+import type {
+  Observer,
+  DescriptorEvent,
+  Subscription,
+} from "@ledgerhq/hw-transport";
+
+const getTransport = (url) =>
+  !url.startsWith("ws") ? HttpTransport : WebSocketTransport;
+
+type InS = string | string[];
+type InP = Promise<InS> | InS;
+type In = InP | (() => InP);
+
+const inferURLs = async (urls: In): Promise<string[]> => {
+  const r = await (typeof urls === "function" ? urls() : urls);
+  return typeof r === "string" ? [r] : r;
+};
+
+export default (urls: In): Class<Transport<string>> => {
+  class StaticTransport extends Transport<string> {
+    static isSupported = HttpTransport.isSupported;
+
+    static list = (): Promise<*[]> =>
+      inferURLs(urls)
+        .then((urls) =>
+          Promise.all(
+            urls.map((url) =>
+              getTransport(url)
+                .check(url)
+                .then(() => [url])
+                .catch(() => [])
+            )
+          )
+        )
+        .then((arrs) => arrs.reduce((acc, a) => acc.concat(a), []));
+
+    static listen = (observer: Observer<DescriptorEvent<*>>): Subscription => {
+      let unsubscribed = false;
+      const seen = {};
+      function checkLoop() {
+        if (unsubscribed) return;
+        inferURLs(urls)
+          .then((urls) =>
+            Promise.all(
+              urls.map(async (url) => {
+                if (unsubscribed) return;
+                try {
+                  await getTransport(url).check(url);
+                  if (unsubscribed) return;
+                  if (!seen[url]) {
+                    seen[url] = 1;
+                    observer.next({ type: "add", descriptor: url });
+                  }
+                } catch (e) {
+                  // nothing
+                  if (seen[url]) {
+                    delete seen[url];
+                    observer.next({ type: "remove", descriptor: url });
+                  }
+                }
+              })
+            )
+          )
+          .then(() => new Promise((success) => setTimeout(success, 5000)))
+          .then(checkLoop);
+      }
+      checkLoop();
+      return {
+        unsubscribe: () => {
+          unsubscribed = true;
+        },
+      };
+    };
+
+    static open = (url) => getTransport(url).open(url);
+  }
+
+  return StaticTransport;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ledgerhq/hw-transport-http",
-  "version": "6.24.1",
+  "version": "6.25.1-alpha.3+eb669e17",
   "description": "Ledger Hardware Wallet communication layer over http",
   "keywords": [
     "Ledger",
@@ -28,7 +28,7 @@
   "license": "Apache-2.0",
   "dependencies": {
     "@ledgerhq/errors": "^6.10.0",
-    "@ledgerhq/hw-transport": "^6.24.1",
+    "@ledgerhq/hw-transport": "^6.25.1-alpha.3+eb669e17",
     "@ledgerhq/logs": "^6.10.0",
     "axios": "^0.24.0",
     "ws": "7"
@@ -38,5 +38,5 @@
     "build": "bash ../../script/build.sh",
     "watch": "bash ../../script/watch.sh"
   },
-  "gitHead": "159269dafc5f177c7af5b20761ab0ef3550e3faf"
+  "gitHead": "eb669e17dd87d3ab568beab1f9a5ddb1a2536e83"
 }