@trezor/connect 9.6.4 → 9.6.5-beta.1

package/lib/types/api/monero/index.js

@@ -0,0 +1,170 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MoneroSignedTransaction = exports.MoneroRingCtSig = exports.MoneroSignTransaction = exports.MoneroTransactionData = exports.MoneroTransactionRsigData = exports.MoneroTransactionDestinationEntry = exports.MoneroAccountPublicAddress = exports.MoneroTransactionSourceEntry = exports.MoneroMultisigKLRki = exports.MoneroOutputEntry = exports.MoneroKeyImageSyncResult = exports.MoneroExportedKeyImage = exports.MoneroKeyImageSync = exports.MoneroSubAddressIndicesList = exports.MoneroTransferDetails = exports.MoneroWatchKey = exports.MoneroGetWatchKey = exports.MoneroGetAddress = void 0;
+const schema_utils_1 = require("@trezor/schema-utils");
+const constants_1 = require("../../../constants");
+const params_1 = require("../../params");
+exports.MoneroGetAddress = schema_utils_1.Type.Object({
+    path: params_1.DerivationPath,
+    address: schema_utils_1.Type.Optional(schema_utils_1.Type.String()),
+    showOnTrezor: schema_utils_1.Type.Optional(schema_utils_1.Type.Boolean()),
+    networkType: schema_utils_1.Type.Optional(constants_1.PROTO.EnumMoneroNetworkType),
+    account: schema_utils_1.Type.Optional(schema_utils_1.Type.Number()),
+    minor: schema_utils_1.Type.Optional(schema_utils_1.Type.Number()),
+    paymentId: schema_utils_1.Type.Optional(schema_utils_1.Type.String()),
+    chunkify: schema_utils_1.Type.Optional(schema_utils_1.Type.Boolean()),
+}, {
+    $id: 'MoneroGetAddress',
+});
+exports.MoneroGetWatchKey = schema_utils_1.Type.Object({
+    path: params_1.DerivationPath,
+    networkType: schema_utils_1.Type.Optional(constants_1.PROTO.EnumMoneroNetworkType),
+}, {
+    $id: 'MoneroGetWatchKey',
+});
+exports.MoneroWatchKey = schema_utils_1.Type.Object({
+    watch_key: schema_utils_1.Type.String(),
+    address: schema_utils_1.Type.String(),
+}, {
+    $id: 'MoneroWatchKey',
+});
+exports.MoneroTransferDetails = schema_utils_1.Type.Object({
+    out_key: schema_utils_1.Type.String(),
+    tx_pub_key: schema_utils_1.Type.String(),
+    additional_tx_pub_keys: schema_utils_1.Type.Optional(schema_utils_1.Type.Union([schema_utils_1.Type.Array(schema_utils_1.Type.String()), schema_utils_1.Type.String()])),
+    internal_output_index: schema_utils_1.Type.Number(),
+    sub_addr_major: schema_utils_1.Type.Optional(schema_utils_1.Type.Number()),
+    sub_addr_minor: schema_utils_1.Type.Optional(schema_utils_1.Type.Number()),
+}, {
+    $id: 'MoneroTransferDetails',
+});
+exports.MoneroSubAddressIndicesList = schema_utils_1.Type.Object({
+    account: schema_utils_1.Type.Number(),
+    minor_indices: schema_utils_1.Type.Array(schema_utils_1.Type.Number()),
+}, {
+    $id: 'MoneroSubAddressIndicesList',
+});
+exports.MoneroKeyImageSync = schema_utils_1.Type.Object({
+    path: params_1.DerivationPath,
+    networkType: schema_utils_1.Type.Optional(constants_1.PROTO.EnumMoneroNetworkType),
+    subs: schema_utils_1.Type.Optional(schema_utils_1.Type.Array(exports.MoneroSubAddressIndicesList)),
+    tdis: schema_utils_1.Type.Array(exports.MoneroTransferDetails),
+}, {
+    $id: 'MoneroKeyImageSync',
+});
+exports.MoneroExportedKeyImage = schema_utils_1.Type.Object({
+    iv: schema_utils_1.Type.String(),
+    key_image: schema_utils_1.Type.String(),
+}, {
+    $id: 'MoneroExportedKeyImage',
+});
+exports.MoneroKeyImageSyncResult = schema_utils_1.Type.Object({
+    key_images: schema_utils_1.Type.Array(exports.MoneroExportedKeyImage),
+    signature: schema_utils_1.Type.String(),
+}, {
+    $id: 'MoneroKeyImageSyncResult',
+});
+exports.MoneroOutputEntry = schema_utils_1.Type.Object({
+    idx: schema_utils_1.Type.Number(),
+    key: schema_utils_1.Type.Object({
+        dest: schema_utils_1.Type.String(),
+        commitment: schema_utils_1.Type.String(),
+    }),
+}, {
+    $id: 'MoneroOutputEntry',
+});
+exports.MoneroMultisigKLRki = schema_utils_1.Type.Object({
+    K: schema_utils_1.Type.Optional(schema_utils_1.Type.String()),
+    L: schema_utils_1.Type.Optional(schema_utils_1.Type.String()),
+    R: schema_utils_1.Type.Optional(schema_utils_1.Type.String()),
+    ki: schema_utils_1.Type.Optional(schema_utils_1.Type.String()),
+}, {
+    $id: 'MoneroMultisigKLRki',
+});
+exports.MoneroTransactionSourceEntry = schema_utils_1.Type.Object({
+    outputs: schema_utils_1.Type.Array(exports.MoneroOutputEntry),
+    real_output: schema_utils_1.Type.Number(),
+    real_out_tx_key: schema_utils_1.Type.String(),
+    real_out_additional_tx_keys: schema_utils_1.Type.Array(schema_utils_1.Type.String()),
+    real_output_in_tx_index: schema_utils_1.Type.Number(),
+    amount: schema_utils_1.Type.Number(),
+    rct: schema_utils_1.Type.Boolean(),
+    mask: schema_utils_1.Type.String(),
+    subaddr_minor: schema_utils_1.Type.Number(),
+    multisig_kLRki: schema_utils_1.Type.Optional(exports.MoneroMultisigKLRki),
+}, {
+    $id: 'MoneroTransactionSourceEntry',
+});
+exports.MoneroAccountPublicAddress = schema_utils_1.Type.Object({
+    spend_public_key: schema_utils_1.Type.String(),
+    view_public_key: schema_utils_1.Type.String(),
+});
+exports.MoneroTransactionDestinationEntry = schema_utils_1.Type.Object({
+    amount: schema_utils_1.Type.Number(),
+    addr: exports.MoneroAccountPublicAddress,
+    is_subaddress: schema_utils_1.Type.Boolean(),
+    original: schema_utils_1.Type.String(),
+    is_integrated: schema_utils_1.Type.Boolean(),
+}, {
+    $id: 'MoneroTransactionDestinationEntry',
+});
+exports.MoneroTransactionRsigData = schema_utils_1.Type.Object({
+    rsig_type: schema_utils_1.Type.Number(),
+    offload_type: schema_utils_1.Type.Optional(schema_utils_1.Type.Number()),
+    grouping: schema_utils_1.Type.Array(schema_utils_1.Type.Number()),
+    mask: schema_utils_1.Type.Optional(schema_utils_1.Type.String()),
+    rsig: schema_utils_1.Type.Optional(schema_utils_1.Type.String()),
+    rsig_parts: schema_utils_1.Type.Optional(schema_utils_1.Type.Array(schema_utils_1.Type.String())),
+    bp_version: schema_utils_1.Type.Number(),
+}, {
+    $id: 'MoneroTransactionRsigData',
+});
+exports.MoneroTransactionData = schema_utils_1.Type.Object({
+    version: schema_utils_1.Type.Number(),
+    payment_id: schema_utils_1.Type.Optional(schema_utils_1.Type.String()),
+    unlock_time: schema_utils_1.Type.Number(),
+    outputs: schema_utils_1.Type.Array(exports.MoneroTransactionDestinationEntry),
+    change_dts: schema_utils_1.Type.Optional(exports.MoneroTransactionDestinationEntry),
+    num_inputs: schema_utils_1.Type.Number(),
+    mixin: schema_utils_1.Type.Number(),
+    fee: schema_utils_1.Type.Number(),
+    account: schema_utils_1.Type.Number(),
+    rsig_data: exports.MoneroTransactionRsigData,
+    minor_indices: schema_utils_1.Type.Optional(schema_utils_1.Type.Array(schema_utils_1.Type.Number())),
+    integrated_indices: schema_utils_1.Type.Optional(schema_utils_1.Type.Array(schema_utils_1.Type.Number())),
+    client_version: schema_utils_1.Type.Number(),
+    hard_fork: schema_utils_1.Type.Number(),
+    monero_version: schema_utils_1.Type.Optional(schema_utils_1.Type.String()),
+    chunkify: schema_utils_1.Type.Optional(schema_utils_1.Type.Boolean()),
+}, {
+    $id: 'MoneroTransactionData',
+});
+exports.MoneroSignTransaction = schema_utils_1.Type.Object({
+    path: params_1.DerivationPath,
+    networkType: constants_1.PROTO.EnumMoneroNetworkType,
+    tsx_data: exports.MoneroTransactionData,
+    inputs: schema_utils_1.Type.Array(exports.MoneroTransactionSourceEntry),
+}, {
+    $id: 'MoneroSignTransaction',
+});
+exports.MoneroRingCtSig = schema_utils_1.Type.Object({
+    txn_fee: schema_utils_1.Type.Optional(schema_utils_1.Type.Number()),
+    message: schema_utils_1.Type.Optional(schema_utils_1.Type.String()),
+    rv_type: schema_utils_1.Type.Optional(schema_utils_1.Type.Number()),
+}, {
+    $id: 'MoneroRingCtSig',
+});
+exports.MoneroSignedTransaction = schema_utils_1.Type.Object({
+    signatures: schema_utils_1.Type.Array(schema_utils_1.Type.String()),
+    tx_prefix_hash: schema_utils_1.Type.String(),
+    rv: exports.MoneroRingCtSig,
+    cout_key: schema_utils_1.Type.Optional(schema_utils_1.Type.String()),
+    salt: schema_utils_1.Type.Optional(schema_utils_1.Type.String()),
+    rand_mult: schema_utils_1.Type.Optional(schema_utils_1.Type.String()),
+    tx_enc_keys: schema_utils_1.Type.Optional(schema_utils_1.Type.String()),
+    opening_key: schema_utils_1.Type.Optional(schema_utils_1.Type.String()),
+    pseudo_outs: schema_utils_1.Type.Array(schema_utils_1.Type.String()),
+}, {
+    $id: 'MoneroSignedTransaction',
+});
+//# sourceMappingURL=index.js.map

package/lib/types/api/moneroGetAddress.d.ts

@@ -0,0 +1,5 @@
+import { MoneroAddress, MoneroGetAddress as MoneroGetAddressParams } from './monero';
+import type { BundledParams, Params, Response } from '../params';
+export declare function moneroGetAddress(params: Params<MoneroGetAddressParams>): Response<MoneroAddress>;
+export declare function moneroGetAddress(params: BundledParams<MoneroGetAddressParams>): Response<MoneroAddress[]>;
+//# sourceMappingURL=moneroGetAddress.d.ts.map

package/lib/types/api/moneroGetAddress.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=moneroGetAddress.js.map

package/lib/types/api/moneroGetWatchKey.d.ts

@@ -0,0 +1,4 @@
+import type { Params, Response } from '../params';
+import type { MoneroGetWatchKey, MoneroWatchKey } from './monero';
+export declare function moneroGetWatchKey(params: Params<MoneroGetWatchKey>): Response<MoneroWatchKey>;
+//# sourceMappingURL=moneroGetWatchKey.d.ts.map

package/lib/types/api/moneroGetWatchKey.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=moneroGetWatchKey.js.map

package/lib/types/api/moneroKeyImageSync.d.ts

@@ -0,0 +1,4 @@
+import type { Params, Response } from '../params';
+import type { MoneroKeyImageSync, MoneroKeyImageSyncResult } from './monero';
+export declare function moneroKeyImageSync(params: Params<MoneroKeyImageSync>): Response<MoneroKeyImageSyncResult>;
+//# sourceMappingURL=moneroKeyImageSync.d.ts.map

package/lib/types/api/moneroKeyImageSync.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=moneroKeyImageSync.js.map

package/lib/types/api/moneroSignTransaction.d.ts

@@ -0,0 +1,4 @@
+import type { Params, Response } from '../params';
+import type { MoneroSignTransaction, MoneroSignedTransaction } from './monero';
+export declare function moneroSignTransaction(params: Params<MoneroSignTransaction>): Response<MoneroSignedTransaction>;
+//# sourceMappingURL=moneroSignTransaction.d.ts.map

package/lib/types/api/moneroSignTransaction.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=moneroSignTransaction.js.map

package/lib/types/firmware.d.ts

@@ -6,7 +6,7 @@ export type FirmwareRange = Record<DeviceModelInternal, {
 export type BinaryInfo = {
     binary: ArrayBuffer;
     binaryVersion: VersionArray;
-    releaseVersion?: VersionArray;
+    release?: FirmwareRelease;
 };
 export type FirmwareReleaseConfigInfo = {
     firmwareType: FirmwareType;

package/lib/types/index.d.ts

@@ -11,6 +11,7 @@ export * from './api/bitcoin';
 export * from './api/eos';
 export * from './api/ripple';
 export * from './api/ethereum';
+export * from './api/monero';
 export * from './api/solana';
 export * from './api/stellar';
 export * from './api/tezos';

package/lib/types/index.js

@@ -15,6 +15,7 @@ tslib_1.__exportStar(require("./api/bitcoin"), exports);
 tslib_1.__exportStar(require("./api/eos"), exports);
 tslib_1.__exportStar(require("./api/ripple"), exports);
 tslib_1.__exportStar(require("./api/ethereum"), exports);
+tslib_1.__exportStar(require("./api/monero"), exports);
 tslib_1.__exportStar(require("./api/solana"), exports);
 tslib_1.__exportStar(require("./api/stellar"), exports);
 tslib_1.__exportStar(require("./api/tezos"), exports);

package/lib/types/settings.d.ts

@@ -62,11 +62,11 @@ export interface ConnectSettingsInternal {
 }
 export interface ConnectSettingsWeb {
     hostLabel?: string;
-    coreMode?: 'auto' | 'popup' | 'iframe' | 'deeplink' | 'suite-desktop';
+    coreMode?: 'auto' | 'popup' | 'iframe' | 'deeplink' | 'suite-desktop' | 'suite-web';
 }
 export interface ConnectSettingsWebextension {
     _extendWebextensionLifetime?: boolean;
-    coreMode?: 'auto' | 'popup' | 'suite-desktop';
+    coreMode?: 'auto' | 'popup' | 'suite-desktop' | 'suite-web';
 }
 export interface ConnectSettingsMobile {
     deeplinkUrl: string;

package/lib/utils/uiPromiseManager.js

@@ -11,6 +11,11 @@ const createUiPromiseManager = (interactionTimeout) => {
             ...(0, utils_1.createDeferred)(promiseEvent),
             device,
         };
+        const existing = _uiPromises.findIndex(p => p.id === promiseEvent);
+        if (existing >= 0) {
+            console.warn(`UiPromise '${promiseEvent}' already exists.`);
+            _uiPromises.splice(existing, 1);
+        }
         _uiPromises.push(uiPromise);
         interactionTimeout();
         return uiPromise;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trezor/connect",
-  "version": "9.6.4",
+  "version": "9.6.5-beta.1",
   "author": "Trezor <info@trezor.io>",
   "homepage": "https://github.com/trezor/trezor-suite/tree/develop/packages/connect",
   "description": "High-level javascript interface for Trezor hardware wallet.",
@@ -79,21 +79,22 @@
     "@solana-program/token": "^0.5.1",
     "@solana-program/token-2022": "^0.4.2",
     "@solana/kit": "^2.3.0",
-    "@trezor/blockchain-link": "2.5.4",
-    "@trezor/blockchain-link-types": "1.4.4",
-    "@trezor/blockchain-link-utils": "1.4.4",
-    "@trezor/connect-analytics": "1.3.6",
-    "@trezor/connect-common": "0.4.4",
+    "@trezor/blockchain-link": "2.5.5-beta.1",
+    "@trezor/blockchain-link-types": "1.4.5-beta.1",
+    "@trezor/blockchain-link-utils": "1.4.5-beta.1",
+    "@trezor/connect-analytics": "1.3.7-beta.1",
+    "@trezor/connect-common": "0.4.5-beta.1",
     "@trezor/crypto-utils": "1.1.5",
-    "@trezor/device-utils": "1.1.4",
+    "@trezor/device-authenticity": "1.0.0",
+    "@trezor/device-utils": "1.1.5-beta.1",
     "@trezor/env-utils": "^1.4.3",
-    "@trezor/protobuf": "1.4.4",
-    "@trezor/protocol": "1.2.10",
+    "@trezor/protobuf": "1.4.5-beta.1",
+    "@trezor/protocol": "1.2.11-beta.1",
     "@trezor/schema-utils": "1.3.4",
-    "@trezor/transport": "1.5.4",
+    "@trezor/transport": "1.5.5-beta.1",
     "@trezor/type-utils": "1.1.9",
-    "@trezor/utils": "9.4.4",
-    "@trezor/utxo-lib": "2.4.4",
+    "@trezor/utils": "9.4.5-beta.1",
+    "@trezor/utxo-lib": "2.4.5-beta.1",
     "blakejs": "^1.2.1",
     "bs58": "^6.0.0",
     "bs58check": "^4.0.0",
@@ -122,7 +123,7 @@
     "ts-node": "^10.9.2",
     "tsx": "^4.20.3",
     "web3-utils": "^4.3.2",
-    "webpack": "5.100.0",
+    "webpack": "5.102.1",
     "ws": "^8.18.0"
   },
   "peerDependencies": {

package/lib/api/firmware/verifyAuthenticityProof.d.ts

@@ -1,15 +0,0 @@
-import { PROTO } from '../../constants';
-import { DeviceAuthenticityBlacklistConfig } from '../../data/deviceAuthenticityBlacklistConfig';
-import { DeviceAuthenticityConfig } from '../../data/deviceAuthenticityConfigTypes';
-import { AuthenticateDeviceResult } from '../../types/api/authenticateDevice';
-interface AuthenticityProofData extends PROTO.AuthenticityProof {
-    challenge: Buffer;
-    config: DeviceAuthenticityConfig;
-    blacklistConfig: DeviceAuthenticityBlacklistConfig;
-    allowDebugKeys?: boolean;
-    deviceModel: keyof typeof PROTO.DeviceModelInternal;
-}
-export declare const getRandomChallenge: () => Buffer<ArrayBufferLike>;
-export declare const verifyAuthenticityProof: ({ optiga_certificates, optiga_signature, challenge, config, blacklistConfig, allowDebugKeys, deviceModel, }: AuthenticityProofData) => Promise<AuthenticateDeviceResult>;
-export {};
-//# sourceMappingURL=verifyAuthenticityProof.d.ts.map

package/lib/api/firmware/verifyAuthenticityProof.js

@@ -1,133 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.verifyAuthenticityProof = exports.getRandomChallenge = void 0;
-const tslib_1 = require("tslib");
-const crypto = tslib_1.__importStar(require("crypto"));
-const crypto_utils_1 = require("@trezor/crypto-utils");
-const utils_1 = require("@trezor/utils");
-const x509certificate_1 = require("./x509certificate");
-const verifySignature = async (rawKey, data, signature) => {
-    const signer = crypto.createVerify('sha256');
-    signer.update(Buffer.from(data));
-    const SubtleCrypto = (0, crypto_utils_1.getSubtleCrypto)();
-    const ecPubKey = await SubtleCrypto.importKey('raw', rawKey, { name: 'ECDSA', namedCurve: 'P-256' }, true, ['verify']);
-    const spkiPubKey = await SubtleCrypto.exportKey('spki', ecPubKey);
-    const key = `-----BEGIN PUBLIC KEY-----\n${Buffer.from(spkiPubKey).toString('base64')}\n-----END PUBLIC KEY-----`;
-    return signer.verify({ key }, Buffer.from(signature));
-};
-const getRandomChallenge = () => crypto.randomBytes(32);
-exports.getRandomChallenge = getRandomChallenge;
-const validateCaCertExtensions = (cert, pathLen) => {
-    let hasKeyUsage, hasBasicConstraints = false;
-    cert.tbsCertificate.extensions.forEach(ext => {
-        if (ext.key === 'keyUsage') {
-            if (ext.keyCertSign !== '1') {
-                throw new Error(`CA keyCertSign not set`);
-            }
-            hasKeyUsage = true;
-        }
-        else if (ext.key === 'basicConstraints') {
-            if (!ext.cA) {
-                throw new Error(`CA basicConstraints.cA not set`);
-            }
-            if (typeof ext.pathLenConstraint != 'number') {
-                throw new Error('CA basicConstraints.pathLenConstraint not set');
-            }
-            if (ext.pathLenConstraint < pathLen) {
-                throw new Error('Issuer was not permitted to issue certificate');
-            }
-            hasBasicConstraints = true;
-        }
-        else if (ext.critical) {
-            throw new Error(`Unknown critical extension ${ext.key} in CA certificate`);
-        }
-    });
-    if (!hasKeyUsage || !hasBasicConstraints) {
-        throw new Error(`CA missing extensions keyUsage: ${hasKeyUsage}, basicConstraints: ${hasBasicConstraints}`);
-    }
-};
-const verifyAuthenticityProof = async ({ optiga_certificates, optiga_signature, challenge, config, blacklistConfig, allowDebugKeys, deviceModel, }) => {
-    const modelConfig = config[deviceModel];
-    if (!modelConfig) {
-        throw new Error(`Pubkeys for ${deviceModel} not found in config`);
-    }
-    const { debug } = modelConfig;
-    const { blacklistedCaPubKeys, debug: debugBlacklist } = blacklistConfig;
-    const [deviceCert, caCert] = optiga_certificates.map((c, i) => {
-        const cert = (0, x509certificate_1.parseCertificate)(new Uint8Array(Buffer.from(c, 'hex')));
-        if (i === 0) {
-            return cert;
-        }
-        validateCaCertExtensions(cert, i - 1);
-        return cert;
-    });
-    const caPubKey = Buffer.from(caCert.tbsCertificate.subjectPublicKeyInfo.bits.bytes).toString('hex');
-    const rootPubKeys = allowDebugKeys
-        ? modelConfig.rootPubKeys.concat(debug?.rootPubKeys || [])
-        : modelConfig.rootPubKeys;
-    const isCertSignedByRootPubkey = await Promise.all(rootPubKeys.map(rootPubKey => verifySignature(Buffer.from(rootPubKey, 'hex'), caCert.tbsCertificate.asn1.raw, caCert.signatureValue.bits.bytes)));
-    const rootPubKeyIndex = isCertSignedByRootPubkey.findIndex(valid => !!valid);
-    const rootPubKey = rootPubKeys[rootPubKeyIndex];
-    const isDebugRootPubKey = debug?.rootPubKeys.includes(rootPubKey);
-    const caCertValidityFrom = caCert.tbsCertificate.validity.from.getTime();
-    if (caCertValidityFrom > new Date().getTime()) {
-        throw new Error(`CA validity from ${caCertValidityFrom} cant't be in the future!`);
-    }
-    if (!rootPubKey) {
-        return {
-            valid: false,
-            caPubKey,
-            error: 'ROOT_PUBKEY_NOT_FOUND',
-        };
-    }
-    const [subject] = deviceCert.tbsCertificate.subject;
-    if (!subject.parameters || subject.algorithm !== '2.5.4.3') {
-        throw new Error('Missing certificate subject');
-    }
-    const subjectValue = Buffer.from(subject.parameters.asn1.contents.subarray(0, 4)).toString();
-    if (subjectValue !== deviceModel) {
-        return {
-            valid: false,
-            caPubKey,
-            error: 'INVALID_DEVICE_MODEL',
-        };
-    }
-    const isDeviceCertValid = await verifySignature(Buffer.from(caCert.tbsCertificate.subjectPublicKeyInfo.bits.bytes), deviceCert.tbsCertificate.asn1.raw, deviceCert.signatureValue.bits.bytes);
-    const challengePrefix = Buffer.from('AuthenticateDevice:');
-    const prefixedChallenge = Buffer.concat([
-        utils_1.bufferUtils.getChunkSize(challengePrefix.length),
-        challengePrefix,
-        utils_1.bufferUtils.getChunkSize(challenge.length),
-        challenge,
-    ]);
-    const isSignatureValid = await verifySignature(Buffer.from(deviceCert.tbsCertificate.subjectPublicKeyInfo.bits.bytes), prefixedChallenge, (0, x509certificate_1.fixSignature)(Buffer.from(optiga_signature, 'hex')));
-    if (rootPubKey && isDeviceCertValid && isSignatureValid) {
-        if ((!isDebugRootPubKey && blacklistedCaPubKeys.includes(caPubKey)) ||
-            (isDebugRootPubKey && debugBlacklist?.blacklistedCaPubKeys.includes(caPubKey))) {
-            return {
-                valid: false,
-                caPubKey,
-                error: 'CA_PUBKEY_BLACKLISTED',
-            };
-        }
-        return {
-            valid: true,
-            caPubKey,
-            debugKey: isDebugRootPubKey,
-        };
-    }
-    if (!isDeviceCertValid) {
-        return {
-            valid: false,
-            caPubKey,
-            error: 'INVALID_DEVICE_CERTIFICATE',
-        };
-    }
-    return {
-        valid: false,
-        caPubKey,
-        error: 'INVALID_DEVICE_SIGNATURE',
-    };
-};
-exports.verifyAuthenticityProof = verifyAuthenticityProof;
-//# sourceMappingURL=verifyAuthenticityProof.js.map

package/lib/api/firmware/x509certificate.d.ts

@@ -1,88 +0,0 @@
-interface Asn1 {
-    cls: number;
-    tag: number;
-    structured: boolean;
-    byteLength: number;
-    contents: Uint8Array;
-    raw: Uint8Array;
-}
-type Oid = `${number}.${number}.${number}.${number}`;
-type Extension = {
-    key: 'keyUsage';
-    critical?: boolean;
-    keyCertSign: '0' | '1';
-} | {
-    key: 'basicConstraints';
-    critical?: boolean;
-    cA: boolean;
-    pathLenConstraint?: number;
-} | (Asn1 & {
-    key: Oid;
-    critical?: boolean;
-});
-export declare const fixSignature: (byteArray: Uint8Array) => Uint8Array<ArrayBuffer>;
-export declare const parseName: (asn1: Asn1) => {
-    asn1: Asn1;
-    algorithm: `${number}.${number}.${number}.${number}`;
-    parameters: {
-        asn1: Asn1;
-    } | null;
-}[];
-export declare const parseCertificate: (byteArray: Uint8Array) => {
-    asn1: Asn1;
-    tbsCertificate: {
-        asn1: Asn1;
-        version: Asn1;
-        serialNumber: Asn1;
-        signature: {
-            asn1: Asn1;
-            algorithm: `${number}.${number}.${number}.${number}`;
-            parameters: {
-                asn1: Asn1;
-            } | null;
-        };
-        issuer: Asn1;
-        validity: {
-            from: Date;
-            to: Date;
-        };
-        subject: {
-            asn1: Asn1;
-            algorithm: `${number}.${number}.${number}.${number}`;
-            parameters: {
-                asn1: Asn1;
-            } | null;
-        }[];
-        subjectPublicKeyInfo: {
-            asn1: Asn1;
-            algorithm: {
-                asn1: Asn1;
-                algorithm: `${number}.${number}.${number}.${number}`;
-                parameters: {
-                    asn1: Asn1;
-                } | null;
-            };
-            bits: {
-                unusedBits: number;
-                bytes: Uint8Array<ArrayBufferLike>;
-            };
-        };
-        extensions: Extension[];
-    };
-    signatureAlgorithm: {
-        asn1: Asn1;
-        algorithm: `${number}.${number}.${number}.${number}`;
-        parameters: {
-            asn1: Asn1;
-        } | null;
-    };
-    signatureValue: {
-        asn1: Asn1;
-        bits: {
-            unusedBits: number;
-            bytes: Uint8Array<ArrayBuffer>;
-        };
-    };
-};
-export {};
-//# sourceMappingURL=x509certificate.d.ts.map