@ledgerhq/revault-sdk 0.25.0 → 0.25.1

package/lib/device-B8Fww8_6.js

@@ -0,0 +1,719 @@
+import axios from "axios";
+import axiosRetry from "axios-retry";
+import { v4 } from "uuid";
+import { Observable, throwError, timer } from "rxjs";
+import { catchError, mergeMap, retryWhen } from "rxjs/operators";
+//#region src/device/constants.ts
+const PATHS = {
+	U2F: "5655636'/5583430'",
+	CONFIDENTIALITY: "5655636'/4410950'",
+	KEY_MATERIAL: "5655636'/4932953'",
+	VALIDATION: "5655636'/5652812'"
+};
+const SCRIPT_IDS = {
+	INIT_SESSION: 3,
+	ACCOUNT_MANAGER_SESSION: 2
+};
+const STR_ROLES = {
+	OPERATOR: "00",
+	ADMIN: "01",
+	SHARED_OWNER: "02"
+};
+const APPID_VAULT_ADMINISTRATOR = "ad5be1a1fe011ce7f53ae081a22ae000a42021f3f94106a3bac9f76e8230e4b9";
+const all61xxStatus = [];
+for (let i = 24832; i <= 25087; i++) all61xxStatus.push(i);
+const PAGINATED_STATUS = all61xxStatus;
+//#endregion
+//#region src/device/api-device.ts
+function createApiDevice(options, logger) {
+	const { genSeed } = options;
+	const sessionId = v4();
+	const deviceApi = axios.create({ baseURL: options.deviceApiUrl });
+	axiosRetry(deviceApi, {
+		retryDelay: axiosRetry.linearDelay(1e3),
+		retries: 3,
+		retryCondition: () => true,
+		onRetry: (retryCount, err) => {
+			const formattedErr = `${err.code ?? `UNKNOWN`} on ${err.config?.method?.toUpperCase() ?? "UNKNOWN_METHOD"} ${err.config?.url ?? "UNKNOWN_URL"}`;
+			logger.warning(`Retrying request to device-api (attempt ${retryCount}) - Cause: ${formattedErr}`);
+		}
+	});
+	/* v8 ignore start -- @preserve */
+	deviceApi.interceptors.request.use((config) => {
+		logger.debug(`[device-api] ${config.method?.toUpperCase()} ${config.url}${config.data ? ` ${JSON.stringify(config.data)}` : ""}`);
+		if (["post", "put"].includes(config.method)) {
+			const isStringMode = typeof config.data === "string";
+			const enhancedData = {
+				sessionID: sessionId,
+				psd_model: "02",
+				version: 3,
+				...isStringMode ? JSON.parse(config.data) : config.data
+			};
+			config.data = isStringMode ? JSON.stringify(enhancedData) : enhancedData;
+		}
+		return config;
+	}, (error) => Promise.reject(error));
+	/* v8 ignore stop */
+	return { with: (index) => {
+		const __seed = genSeed({
+			salt: options.salt,
+			index
+		});
+		const getSeed = async () => {
+			if (typeof __seed === "string") return Promise.resolve(__seed);
+			return __seed;
+		};
+		const authenticate = async ({ challenge, workspaceName }) => {
+			const role = challenge.role;
+			if (role === "READ_ONLY_API_KEY") throw new Error("Invalid role for authenticate: READ_ONLY_API_KEY");
+			const { data } = await deviceApi.post("/authenticate", {
+				seed: await getSeed(),
+				challenge: Buffer.from(challenge.challenge, "base64").toString("hex"),
+				application: APPID_VAULT_ADMINISTRATOR,
+				key_handle: challenge.keyHandle,
+				name: challenge.name,
+				role: STR_ROLES[role],
+				type: "02",
+				workspaceName
+			});
+			return data;
+		};
+		const finalizePairingHandshake = async (params) => {
+			const { handshake, partitionId } = params;
+			const payload = {
+				seed: await getSeed(),
+				handshake,
+				ciphertext: partitionId
+			};
+			return (await deviceApi.post("/finalize-pairing-handshake", payload)).data;
+		};
+		const generateSeedFragment = async () => {
+			const payload = {
+				seed: await getSeed(),
+				path: PATHS.KEY_MATERIAL,
+				goal: 0
+			};
+			const { data } = await deviceApi.post("/generate-key-component", payload);
+			return data;
+		};
+		const generateWrappingKeyFragment = async () => {
+			const payload = {
+				seed: await getSeed(),
+				goal: 1,
+				path: PATHS.KEY_MATERIAL
+			};
+			const res = await deviceApi.post("/generate-key-fragments", payload);
+			return Buffer.from(res.data, "hex").toString("base64");
+		};
+		const getAttestation = async () => {
+			const { data: attestationStr } = await deviceApi.post("/get-attestation", { seed: await getSeed() });
+			const attestationBuffer = Buffer.from(attestationStr, "hex");
+			const certLen = attestationBuffer.readInt8(98);
+			return {
+				attestation: {
+					codeHash: attestationBuffer.slice(0, 32).toString("base64"),
+					attestationPub: attestationBuffer.slice(32, 97).toString("base64"),
+					certificate: attestationBuffer.slice(97, 99 + certLen).toString("base64")
+				},
+				buffer: attestationBuffer
+			};
+		};
+		const getConfidentialityKey = async () => {
+			const res = await deviceApi.post("/get-confidentiality-key", { seed: await getSeed() });
+			return {
+				confidentialityKeyCurve25519: res.data.confidentiality_key_curve25519,
+				confidentialityKeySignature: res.data.confidentiality_key_signature
+			};
+		};
+		const getConfidentialityPubKey = async () => {
+			return getPublicKey({ path: PATHS.CONFIDENTIALITY });
+		};
+		const getDeviceUserId = async () => {
+			return (await deviceApi.post("/blue-device-id", { seed: await getSeed() })).data.blue_device_id.toUpperCase();
+		};
+		const getU2FPubKey = async () => {
+			return getPublicKey({ path: PATHS.U2F });
+		};
+		const getValidationPubKey = async () => {
+			return getPublicKey({ path: PATHS.VALIDATION });
+		};
+		const hasPairing = async () => {
+			return (await deviceApi.post("/get-partition-ids", { seed: await getSeed() })).data.length > 0;
+		};
+		const initPairingHandshake = async () => {
+			const { data } = await deviceApi.post("/initiate-pairing-handshake", { seed: await getSeed() });
+			return {
+				pubKey: data.pubKey,
+				signature: Buffer.from(data.attestation, "hex").toString("base64")
+			};
+		};
+		const openSession = async (params) => {
+			const { secureChannel } = params;
+			const signature = Buffer.from(secureChannel.certificate.signature, "base64");
+			const attestationPubKey = Buffer.from(secureChannel.certificate.attestationPub, "base64");
+			const attestationCertificate = Buffer.from(secureChannel.certificate.certificate, "base64");
+			const attestation = Buffer.concat([
+				Buffer.from([signature.length]),
+				signature,
+				attestationPubKey,
+				Buffer.from([attestationCertificate.length]),
+				attestationCertificate
+			]);
+			const payload = {
+				seed: await getSeed(),
+				path: PATHS.CONFIDENTIALITY,
+				pubKey: secureChannel.pubKey,
+				attestation: attestation.toString("hex"),
+				scriptId: SCRIPT_IDS.INIT_SESSION
+			};
+			const { data: deviceResponse } = await deviceApi.post("/open-session", payload);
+			if (deviceResponse !== "9000") throw new Error(`device-api device failed with code: ${deviceResponse}`);
+		};
+		const register = async (params) => {
+			const { challenge, u2fRegisterData, name, role } = params;
+			const payload = {
+				seed: await getSeed(),
+				challenge,
+				name,
+				role: STR_ROLES[role],
+				hsm_data: u2fRegisterData,
+				type: "02",
+				application: APPID_VAULT_ADMINISTRATOR
+			};
+			const { data } = await deviceApi.post("/register", payload);
+			const response = Buffer.from(data, "hex");
+			let i = 0;
+			const rfu = response.slice(i, i + 1)[0];
+			i += 1;
+			const pubKey = response.slice(i, i + 65).toString("hex");
+			i += 65;
+			const keyHandleLength = response.slice(i, i + 1)[0];
+			i++;
+			const keyHandle = response.slice(i, i + keyHandleLength);
+			i += keyHandleLength;
+			return {
+				u2fRegister: response.slice(0, response.length - 2),
+				keyHandle,
+				rfu,
+				pubKey
+			};
+		};
+		const registerData = async (params) => {
+			const { challenge } = params;
+			const payload = {
+				seed: await getSeed(),
+				challenge
+			};
+			return (await deviceApi.post("/u2f-register-data", payload)).data;
+		};
+		const setPairing = async ({ pairing }) => {
+			const payload = {
+				seed: await getSeed(),
+				blob: pairing.blob,
+				pairing: {
+					bootstrap_enabled: pairing.pairing.bootstrapEnabled,
+					partition_key: pairing.pairing.partitionKey,
+					workspace_name: pairing.pairing.workspaceName
+				},
+				partition_key_attestation: {
+					code_hash: pairing.partitionKeyAttestation.codeHash,
+					attestation_pub: pairing.partitionKeyAttestation.attestationPub,
+					certificate: pairing.partitionKeyAttestation.certificate,
+					signature: pairing.partitionKeyAttestation.signature
+				}
+			};
+			await deviceApi.post("/set-partition-key", payload);
+		};
+		const startKKPatternAsResponder = async (params) => {
+			const payload = {
+				seed: await getSeed(),
+				script_id: SCRIPT_IDS.ACCOUNT_MANAGER_SESSION,
+				handshake: params.handshake,
+				handshake_attestation: "",
+				partition_id: params.partitionId
+			};
+			const { data } = await deviceApi.post("/start-kk-pattern-as-responder", payload);
+			const buffer = Buffer.from(data, "hex");
+			const dataLength = buffer.readInt8(0);
+			return {
+				handshake: buffer.slice(1, dataLength + 1).toString("base64"),
+				signature: buffer.slice(dataLength + 1).toString("base64")
+			};
+		};
+		const startKPatternAsResponder = async (params) => {
+			const { handshake, partitionId } = params;
+			const payload = {
+				seed: await getSeed(),
+				script_id: SCRIPT_IDS.ACCOUNT_MANAGER_SESSION,
+				handshake,
+				handshake_attestation: "",
+				partition_id: partitionId
+			};
+			const { data: deviceResponse } = await deviceApi.post("/start-k-pattern-as-responder", payload);
+			if (deviceResponse !== "9000") throw new Error(`device-api device failed with code: ${deviceResponse}`);
+		};
+		const getPublicKey = async (params) => {
+			const { path } = params;
+			const payload = {
+				seed: await getSeed(),
+				secp256k1: true,
+				path
+			};
+			const res = await deviceApi.post("/get-public-key", payload);
+			return {
+				pubKey: res.data.pubKey,
+				signature: Buffer.from(res.data.attestation, "hex").toString("base64")
+			};
+		};
+		const validateVaultOperation = async (params) => {
+			const { actions } = params;
+			const payload = {
+				seed: await getSeed(),
+				path: PATHS.VALIDATION,
+				actions
+			};
+			const { data: signature } = await deviceApi.post("/validate-op", payload);
+			return signature;
+		};
+		const sendAPDU = (_apdu) => {
+			logger.info("Can't send arbitrary APDU to software device");
+			return Promise.resolve("9000");
+		};
+		const getVersion = async () => {
+			return "1.2.3";
+		};
+		const poll = async () => {
+			await new Promise((r) => setTimeout(r, 1e3));
+			return { isAppOpened: true };
+		};
+		const pollApp = async () => {
+			await new Promise((r) => setTimeout(r, 1e3));
+			return "9000";
+		};
+		return {
+			authenticate,
+			finalizePairingHandshake,
+			generateSeedFragment,
+			generateWrappingKeyFragment,
+			getAttestation,
+			getConfidentialityKey,
+			getConfidentialityPubKey,
+			getDeviceUserId,
+			getU2FPubKey,
+			getValidationPubKey,
+			hasPairing,
+			initPairingHandshake,
+			openSession,
+			register,
+			registerData,
+			setPairing,
+			startKKPatternAsResponder,
+			startKPatternAsResponder,
+			validateVaultOperation,
+			getVersion,
+			sendAPDU,
+			poll,
+			pollApp
+		};
+	} };
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@ledgerhq+errors@6.32.0/node_modules/@ledgerhq/errors/lib-es/helpers.js
+const errorClasses = {};
+const deserializers = {};
+const addCustomErrorDeserializer = (name, deserializer) => {
+	deserializers[name] = deserializer;
+};
+const createCustomErrorClass = (name) => {
+	class CustomErrorClass extends Error {
+		cause;
+		constructor(message, fields, options) {
+			super(message || name, options);
+			Object.setPrototypeOf(this, CustomErrorClass.prototype);
+			this.name = name;
+			if (fields) for (const k in fields) this[k] = fields[k];
+			if (options && isObject(options) && "cause" in options && !this.cause) {
+				const cause = options.cause;
+				this.cause = cause;
+				if ("stack" in cause) this.stack = this.stack + "\nCAUSE: " + cause.stack;
+			}
+		}
+	}
+	errorClasses[name] = CustomErrorClass;
+	return CustomErrorClass;
+};
+function isObject(value) {
+	return typeof value === "object";
+}
+createCustomErrorClass("AccountNameRequired");
+createCustomErrorClass("AccountNotSupported");
+createCustomErrorClass("AccountAwaitingSendPendingOperations");
+createCustomErrorClass("AmountRequired");
+const BluetoothRequired = createCustomErrorClass("BluetoothRequired");
+createCustomErrorClass("BtcUnmatchedApp");
+const CantOpenDevice = createCustomErrorClass("CantOpenDevice");
+createCustomErrorClass("CashAddrNotSupported");
+createCustomErrorClass("ClaimRewardsFeesWarning");
+createCustomErrorClass("CurrencyNotSupported");
+createCustomErrorClass("DeviceAppVerifyNotSupported");
+createCustomErrorClass("DeviceGenuineSocketEarlyClose");
+createCustomErrorClass("DeviceNotGenuine");
+createCustomErrorClass("DeviceOnDashboardExpected");
+createCustomErrorClass("DeviceOnDashboardUnexpected");
+createCustomErrorClass("DeviceInOSUExpected");
+const DeviceHalted = createCustomErrorClass("DeviceHalted");
+createCustomErrorClass("DeviceNameInvalid");
+createCustomErrorClass("DeviceSocketFail");
+createCustomErrorClass("DeviceSocketNoBulkStatus");
+createCustomErrorClass("DeviceSocketNoBulkStatus");
+createCustomErrorClass("UnresponsiveDeviceError");
+const DisconnectedDevice = createCustomErrorClass("DisconnectedDevice");
+createCustomErrorClass("DisconnectedDeviceDuringOperation");
+createCustomErrorClass("DeviceExtractOnboardingStateError");
+createCustomErrorClass("DeviceOnboardingStatePollingError");
+createCustomErrorClass("EnpointConfig");
+createCustomErrorClass("EthAppPleaseEnableContractData");
+createCustomErrorClass("SolAppPleaseEnableContractData");
+createCustomErrorClass("CeloAppPleaseEnableContractData");
+createCustomErrorClass("FeeEstimationFailed");
+createCustomErrorClass("FirmwareNotRecognized");
+createCustomErrorClass("HardResetFail");
+createCustomErrorClass("InvalidXRPTag");
+createCustomErrorClass("InvalidAddress");
+createCustomErrorClass("InvalidTransactionError");
+createCustomErrorClass("InvalidNonce");
+createCustomErrorClass("InvalidAddressBecauseDestinationIsAlsoSource");
+createCustomErrorClass("LatestMCUInstalledError");
+createCustomErrorClass("LatestFirmwareVersionRequired");
+createCustomErrorClass("UnsupportedFeatureError");
+createCustomErrorClass("NanoSNotSupported");
+createCustomErrorClass("UnknownMCU");
+createCustomErrorClass("LedgerAPIError");
+createCustomErrorClass("LedgerAPIErrorWithMessage");
+createCustomErrorClass("LedgerAPINotAvailable");
+createCustomErrorClass("ManagerAppAlreadyInstalled");
+createCustomErrorClass("ManagerAppRelyOnBTC");
+createCustomErrorClass("ManagerAppDepInstallRequired");
+createCustomErrorClass("ManagerAppDepUninstallRequired");
+createCustomErrorClass("ManagerDeviceLocked");
+createCustomErrorClass("ManagerFirmwareNotEnoughSpace");
+createCustomErrorClass("ManagerNotEnoughSpace");
+createCustomErrorClass("ManagerUninstallBTCDep");
+createCustomErrorClass("NetworkDown");
+createCustomErrorClass("NetworkError");
+createCustomErrorClass("NoAddressesFound");
+createCustomErrorClass("NotEnoughBalance");
+createCustomErrorClass("NotEnoughBalanceFees");
+createCustomErrorClass("NotEnoughBalanceSwap");
+createCustomErrorClass("NotEnoughBalanceToDelegate");
+createCustomErrorClass("UnstakeNotEnoughStakedBalanceLeft");
+createCustomErrorClass("RestakeNotEnoughStakedBalanceLeft");
+createCustomErrorClass("NotEnoughToRestake");
+createCustomErrorClass("NotEnoughToUnstake");
+createCustomErrorClass("NotEnoughBalanceInParentAccount");
+createCustomErrorClass("NotEnoughSpendableBalance");
+createCustomErrorClass("NotEnoughBalanceBecauseDestinationNotCreated");
+createCustomErrorClass("NotEnoughToStake");
+createCustomErrorClass("NoAccessToCamera");
+createCustomErrorClass("NotEnoughGas");
+createCustomErrorClass("NotEnoughGasSwap");
+createCustomErrorClass("TronEmptyAccount");
+createCustomErrorClass("MaybeKeepTronAccountAlive");
+createCustomErrorClass("NotSupportedLegacyAddress");
+createCustomErrorClass("GasLessThanEstimate");
+createCustomErrorClass("PriorityFeeTooLow");
+createCustomErrorClass("PriorityFeeTooHigh");
+createCustomErrorClass("PriorityFeeHigherThanMaxFee");
+createCustomErrorClass("MaxFeeTooLow");
+createCustomErrorClass("PasswordsDontMatch");
+createCustomErrorClass("PasswordIncorrect");
+createCustomErrorClass("RecommendSubAccountsToEmpty");
+createCustomErrorClass("RecommendUndelegation");
+createCustomErrorClass("TimeoutTagged");
+createCustomErrorClass("UnexpectedBootloader");
+createCustomErrorClass("MCUNotGenuineToDashboard");
+createCustomErrorClass("RecipientRequired");
+createCustomErrorClass("UnavailableTezosOriginatedAccountReceive");
+createCustomErrorClass("UnavailableTezosOriginatedAccountSend");
+createCustomErrorClass("UpdateFetchFileFail");
+createCustomErrorClass("UpdateIncorrectHash");
+createCustomErrorClass("UpdateIncorrectSig");
+createCustomErrorClass("UpdateYourApp");
+createCustomErrorClass("UserRefusedDeviceNameChange");
+createCustomErrorClass("UserRefusedAddress");
+createCustomErrorClass("UserRefusedFirmwareUpdate");
+createCustomErrorClass("UserRefusedAllowManager");
+createCustomErrorClass("UserRefusedOnDevice");
+createCustomErrorClass("PinNotSet");
+createCustomErrorClass("ExpertModeRequired");
+createCustomErrorClass("TransportOpenUserCancelled");
+const TransportInterfaceNotAvailable = createCustomErrorClass("TransportInterfaceNotAvailable");
+createCustomErrorClass("TransportRaceCondition");
+const TransportWebUSBGestureRequired = createCustomErrorClass("TransportWebUSBGestureRequired");
+createCustomErrorClass("TransactionHasBeenValidatedError");
+createCustomErrorClass("TransportExchangeTimeoutError");
+createCustomErrorClass("DeviceShouldStayInApp");
+createCustomErrorClass("WebsocketConnectionError");
+createCustomErrorClass("WebsocketConnectionFailed");
+createCustomErrorClass("WrongDeviceForAccount");
+createCustomErrorClass("WrongDeviceForAccountPayout");
+createCustomErrorClass("MissingSwapPayloadParamaters");
+createCustomErrorClass("WrongDeviceForAccountRefund");
+createCustomErrorClass("WrongAppForCurrency");
+createCustomErrorClass("ETHAddressNonEIP");
+createCustomErrorClass("CantScanQRCode");
+createCustomErrorClass("FeeNotLoaded");
+createCustomErrorClass("FeeNotLoadedSwap");
+createCustomErrorClass("FeeRequired");
+createCustomErrorClass("FeeTooHigh");
+createCustomErrorClass("PendingOperation");
+createCustomErrorClass("SyncError");
+createCustomErrorClass("PairingFailed");
+createCustomErrorClass("PeerRemovedPairing");
+createCustomErrorClass("GenuineCheckFailed");
+createCustomErrorClass("LedgerAPI4xx");
+createCustomErrorClass("LedgerAPI5xx");
+const FirmwareOrAppUpdateRequired = createCustomErrorClass("FirmwareOrAppUpdateRequired");
+createCustomErrorClass("ReplacementTransactionUnderpriced");
+createCustomErrorClass("OpReturnSizeLimit");
+createCustomErrorClass("DustLimit");
+createCustomErrorClass("ConcordiumInsufficientFunds");
+createCustomErrorClass("ConcordiumMemoTooLong");
+createCustomErrorClass("ConcordiumPairingExpiredError");
+createCustomErrorClass("ConcordiumSessionExpiredError");
+createCustomErrorClass("LanguageNotFound");
+createCustomErrorClass("NoDBPathGiven");
+createCustomErrorClass("DBWrongPassword");
+createCustomErrorClass("DBNotReset");
+createCustomErrorClass("SequenceNumberError");
+createCustomErrorClass("DisabledTransactionBroadcastError");
+/**
+* Type of a Transport error used to represent all equivalent errors coming from all possible implementation of Transport
+*/
+var HwTransportErrorType;
+(function(HwTransportErrorType) {
+	HwTransportErrorType["Unknown"] = "Unknown";
+	HwTransportErrorType["LocationServicesDisabled"] = "LocationServicesDisabled";
+	HwTransportErrorType["LocationServicesUnauthorized"] = "LocationServicesUnauthorized";
+	HwTransportErrorType["BluetoothScanStartFailed"] = "BluetoothScanStartFailed";
+})(HwTransportErrorType || (HwTransportErrorType = {}));
+/**
+* TransportError is used for any generic transport errors.
+* e.g. Error thrown when data received by exchanges are incorrect or if exchanged failed to communicate with the device for various reason.
+*/
+var TransportError = class extends Error {
+	id;
+	constructor(message, id) {
+		const name = "TransportError";
+		super(message || name);
+		this.name = name;
+		this.message = message;
+		this.stack = new Error(message).stack;
+		this.id = id;
+	}
+};
+addCustomErrorDeserializer("TransportError", (e) => new TransportError(e.message, e.id));
+const StatusCodes = {
+	ACCESS_CONDITION_NOT_FULFILLED: 38916,
+	ALGORITHM_NOT_SUPPORTED: 38020,
+	CLA_NOT_SUPPORTED: 28160,
+	CODE_BLOCKED: 38976,
+	CODE_NOT_INITIALIZED: 38914,
+	COMMAND_INCOMPATIBLE_FILE_STRUCTURE: 27009,
+	CONDITIONS_OF_USE_NOT_SATISFIED: 27013,
+	CONTRADICTION_INVALIDATION: 38928,
+	CONTRADICTION_SECRET_CODE_STATUS: 38920,
+	DEVICE_IN_RECOVERY_MODE: 26159,
+	CUSTOM_IMAGE_EMPTY: 26158,
+	FILE_ALREADY_EXISTS: 27273,
+	FILE_NOT_FOUND: 37892,
+	GP_AUTH_FAILED: 25344,
+	HALTED: 28586,
+	INCONSISTENT_FILE: 37896,
+	INCORRECT_DATA: 27264,
+	INCORRECT_LENGTH: 26368,
+	INCORRECT_P1_P2: 27392,
+	INS_NOT_SUPPORTED: 27904,
+	DEVICE_NOT_ONBOARDED: 27911,
+	DEVICE_NOT_ONBOARDED_2: 26129,
+	INVALID_KCV: 38021,
+	INVALID_OFFSET: 37890,
+	LICENSING: 28482,
+	LOCKED_DEVICE: 21781,
+	MAX_VALUE_REACHED: 38992,
+	MEMORY_PROBLEM: 37440,
+	MISSING_CRITICAL_PARAMETER: 26624,
+	NO_EF_SELECTED: 37888,
+	NOT_ENOUGH_MEMORY_SPACE: 27268,
+	OK: 36864,
+	PIN_REMAINING_ATTEMPTS: 25536,
+	REFERENCED_DATA_NOT_FOUND: 27272,
+	SECURITY_STATUS_NOT_SATISFIED: 27010,
+	TECHNICAL_PROBLEM: 28416,
+	UNKNOWN_APDU: 27906,
+	USER_REFUSED_ON_DEVICE: 21761,
+	NOT_ENOUGH_SPACE: 20738,
+	APP_NOT_FOUND_OR_INVALID_CONTEXT: 20771,
+	INVALID_APP_NAME_LENGTH: 26378,
+	GEN_AES_KEY_FAILED: 21529,
+	INTERNAL_CRYPTO_OPERATION_FAILED: 21530,
+	INTERNAL_COMPUTE_AES_CMAC_FAILED: 21531,
+	ENCRYPT_APP_STORAGE_FAILED: 21532,
+	INVALID_BACKUP_STATE: 26178,
+	PIN_NOT_SET: 21762,
+	INVALID_BACKUP_LENGTH: 26419,
+	INVALID_RESTORE_STATE: 26179,
+	INVALID_CHUNK_LENGTH: 26420,
+	INVALID_BACKUP_HEADER: 26698,
+	SW_BAD_STATE: 45063
+};
+function getAltStatusMessage(code) {
+	switch (code) {
+		case 26368: return "Incorrect length";
+		case 26624: return "Missing critical parameter";
+		case 27010: return "Security not satisfied (dongle locked or have invalid access rights)";
+		case 27013: return "Condition of use not satisfied (denied by the user?)";
+		case 27264: return "Invalid data received";
+		case 27392: return "Invalid parameter received";
+		case 21781: return "Locked device";
+		case 45063: return "Unexpected state on the device";
+	}
+	if (28416 <= code && code <= 28671) return "Internal error, please report";
+}
+/**
+* Error thrown when a device returned a non success status.
+* the error.statusCode is one of the `StatusCodes` exported by this library.
+*/
+var TransportStatusError = class TransportStatusError extends Error {
+	statusCode;
+	statusText;
+	/**
+	* @param statusCode The error status code coming from a Transport implementation
+	* @param options containing:
+	*  - canBeMappedToChildError: enable the mapping of TransportStatusError to an error extending/inheriting from it
+	*  . Ex: LockedDeviceError. Default to true.
+	*/
+	constructor(statusCode, { canBeMappedToChildError = true } = {}) {
+		const statusText = Object.keys(StatusCodes).find((k) => StatusCodes[k] === statusCode) || "UNKNOWN_ERROR";
+		const message = `Ledger device: ${getAltStatusMessage(statusCode) || statusText} (0x${statusCode.toString(16)})`;
+		super(message);
+		this.name = "TransportStatusError";
+		this.statusCode = statusCode;
+		this.statusText = statusText;
+		Object.setPrototypeOf(this, TransportStatusError.prototype);
+		if (canBeMappedToChildError && statusCode === StatusCodes.LOCKED_DEVICE) return new LockedDeviceError(message);
+	}
+};
+var LockedDeviceError = class LockedDeviceError extends TransportStatusError {
+	constructor(message) {
+		super(StatusCodes.LOCKED_DEVICE, { canBeMappedToChildError: false });
+		if (message) this.message = message;
+		this.name = "LockedDeviceError";
+		Object.setPrototypeOf(this, LockedDeviceError.prototype);
+	}
+};
+addCustomErrorDeserializer("TransportStatusError", (e) => new TransportStatusError(e.statusCode));
+//#endregion
+//#region src/device/device-access.ts
+const initialErrorRemapping = (error) => throwError(error && error instanceof TransportStatusError && error.statusCode === 28586 ? new DeviceHalted(error.message) : error instanceof TransportStatusError && error.statusCode === 27392 ? new FirmwareOrAppUpdateRequired(error.message) : error);
+const never = new Promise(() => {});
+const modules = [];
+const registerTransportModule = (module) => {
+	modules.push(module);
+};
+const close = (transport, deviceId) => {
+	for (const m of modules) {
+		const p = m.close?.(transport, deviceId);
+		if (p) return p;
+	}
+	return transport.close();
+};
+const open = (deviceId) => {
+	for (const m of modules) {
+		const p = m.open(deviceId);
+		if (p) return p;
+	}
+	return Promise.reject(/* @__PURE__ */ new Error(`Can't find handler to open ${deviceId}`));
+};
+const transportFinally = (cleanup) => (observable) => Observable.create((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 accessHooks = [];
+const deviceQueues = {};
+const withDevice = (deviceId) => (job) => new Observable((o) => {
+	let unsubscribed;
+	let sub;
+	const deviceQueue = deviceQueues[deviceId] ?? Promise.resolve();
+	const finalize = (transport, cleanups) => close(transport, deviceId).catch(() => {}).then(() => {
+		cleanups.forEach((c) => c());
+	});
+	let finish;
+	deviceQueues[deviceId] = new Promise((resolve) => {
+		finish = resolve;
+	});
+	deviceQueue.then(() => open(deviceId)).then(async (transport) => {
+		if (unsubscribed) return finalize(transport, [finish]);
+		if (transport.requestConnectionPriority && typeof transport.requestConnectionPriority === "function") await transport.requestConnectionPriority("High");
+		return transport;
+	}).catch((e) => {
+		finish();
+		if (e instanceof BluetoothRequired) throw e;
+		if (e instanceof TransportWebUSBGestureRequired) throw e;
+		if (e instanceof TransportInterfaceNotAvailable) throw e;
+		throw new CantOpenDevice(e.message);
+	}).then((transport) => {
+		if (!transport) return;
+		if (unsubscribed) return finalize(transport, [finish]);
+		const cleanups = accessHooks.map((hook) => hook());
+		sub = job(transport).pipe(catchError(initialErrorRemapping), transportFinally(() => finalize(transport, [...cleanups, finish]))).subscribe(o);
+	}).catch((error) => o.error(error));
+	return () => {
+		unsubscribed = true;
+		if (sub) sub.unsubscribe();
+	};
+});
+const WITH_DEVICE_POLLING_DELAY = 500;
+const retryWhileErrors = (acceptError) => (attempts) => attempts.pipe(mergeMap((error) => {
+	if (!acceptError(error)) return throwError(error);
+	return timer(WITH_DEVICE_POLLING_DELAY);
+}));
+const withDevicePolling = (deviceId) => (job, acceptError = () => false) => withDevice(deviceId)(job).pipe(retryWhen(retryWhileErrors(acceptError)));
+//#endregion
+//#region src/device/utils.ts
+const isTransportStatusError = (error) => {
+	return error instanceof TransportStatusError || error instanceof Error && "statusCode" in error && error.message.startsWith("Ledger device:");
+};
+const CANCEL_STATUS_CODES = [
+	27013,
+	45068,
+	45069,
+	45072,
+	45074,
+	45075,
+	21761
+];
+const isDeviceCancelError = (error) => {
+	return isTransportStatusError(error) && CANCEL_STATUS_CODES.includes(error.statusCode);
+};
+//#endregion
+export { DisconnectedDevice as a, APPID_VAULT_ADMINISTRATOR as c, SCRIPT_IDS as d, STR_ROLES as f, withDevicePolling as i, PAGINATED_STATUS as l, isTransportStatusError as n, LockedDeviceError as o, registerTransportModule as r, createApiDevice as s, isDeviceCancelError as t, PATHS as u };
+
+//# sourceMappingURL=device-B8Fww8_6.js.map