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

package/lib-es/SpeculosTransport.js.flow

@@ -0,0 +1,172 @@
+//@flow
+import { Subject } from "rxjs";
+import net from "net";
+import Transport from "@ledgerhq/hw-transport";
+import {
+  DisconnectedDevice,
+  DisconnectedDeviceDuringOperation,
+  TransportError,
+} from "@ledgerhq/errors";
+import { log } from "@ledgerhq/logs";
+
+/**
+ *
+ */
+export type SpeculosTransportOpts = {
+  apduPort: number,
+  buttonPort?: number,
+  automationPort?: number,
+  host?: string,
+};
+
+/**
+ * Speculos TCP transport implementation
+ *
+ * @example
+ * import SpeculosTransport from "@ledgerhq/hw-transport-node-speculos";
+ * const transport = await SpeculosTransport.open({ apduPort });
+ * const res = await transport.send(0xE0, 0x01, 0, 0);
+ */
+export default class SpeculosTransport extends Transport<SpeculosTransportOpts> {
+  static isSupported = (): Promise<boolean> => Promise.resolve(true);
+
+  // this transport is not discoverable
+  static list = (): * => Promise.resolve([]);
+  static listen = (_observer: *) => ({
+    unsubscribe: () => {},
+  });
+
+  /**
+   *
+   */
+  static open = (opts: SpeculosTransportOpts): Promise<SpeculosTransport> =>
+    new Promise((resolve, reject) => {
+      const socket = new net.Socket();
+      socket.on("error", (e) => {
+        socket.destroy();
+        reject(e);
+      });
+      socket.on("end", () => {
+        reject(new DisconnectedDevice("tcp closed"));
+      });
+      socket.connect(opts.apduPort, opts.host || "127.0.0.1", () => {
+        // we delay a bit the transport creation to make sure the tcp does not hang up
+        setTimeout(() => {
+          resolve(new SpeculosTransport(socket, opts));
+        }, 100);
+      });
+    });
+
+  apduSocket: net.Socket;
+  opts: SpeculosTransportOpts;
+  rejectExchange: (Error) => void = (_e) => {};
+  resolveExchange: (Buffer) => void = (_b) => {};
+
+  automationSocket: ?net.Socket;
+  automationEvents: Subject<Object> = new Subject();
+
+  constructor(apduSocket: net.Socket, opts: SpeculosTransportOpts) {
+    super();
+    this.opts = opts;
+    this.apduSocket = apduSocket;
+    apduSocket.on("error", (e) => {
+      this.emit("disconnect", new DisconnectedDevice(e.message));
+      this.rejectExchange(e);
+      this.apduSocket.destroy();
+    });
+    apduSocket.on("end", () => {
+      this.emit("disconnect", new DisconnectedDevice());
+      this.rejectExchange(new DisconnectedDeviceDuringOperation());
+    });
+    apduSocket.on("data", (data) => {
+      try {
+        this.resolveExchange(decodeAPDUPayload(data));
+      } catch (e) {
+        this.rejectExchange(e);
+      }
+    });
+
+    const { automationPort } = opts;
+    if (automationPort) {
+      const socket = new net.Socket();
+      this.automationSocket = socket;
+      socket.on("error", (e) => {
+        log("speculos-automation-error", String(e));
+        socket.destroy();
+      });
+      socket.on("data", (data) => {
+        log("speculos-automation-data", data);
+        const split = data.toString("ascii").split("\n");
+        split
+          .filter((ascii) => !!ascii)
+          .forEach((ascii) => {
+            const json = JSON.parse(ascii);
+            this.automationEvents.next(json);
+          });
+      });
+      socket.connect(automationPort, opts.host || "127.0.0.1");
+    }
+  }
+
+  /**
+   * Send a speculos button command
+   * typically "Ll" would press and release the left button
+   * typically "Rr" would press and release the right button
+   * @param {*} command
+   */
+  button = (command: string): Promise<void> =>
+    new Promise((resolve, reject) => {
+      log("speculos-button", command);
+      const { buttonPort, host } = this.opts;
+      if (!buttonPort) throw new Error("buttonPort is missing");
+      const socket = new net.Socket();
+      socket.on("error", (e) => {
+        socket.destroy();
+        reject(e);
+      });
+      socket.connect(buttonPort, host || "127.0.0.1", () => {
+        socket.write(Buffer.from(command, "ascii"));
+        socket.destroy();
+        resolve();
+      });
+    });
+
+  async exchange(apdu: Buffer): Promise<Buffer> {
+    const hex = apdu.toString("hex");
+    log("apdu", "=> " + hex);
+    const encoded = encodeAPDU(apdu);
+    const res = await new Promise((resolve, reject) => {
+      this.rejectExchange = reject;
+      this.resolveExchange = resolve;
+      this.apduSocket.write(encoded);
+    });
+    log("apdu", "<= " + res.toString("hex"));
+    return res;
+  }
+
+  setScrambleKey() {}
+
+  async close() {
+    if (this.automationSocket) this.automationSocket.destroy();
+    this.apduSocket.destroy();
+    return Promise.resolve();
+  }
+}
+
+function encodeAPDU(apdu: Buffer) {
+  const size = Buffer.allocUnsafe(4);
+  size.writeUIntBE(apdu.length, 0, 4);
+  return Buffer.concat([size, apdu]);
+}
+
+function decodeAPDUPayload(data: Buffer) {
+  const dataLength = data.readUIntBE(0, 4); // 4 bytes tells the data length
+  const size = dataLength + 2; // size does not include the status code so we add 2
+  const payload = data.slice(4);
+  if (payload.length !== size) {
+    throw new TransportError(
+      `Expected payload of length ${size} but got ${payload.length}`
+    );
+  }
+  return payload;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ledgerhq/hw-transport-node-speculos",
-  "version": "6.24.1",
+  "version": "6.25.1-alpha.3+eb669e17",
   "description": "Ledger Hardware Wallet communication layer with speculos Nano simulator",
   "keywords": [
     "Ledger",
@@ -29,7 +29,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",
     "rxjs": "6"
   },
@@ -39,5 +39,5 @@
     "watch": "bash ../../script/watch.sh",
     "doc": "bash ../../script/doc.sh"
   },
-  "gitHead": "159269dafc5f177c7af5b20761ab0ef3550e3faf"
+  "gitHead": "eb669e17dd87d3ab568beab1f9a5ddb1a2536e83"
 }