@nightlylabs/dex-sdk 0.3.1 → 0.3.2

package/dist/TransportWebHID-QH5HRZY3.js

@@ -0,0 +1,225 @@
+import {
+  DisconnectedDevice,
+  DisconnectedDeviceDuringOperation,
+  TransportError,
+  TransportOpenUserCancelled,
+  Transport_default,
+  hid_framing_default,
+  identifyUSBProductId,
+  ledgerUSBVendorId,
+  log
+} from "./chunk-ISCCOOHD.js";
+import "./chunk-DOLYMX7P.js";
+
+// node_modules/.pnpm/@ledgerhq+hw-transport-webhid@6.30.0/node_modules/@ledgerhq/hw-transport-webhid/lib-es/TransportWebHID.js
+var __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());
+  });
+};
+var ledgerDevices = [
+  {
+    vendorId: ledgerUSBVendorId
+  }
+];
+var isSupported = () => Promise.resolve(!!(window.navigator && window.navigator.hid));
+var getHID = () => {
+  const { hid } = navigator;
+  if (!hid)
+    throw new TransportError("navigator.hid is not supported", "HIDNotSupported");
+  return hid;
+};
+function requestLedgerDevices() {
+  return __awaiter(this, void 0, void 0, function* () {
+    const device = yield getHID().requestDevice({
+      filters: ledgerDevices
+    });
+    if (Array.isArray(device))
+      return device;
+    return [device];
+  });
+}
+function getLedgerDevices() {
+  return __awaiter(this, void 0, void 0, function* () {
+    const devices = yield getHID().getDevices();
+    return devices.filter((d) => d.vendorId === ledgerUSBVendorId);
+  });
+}
+function getFirstLedgerDevice() {
+  return __awaiter(this, void 0, void 0, function* () {
+    const existingDevices = yield getLedgerDevices();
+    if (existingDevices.length > 0)
+      return existingDevices[0];
+    const devices = yield requestLedgerDevices();
+    return devices[0];
+  });
+}
+var TransportWebHID = class _TransportWebHID extends Transport_default {
+  constructor(device) {
+    super();
+    this.channel = Math.floor(Math.random() * 65535);
+    this.packetSize = 64;
+    this.inputs = [];
+    this.read = () => {
+      if (this.inputs.length) {
+        return Promise.resolve(this.inputs.shift());
+      }
+      return new Promise((success) => {
+        this.inputCallback = success;
+      });
+    };
+    this.onInputReport = (e) => {
+      const buffer = Buffer.from(e.data.buffer);
+      if (this.inputCallback) {
+        this.inputCallback(buffer);
+        this.inputCallback = null;
+      } else {
+        this.inputs.push(buffer);
+      }
+    };
+    this._disconnectEmitted = false;
+    this._emitDisconnect = (e) => {
+      if (this._disconnectEmitted)
+        return;
+      this._disconnectEmitted = true;
+      this.emit("disconnect", e);
+    };
+    this.exchange = (apdu) => __awaiter(this, void 0, void 0, function* () {
+      const b = yield this.exchangeAtomicImpl(() => __awaiter(this, void 0, void 0, function* () {
+        const { channel, packetSize } = this;
+        log("apdu", "=> " + apdu.toString("hex"));
+        const framing = hid_framing_default(channel, packetSize);
+        const blocks = framing.makeBlocks(apdu);
+        for (let i = 0; i < blocks.length; i++) {
+          yield this.device.sendReport(0, blocks[i]);
+        }
+        let result;
+        let acc;
+        while (!(result = framing.getReducedResult(acc))) {
+          try {
+            const buffer = yield this.read();
+            acc = framing.reduceResponse(acc, buffer);
+          } catch (e) {
+            if (e instanceof TransportError && e.id === "InvalidChannel") {
+              continue;
+            }
+            throw e;
+          }
+        }
+        log("apdu", "<= " + result.toString("hex"));
+        return result;
+      })).catch((e) => {
+        if (e && e.message && e.message.includes("write")) {
+          this._emitDisconnect(e);
+          throw new DisconnectedDeviceDuringOperation(e.message);
+        }
+        throw e;
+      });
+      return b;
+    });
+    this.device = device;
+    this.deviceModel = typeof device.productId === "number" ? identifyUSBProductId(device.productId) : void 0;
+    device.addEventListener("inputreport", this.onInputReport);
+  }
+  /**
+   * Similar to create() except it will always display the device permission (even if some devices are already accepted).
+   */
+  static request() {
+    return __awaiter(this, void 0, void 0, function* () {
+      const [device] = yield requestLedgerDevices();
+      return _TransportWebHID.open(device);
+    });
+  }
+  /**
+   * Similar to create() except it will never display the device permission (it returns a Promise<?Transport>, null if it fails to find a device).
+   */
+  static openConnected() {
+    return __awaiter(this, void 0, void 0, function* () {
+      const devices = yield getLedgerDevices();
+      if (devices.length === 0)
+        return null;
+      return _TransportWebHID.open(devices[0]);
+    });
+  }
+  /**
+   * Create a Ledger transport with a HIDDevice
+   */
+  static open(device) {
+    return __awaiter(this, void 0, void 0, function* () {
+      yield device.open();
+      const transport = new _TransportWebHID(device);
+      const onDisconnect = (e) => {
+        if (device === e.device) {
+          getHID().removeEventListener("disconnect", onDisconnect);
+          transport._emitDisconnect(new DisconnectedDevice());
+        }
+      };
+      getHID().addEventListener("disconnect", onDisconnect);
+      return transport;
+    });
+  }
+  /**
+   * Release the transport device
+   */
+  close() {
+    return __awaiter(this, void 0, void 0, function* () {
+      yield this.exchangeBusyPromise;
+      this.device.removeEventListener("inputreport", this.onInputReport);
+      yield this.device.close();
+    });
+  }
+  setScrambleKey() {
+  }
+};
+TransportWebHID.isSupported = isSupported;
+TransportWebHID.list = getLedgerDevices;
+TransportWebHID.listen = (observer) => {
+  let unsubscribed = false;
+  getFirstLedgerDevice().then((device) => {
+    if (!device) {
+      observer.error(new TransportOpenUserCancelled("Access denied to use Ledger device"));
+    } else if (!unsubscribed) {
+      const deviceModel = typeof device.productId === "number" ? identifyUSBProductId(device.productId) : void 0;
+      observer.next({
+        type: "add",
+        descriptor: device,
+        deviceModel
+      });
+      observer.complete();
+    }
+  }, (error) => {
+    observer.error(new TransportOpenUserCancelled(error.message));
+  });
+  function unsubscribe() {
+    unsubscribed = true;
+  }
+  return {
+    unsubscribe
+  };
+};
+var TransportWebHID_default = TransportWebHID;
+export {
+  TransportWebHID_default as default
+};

package/dist/TransportWebUSB-CZSRX7MB.js

@@ -0,0 +1,258 @@
+import {
+  DisconnectedDevice,
+  DisconnectedDeviceDuringOperation,
+  TransportInterfaceNotAvailable,
+  TransportOpenUserCancelled,
+  TransportWebUSBGestureRequired,
+  Transport_default,
+  hid_framing_default,
+  identifyUSBProductId,
+  ledgerUSBVendorId,
+  log
+} from "./chunk-ISCCOOHD.js";
+import "./chunk-DOLYMX7P.js";
+
+// node_modules/.pnpm/@ledgerhq+hw-transport-webusb@6.29.4/node_modules/@ledgerhq/hw-transport-webusb/lib-es/webusb.js
+var __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());
+  });
+};
+var ledgerDevices = [
+  {
+    vendorId: ledgerUSBVendorId
+  }
+];
+function requestLedgerDevice() {
+  return __awaiter(this, void 0, void 0, function* () {
+    const device = yield navigator.usb.requestDevice({
+      filters: ledgerDevices
+    });
+    return device;
+  });
+}
+function getLedgerDevices() {
+  return __awaiter(this, void 0, void 0, function* () {
+    const devices = yield navigator.usb.getDevices();
+    return devices.filter((d) => d.vendorId === ledgerUSBVendorId);
+  });
+}
+function getFirstLedgerDevice() {
+  return __awaiter(this, void 0, void 0, function* () {
+    const existingDevices = yield getLedgerDevices();
+    if (existingDevices.length > 0)
+      return existingDevices[0];
+    return requestLedgerDevice();
+  });
+}
+var isSupported = () => Promise.resolve(!!navigator && !!navigator.usb && typeof navigator.usb.getDevices === "function");
+
+// node_modules/.pnpm/@ledgerhq+hw-transport-webusb@6.29.4/node_modules/@ledgerhq/hw-transport-webusb/lib-es/TransportWebUSB.js
+var __awaiter2 = 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());
+  });
+};
+var configurationValue = 1;
+var endpointNumber = 3;
+var TransportWebUSB = class _TransportWebUSB extends Transport_default {
+  constructor(device, interfaceNumber) {
+    super();
+    this.channel = Math.floor(Math.random() * 65535);
+    this.packetSize = 64;
+    this._disconnectEmitted = false;
+    this._emitDisconnect = (e) => {
+      if (this._disconnectEmitted)
+        return;
+      this._disconnectEmitted = true;
+      this.emit("disconnect", e);
+    };
+    this.device = device;
+    this.interfaceNumber = interfaceNumber;
+    this.deviceModel = identifyUSBProductId(device.productId);
+  }
+  /**
+   * Similar to create() except it will always display the device permission (even if some devices are already accepted).
+   */
+  static request() {
+    return __awaiter2(this, void 0, void 0, function* () {
+      const device = yield requestLedgerDevice();
+      return _TransportWebUSB.open(device);
+    });
+  }
+  /**
+   * Similar to create() except it will never display the device permission (it returns a Promise<?Transport>, null if it fails to find a device).
+   */
+  static openConnected() {
+    return __awaiter2(this, void 0, void 0, function* () {
+      const devices = yield getLedgerDevices();
+      if (devices.length === 0)
+        return null;
+      return _TransportWebUSB.open(devices[0]);
+    });
+  }
+  /**
+   * Create a Ledger transport with a USBDevice
+   */
+  static open(device) {
+    return __awaiter2(this, void 0, void 0, function* () {
+      yield device.open();
+      if (device.configuration === null) {
+        yield device.selectConfiguration(configurationValue);
+      }
+      yield gracefullyResetDevice(device);
+      const iface = device.configurations[0].interfaces.find(({ alternates }) => alternates.some((a) => a.interfaceClass === 255));
+      if (!iface) {
+        throw new TransportInterfaceNotAvailable("No WebUSB interface found for your Ledger device. Please upgrade firmware or contact techsupport.");
+      }
+      const interfaceNumber = iface.interfaceNumber;
+      try {
+        yield device.claimInterface(interfaceNumber);
+      } catch (e) {
+        yield device.close();
+        throw new TransportInterfaceNotAvailable(e.message);
+      }
+      const transport = new _TransportWebUSB(device, interfaceNumber);
+      const onDisconnect = (e) => {
+        if (device === e.device) {
+          navigator.usb.removeEventListener("disconnect", onDisconnect);
+          transport._emitDisconnect(new DisconnectedDevice());
+        }
+      };
+      navigator.usb.addEventListener("disconnect", onDisconnect);
+      return transport;
+    });
+  }
+  /**
+   * Release the transport device
+   */
+  close() {
+    return __awaiter2(this, void 0, void 0, function* () {
+      yield this.exchangeBusyPromise;
+      yield this.device.releaseInterface(this.interfaceNumber);
+      yield gracefullyResetDevice(this.device);
+      yield this.device.close();
+    });
+  }
+  /**
+   * Exchange with the device using APDU protocol.
+   * @param apdu
+   * @returns a promise of apdu response
+   */
+  exchange(apdu) {
+    return __awaiter2(this, void 0, void 0, function* () {
+      const b = yield this.exchangeAtomicImpl(() => __awaiter2(this, void 0, void 0, function* () {
+        const { channel, packetSize } = this;
+        log("apdu", "=> " + apdu.toString("hex"));
+        const framing = hid_framing_default(channel, packetSize);
+        const blocks = framing.makeBlocks(apdu);
+        for (let i = 0; i < blocks.length; i++) {
+          yield this.device.transferOut(endpointNumber, blocks[i]);
+        }
+        let result;
+        let acc;
+        while (!(result = framing.getReducedResult(acc))) {
+          const r = yield this.device.transferIn(endpointNumber, packetSize);
+          const buffer = Buffer.from(r.data.buffer);
+          acc = framing.reduceResponse(acc, buffer);
+        }
+        log("apdu", "<= " + result.toString("hex"));
+        return result;
+      })).catch((e) => {
+        if (e && e.message && e.message.includes("disconnected")) {
+          this._emitDisconnect(e);
+          throw new DisconnectedDeviceDuringOperation(e.message);
+        }
+        throw e;
+      });
+      return b;
+    });
+  }
+  setScrambleKey() {
+  }
+};
+TransportWebUSB.isSupported = isSupported;
+TransportWebUSB.list = getLedgerDevices;
+TransportWebUSB.listen = (observer) => {
+  let unsubscribed = false;
+  getFirstLedgerDevice().then((device) => {
+    if (!unsubscribed) {
+      const deviceModel = identifyUSBProductId(device.productId);
+      observer.next({
+        type: "add",
+        descriptor: device,
+        deviceModel
+      });
+      observer.complete();
+    }
+  }, (error) => {
+    if (window.DOMException && error instanceof window.DOMException && error.code === 18) {
+      observer.error(new TransportWebUSBGestureRequired(error.message));
+    } else {
+      observer.error(new TransportOpenUserCancelled(error.message));
+    }
+  });
+  function unsubscribe() {
+    unsubscribed = true;
+  }
+  return {
+    unsubscribe
+  };
+};
+var TransportWebUSB_default = TransportWebUSB;
+function gracefullyResetDevice(device) {
+  return __awaiter2(this, void 0, void 0, function* () {
+    try {
+      yield device.reset();
+    } catch (err) {
+      console.warn(err);
+    }
+  });
+}
+export {
+  TransportWebUSB_default as default
+};