@ledgerhq/live-common
Version:
Common ground for the Ledger Live apps
224 lines • 8.84 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", { value: true });
exports.withDevicePolling = exports.retryWhileErrors = exports.genericCanRetryOnError = exports.withDevicePromise = exports.withDevice = exports.cancelDeviceAction = exports.setErrorRemapping = void 0;
const rxjs_1 = require("rxjs");
const operators_1 = require("rxjs/operators");
const errors_1 = require("@ledgerhq/errors");
const logs_1 = require("@ledgerhq/logs");
const live_env_1 = require("@ledgerhq/live-env");
const _1 = require(".");
const LOG_TYPE = "hw";
const initialErrorRemapping = (error, context) => {
let mappedError = error;
if (error && error instanceof errors_1.TransportStatusError) {
if (error.statusCode === 0x6faa) {
mappedError = new errors_1.DeviceHalted(error.message);
}
else if (error.statusCode === 0x6b00) {
mappedError = new errors_1.FirmwareOrAppUpdateRequired(error.message);
}
}
(0, logs_1.trace)({
type: LOG_TYPE,
message: `Initial error remapping: ${error}`,
data: { error, mappedError },
context,
});
return (0, rxjs_1.throwError)(() => mappedError);
};
let errorRemapping = e => (0, rxjs_1.throwError)(() => e);
const setErrorRemapping = (f) => {
errorRemapping = f;
};
exports.setErrorRemapping = setErrorRemapping;
const never = new Promise(() => { });
/**
* Wrapper to pipe a "cleanup" function at then end of an Observable flow.
*
* The `finalize` is only called once if there is an error and a complete
* (but normally an error event completes automatically the Observable pipes. Is it needed ?)
*/
function transportFinally(cleanup) {
return (observable) => {
return new rxjs_1.Observable(o => {
let done = false;
const finalize = () => {
if (done)
return never;
done = true;
return cleanup();
};
const sub = observable.subscribe({
next: e => o.next(e),
complete: () => {
finalize().then(() => o.complete());
},
error: e => {
finalize().then(() => o.error(e));
},
});
return () => {
sub.unsubscribe();
finalize();
};
});
};
}
const identifyTransport = t => (typeof t.id === "string" ? t.id : "");
const needsCleanup = {};
// When a series of APDUs are interrupted, this is called
// so we don't forget to cleanup on the next withDevice
const cancelDeviceAction = (transport) => {
const transportId = identifyTransport(transport);
(0, logs_1.trace)({
type: LOG_TYPE,
message: "Cancelling device action",
data: { transportId },
});
needsCleanup[transportId] = true;
};
exports.cancelDeviceAction = cancelDeviceAction;
/**
* Provides a Transport instance to a given job
*
* @param deviceId
* @param options contains optional configuration
* - openTimeoutMs: optional timeout that limits in time the open attempt of the matching registered transport.
* - matchDeviceByName: optional name of the device to match.
*/
const withDevice = (deviceId, options) => (job) => new rxjs_1.Observable(o => {
const tracer = new logs_1.LocalTracer(LOG_TYPE, { deviceId, origin: "hw:withDevice" });
tracer.trace(`New job for device: ${deviceId || "USB"}`);
// To call to cleanup the current transport
const finalize = async (transport) => {
tracer.trace("Closing and cleaning transport", { function: "finalize" });
try {
await (0, _1.close)(transport, deviceId);
}
catch (error) {
tracer.trace(`An error occurred when closing transport (ignoring it): ${error}`, {
error,
function: "finalize",
});
}
};
let unsubscribed;
let sub;
// Open the transport
(0, _1.open)(deviceId, options, tracer.getContext())
.then(async (transport) => {
tracer.trace("Got a Transport instance from open");
if (unsubscribed) {
tracer.trace("Unsubscribed while opening transport");
// It was unsubscribed prematurely
return finalize(transport);
}
if (needsCleanup[identifyTransport(transport)]) {
delete needsCleanup[identifyTransport(transport)];
await transport.send(0, 0, 0, 0).catch(() => { });
}
return transport;
})
// This catch is here only for errors that might happen at open or at clean up of the transport before doing the job
.catch(e => {
tracer.trace(`Error while opening Transport: ${e}`, { error: e });
if (e instanceof errors_1.BluetoothRequired)
throw e;
if (e instanceof errors_1.TransportWebUSBGestureRequired)
throw e;
if (e instanceof errors_1.TransportInterfaceNotAvailable)
throw e;
if (e instanceof errors_1.PeerRemovedPairing)
throw e;
if (e instanceof errors_1.PairingFailed)
throw e;
console.error(e);
throw new errors_1.CantOpenDevice(e.message);
})
// Executes the job
.then(transport => {
tracer.trace("Executing job", { hasTransport: !!transport, unsubscribed });
if (!transport)
return;
// It was unsubscribed prematurely
if (unsubscribed) {
tracer.trace("Unsubscribed before executing job");
return finalize(transport);
}
sub = job(transport)
.pipe((0, operators_1.catchError)(error => initialErrorRemapping(error, tracer.getContext())), (0, operators_1.catchError)(errorRemapping), transportFinally(() => {
// Closes the transport and cleans up everything
return finalize(transport);
}))
.subscribe({
next: event => {
// This kind of log should be a "debug" level for ex
// tracer.trace("Job next", { event });
o.next(event);
},
error: error => {
tracer.trace("Job error", { error });
if (error.statusCode) {
o.error(new errors_1.TransportStatusError(error.statusCode));
}
else {
o.error(error);
}
},
complete: () => {
o.complete();
},
});
})
.catch(error => {
tracer.trace(`Caught error on job execution step: ${error}`, { error });
o.error(error);
});
// Returns function to unsubscribe from the job if we don't need it anymore.
// This will prevent us from executing the job unnecessarily later on
return () => {
tracer.trace(`Unsubscribing withDevice flow. Ongoing job to unsubscribe from ? ${!!sub}`);
unsubscribed = true;
if (sub)
sub.unsubscribe();
};
});
exports.withDevice = withDevice;
/**
* Provides a Transport instance to the given function fn
* @see withDevice
*/
const withDevicePromise = (deviceId, fn) => (0, rxjs_1.firstValueFrom)((0, exports.withDevice)(deviceId)(transport => (0, rxjs_1.from)(fn(transport))));
exports.withDevicePromise = withDevicePromise;
const genericCanRetryOnError = (err) => {
if (err instanceof errors_1.WrongAppForCurrency)
return false;
if (err instanceof errors_1.WrongDeviceForAccount)
return false;
if (err instanceof errors_1.CantOpenDevice)
return false;
if (err instanceof errors_1.BluetoothRequired)
return false;
if (err instanceof errors_1.UpdateYourApp)
return false;
if (err instanceof errors_1.FirmwareOrAppUpdateRequired)
return false;
if (err instanceof errors_1.DeviceHalted)
return false;
if (err instanceof errors_1.TransportWebUSBGestureRequired)
return false;
if (err instanceof errors_1.TransportInterfaceNotAvailable)
return false;
return true;
};
exports.genericCanRetryOnError = genericCanRetryOnError;
const retryWhileErrors = (acceptError) => (attempts) => attempts.pipe((0, operators_1.mergeMap)(error => {
if (!acceptError(error)) {
return (0, rxjs_1.throwError)(() => error);
}
return (0, rxjs_1.timer)((0, live_env_1.getEnv)("WITH_DEVICE_POLLING_DELAY"));
}));
exports.retryWhileErrors = retryWhileErrors;
const withDevicePolling = (deviceId) => (job, acceptError = exports.genericCanRetryOnError) => (0, exports.withDevice)(deviceId)(job).pipe((0, operators_1.retryWhen)((0, exports.retryWhileErrors)(acceptError)));
exports.withDevicePolling = withDevicePolling;
//# sourceMappingURL=deviceAccess.js.map