How to use @ledgerhq/hw-transport-mocker - 10 common examples

let Transport;
let saveToFile = null;
let recordStore;

const log = mainOptions.silent ? () => {} : (...args) => console.log(...args);

// --mock 
// There are two ways to use the mock, either you record or you replay
// - record means that it's a decoration in node-hid that will just save to a file
// - replay means that it's going to re-use a recorded file and mock a transport instead of using an actual device
// replay mode is the default unless environment RECORD_APDU_TO_FILE is defined, this allow to easily replay tests in record mode.
if (mainOptions.file) {
  if (process.env.RECORD_APDU_TO_FILE) {
    log(`the APDUs will be recorded in ${mainOptions.file}`);
    saveToFile = mainOptions.file;
    recordStore = new RecordStore([]);
    Transport = createTransportRecorder(
      require("@ledgerhq/hw-transport-node-hid").default,
      recordStore
    );
  } else {
    recordStore = RecordStore.fromString(
      fs.readFileSync(mainOptions.file, "utf8")
    );
    if (recordStore.isEmpty()) {
      process.exit(0);
    }
    log(
      `${recordStore.queue.length} mocked APDUs will be replayed from ${mainOptions.file}`
    );
    Transport = createTransportReplayer(recordStore);
  }

let saveToFile = null;
let recordStore;

const log = mainOptions.silent ? () => {} : (...args) => console.log(...args);

// --mock 
// There are two ways to use the mock, either you record or you replay
// - record means that it's a decoration in node-hid that will just save to a file
// - replay means that it's going to re-use a recorded file and mock a transport instead of using an actual device
// replay mode is the default unless environment RECORD_APDU_TO_FILE is defined, this allow to easily replay tests in record mode.
if (mainOptions.file) {
  if (process.env.RECORD_APDU_TO_FILE) {
    log(`the APDUs will be recorded in ${mainOptions.file}`);
    saveToFile = mainOptions.file;
    recordStore = new RecordStore([]);
    Transport = createTransportRecorder(
      require("@ledgerhq/hw-transport-node-hid").default,
      recordStore
    );
  } else {
    recordStore = RecordStore.fromString(
      fs.readFileSync(mainOptions.file, "utf8")
    );
    if (recordStore.isEmpty()) {
      process.exit(0);
    }
    log(
      `${recordStore.queue.length} mocked APDUs will be replayed from ${mainOptions.file}`
    );
    Transport = createTransportReplayer(recordStore);
  }
} else {

create: () => open(device || "")
      };
    };

    // --file 
    // There are two ways to use the mock, either you record or you replay
    // record: using --record means that it's a decoration in node-hid that will just save to a file
    // replay: without --record, it's going to re-use a recorded file and mock a transport instead of using an actual device
    if (file) {
      if (record) {
        log("proxy", `the APDUs will be recorded in ${file}`);
        saveToFile = file;
        recordStore = new RecordStore([]);
        Transport = createTransportRecorder(getTransportLike(), recordStore);
      } else {
        recordStore = RecordStore.fromString(fs.readFileSync(file, "utf8"));
        if (recordStore.isEmpty()) {
          process.exit(0);
        }
        log(
          "proxy",
          `${recordStore.queue.length} mocked APDUs will be replayed from ${file}`
        );
        Transport = createTransportReplayer(recordStore);
      }
    } else {
      Transport = getTransportLike();
    }

    const ifaces = os.networkInterfaces();
    const ips = Object.keys(ifaces)
      .reduce(

// --mock 
// There are two ways to use the mock, either you record or you replay
// - record means that it's a decoration in node-hid that will just save to a file
// - replay means that it's going to re-use a recorded file and mock a transport instead of using an actual device
// replay mode is the default unless environment RECORD_APDU_TO_FILE is defined, this allow to easily replay tests in record mode.
if (mainOptions.file) {
  if (process.env.RECORD_APDU_TO_FILE) {
    log(`the APDUs will be recorded in ${mainOptions.file}`);
    saveToFile = mainOptions.file;
    recordStore = new RecordStore([]);
    Transport = createTransportRecorder(
      require("@ledgerhq/hw-transport-node-hid").default,
      recordStore
    );
  } else {
    recordStore = RecordStore.fromString(
      fs.readFileSync(mainOptions.file, "utf8")
    );
    if (recordStore.isEmpty()) {
      process.exit(0);
    }
    log(
      `${recordStore.queue.length} mocked APDUs will be replayed from ${mainOptions.file}`
    );
    Transport = createTransportReplayer(recordStore);
  }
} else {
  Transport = require("@ledgerhq/hw-transport-node-hid").default;
}

const ifaces = os.networkInterfaces();
export const ips = Object.keys(ifaces)

if (file) {
      if (record) {
        log("proxy", `the APDUs will be recorded in ${file}`);
        saveToFile = file;
        recordStore = new RecordStore([]);
        Transport = createTransportRecorder(getTransportLike(), recordStore);
      } else {
        recordStore = RecordStore.fromString(fs.readFileSync(file, "utf8"));
        if (recordStore.isEmpty()) {
          process.exit(0);
        }
        log(
          "proxy",
          `${recordStore.queue.length} mocked APDUs will be replayed from ${file}`
        );
        Transport = createTransportReplayer(recordStore);
      }
    } else {
      Transport = getTransportLike();
    }

    const ifaces = os.networkInterfaces();
    const ips = Object.keys(ifaces)
      .reduce(
        (acc, ifname) =>
          acc.concat(
            ifaces[ifname].map(iface => {
              if (iface.family !== "IPv4" || iface.internal !== false) {
                // skip over internal (i.e. 127.0.0.1) and non-ipv4 addresses
                return;
              }
              return iface.address;

recordStore = new RecordStore([]);
    Transport = createTransportRecorder(
      require("@ledgerhq/hw-transport-node-hid").default,
      recordStore
    );
  } else {
    recordStore = RecordStore.fromString(
      fs.readFileSync(mainOptions.file, "utf8")
    );
    if (recordStore.isEmpty()) {
      process.exit(0);
    }
    log(
      `${recordStore.queue.length} mocked APDUs will be replayed from ${mainOptions.file}`
    );
    Transport = createTransportReplayer(recordStore);
  }
} else {
  Transport = require("@ledgerhq/hw-transport-node-hid").default;
}

const ifaces = os.networkInterfaces();
export const ips = Object.keys(ifaces)
  .reduce(
    (acc, ifname) =>
      acc.concat(
        ifaces[ifname].map(iface => {
          if ("IPv4" !== iface.family || iface.internal !== false) {
            // skip over internal (i.e. 127.0.0.1) and non-ipv4 addresses
            return;
          }
          return iface.address;

const getTransportLike = () => {
      return {
        open: () => open(device || ""),
        create: () => open(device || "")
      };
    };

    // --file 
    // There are two ways to use the mock, either you record or you replay
    // record: using --record means that it's a decoration in node-hid that will just save to a file
    // replay: without --record, it's going to re-use a recorded file and mock a transport instead of using an actual device
    if (file) {
      if (record) {
        log("proxy", `the APDUs will be recorded in ${file}`);
        saveToFile = file;
        recordStore = new RecordStore([]);
        Transport = createTransportRecorder(getTransportLike(), recordStore);
      } else {
        recordStore = RecordStore.fromString(fs.readFileSync(file, "utf8"));
        if (recordStore.isEmpty()) {
          process.exit(0);
        }
        log(
          "proxy",
          `${recordStore.queue.length} mocked APDUs will be replayed from ${file}`
        );
        Transport = createTransportReplayer(recordStore);
      }
    } else {
      Transport = getTransportLike();
    }

return {
        open: () => open(device || ""),
        create: () => open(device || "")
      };
    };

    // --file 
    // There are two ways to use the mock, either you record or you replay
    // record: using --record means that it's a decoration in node-hid that will just save to a file
    // replay: without --record, it's going to re-use a recorded file and mock a transport instead of using an actual device
    if (file) {
      if (record) {
        log("proxy", `the APDUs will be recorded in ${file}`);
        saveToFile = file;
        recordStore = new RecordStore([]);
        Transport = createTransportRecorder(getTransportLike(), recordStore);
      } else {
        recordStore = RecordStore.fromString(fs.readFileSync(file, "utf8"));
        if (recordStore.isEmpty()) {
          process.exit(0);
        }
        log(
          "proxy",
          `${recordStore.queue.length} mocked APDUs will be replayed from ${file}`
        );
        Transport = createTransportReplayer(recordStore);
      }
    } else {
      Transport = getTransportLike();
    }

    const ifaces = os.networkInterfaces();

test("OSU 1.5.5", async () => {
  const Transport = createTransportReplayer(
    RecordStore.fromString(`
    => e001000000
    <= 3110000409312e352e352d6f7375042400000004312e35002000000000000000000000000000000000000000000000000000000000000000009000
    `)
  );
  const t = await Transport.create();
  const deviceInfo = await getDeviceInfo(t);
  const next = await fetchNextFirmware(deviceInfo).toPromise();
  expect(next).toBeDefined();
  expect(next.firmware).toBeTruthy();
});

test("1.4.2 manager allowed", async () => {
  const Transport = createTransportReplayer(
    RecordStore.fromString(`
    => e001000000
    <= 3110000305312e342e3204ae00000004312e36002034c8e1ed994a446ef70c9b256d8a6e01eb949aba4b18b9f9a39b7f38782531039000
    `)
  );
  const t = await Transport.create();
  const res = await getDeviceInfo(t);
  expect(res).toMatchObject({
    version: "1.4.2",
    isBootloader: false,
    isOSU: false,
    managerAllowed: true,
    mcuVersion: "1.6",
    pinValidated: true,
    providerId: 1,
    majMin: "1.4",
    targetId: 823132163