@trezor/connect 9.6.4-beta.1 → 9.6.5-beta.1

package/CHANGELOG.md

@@ -1,17 +1,28 @@
 |             Package              | Stable |    Canary    |
 | :------------------------------: | :----: | :----------: |
-|       npm @trezor/connect        | 9.6.3  | 9.6.4-beta.1 |
-|     npm @trezor/connect-web      | 9.6.3  | 9.6.4-beta.1 |
-| npm @trezor/connect-webextension | 9.6.3  | 9.6.4-beta.1 |
-|    npm @trezor/connect-mobile    | 9.6.3  | 9.6.4-beta.1 |
+|       npm @trezor/connect        | 9.6.4  | 9.6.5-beta.1 |
+|     npm @trezor/connect-web      | 9.6.4  | 9.6.5-beta.1 |
+| npm @trezor/connect-webextension | 9.6.4  | 9.6.5-beta.1 |
+|    npm @trezor/connect-mobile    | 9.6.4  | 9.6.5-beta.1 |
 
 |     Deployment     | Stable |    Canary    |
 | :----------------: | :----: | :----------: |
-| connect.trezor.io/ | 9.6.3  | 9.6.4-beta.1 |
+| connect.trezor.io/ | 9.6.4  | 9.6.5-beta.1 |
 
 Use the persistent link [connect.trezor.io/9](https://connect.trezor.io/9/) to access the latest stable version of Connect Explorer.
 
-# 9.6.4-beta.1
+# 9.6.5-beta.1
+
+This release introduces Monero support in Trezor Connect and enhances Trezor Suite Web for use as a Trezor Connect popup.
+
+    feat(connect-web): in core-in-suite-desktop handle permission error (41da933)
+    feat(connect): monero support (7e4e42c)
+    feat(connect-webextension): suite web popup implementation for webextension (175e40c)
+    feat(connect): use existing message channels for suite web (314464a)
+    feat(connect-explorer): suite web popup setting (9252ce3)
+    feat(connect): suite web popup implementation (6bafb1e)
+
+# 9.6.4
 
 This release primarily introduces support for the new Trezor device and enhancements to the transport API, including a new API type:
 

package/README.md

@@ -1,6 +1,6 @@
 # @trezor/connect
 
-API version 9.6.4-beta.1
+API version 9.6.5-beta.1
 
 [![Build Status](https://github.com/trezor/trezor-suite/actions/workflows/test-connect.yml/badge.svg)](https://github.com/trezor/trezor-suite/actions/workflows/test-connect.yml)
 [![NPM](https://img.shields.io/npm/v/@trezor/connect.svg)](https://www.npmjs.org/package/@trezor/connect)

package/lib/api/authenticateDevice.d.ts

@@ -1,7 +1,11 @@
+import { VerifyAuthenticityProofResult } from '@trezor/device-authenticity';
 import { AbstractMethod } from '../core/AbstractMethod';
 import { AuthenticateDeviceParams } from '../types/api/authenticateDevice';
 export default class AuthenticateDevice extends AbstractMethod<'authenticateDevice', AuthenticateDeviceParams> {
     init(): void;
-    run(): Promise<import("../types/api/authenticateDevice").AuthenticateDeviceResult>;
+    run(): Promise<{
+        optigaResult: VerifyAuthenticityProofResult;
+        tropicResult: VerifyAuthenticityProofResult | null;
+    }>;
 }
 //# sourceMappingURL=authenticateDevice.d.ts.map

package/lib/api/authenticateDevice.js

@@ -1,12 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+const device_authenticity_1 = require("@trezor/device-authenticity");
 const schema_utils_1 = require("@trezor/schema-utils");
 const AbstractMethod_1 = require("../core/AbstractMethod");
-const deviceAuthenticityBlacklist_1 = require("../data/deviceAuthenticityBlacklist");
 const events_1 = require("../events");
 const paramsValidator_1 = require("./common/paramsValidator");
-const deviceAuthenticityConfig_1 = require("../data/deviceAuthenticityConfig");
-const verifyAuthenticityProof_1 = require("./firmware/verifyAuthenticityProof");
 const authenticateDevice_1 = require("../types/api/authenticateDevice");
 class AuthenticateDevice extends AbstractMethod_1.AbstractMethod {
     init() {
@@ -25,23 +23,44 @@ class AuthenticateDevice extends AbstractMethod_1.AbstractMethod {
         };
     }
     async run() {
-        const challenge = (0, verifyAuthenticityProof_1.getRandomChallenge)();
+        const challenge = (0, device_authenticity_1.getRandomChallenge)();
         const { message } = await this.device
             .getCommands()
             .typedCall('AuthenticateDevice', 'AuthenticityProof', {
             challenge: challenge.toString('hex'),
         });
-        const config = this.params.config || deviceAuthenticityConfig_1.deviceAuthenticityConfig;
-        const blacklistConfig = this.params.blacklistConfig || deviceAuthenticityBlacklist_1.deviceAuthenticityBlacklist;
-        const valid = await (0, verifyAuthenticityProof_1.verifyAuthenticityProof)({
-            ...message,
+        const config = this.params.config || device_authenticity_1.deviceAuthenticityConfig;
+        const blacklistConfig = this.params.blacklistConfig || device_authenticity_1.deviceAuthenticityBlacklistConfig;
+        const commonParams = {
             challenge,
+            deviceModel: this.device.features.internal_model,
+            allowDebugKeys: this.params.allowDebugKeys,
             config,
             blacklistConfig,
-            allowDebugKeys: this.params.allowDebugKeys,
-            deviceModel: this.device.features.internal_model,
-        });
-        return valid;
+        };
+        const getOptigaResult = async () => {
+            const { optiga_signature: signature, optiga_certificates: certificates } = message;
+            const isAvailable = signature !== undefined && certificates.length > 0;
+            if (isAvailable) {
+                return await (0, device_authenticity_1.verifyAuthenticityProof)({ ...commonParams, certificates, signature });
+            }
+            return { valid: false, error: 'RESPONSE_PAYLOAD_MISSING' };
+        };
+        const getTropicResult = async () => {
+            const { tropic_signature: signature, tropic_certificates: certificates } = message;
+            const isAvailable = signature !== undefined && certificates.length > 0;
+            const isRequired = !this.device.unavailableCapabilities['tropicDeviceAuthentication'];
+            if (isAvailable) {
+                return await (0, device_authenticity_1.verifyAuthenticityProof)({ ...commonParams, certificates, signature });
+            }
+            if (isRequired) {
+                return { valid: false, error: 'RESPONSE_PAYLOAD_MISSING' };
+            }
+            return null;
+        };
+        const optigaResult = await getOptigaResult();
+        const tropicResult = await getTropicResult();
+        return { optigaResult, tropicResult };
     }
 }
 exports.default = AuthenticateDevice;

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

@@ -1,11 +1,11 @@
-import { VersionArray } from '@trezor/device-utils';
+import { FirmwareRelease } from '@trezor/device-utils';
 import { BinaryInfo } from '../../types';
 interface GetBinaryParams {
     baseUrl: string;
     path: string;
-    version: VersionArray;
+    release: FirmwareRelease;
 }
-export declare const getBinary: ({ baseUrl, path, version, }: GetBinaryParams) => Promise<BinaryInfo>;
+export declare const getBinary: ({ baseUrl, path, release, }: GetBinaryParams) => Promise<BinaryInfo>;
 export declare const getBinaryOptional: (params: GetBinaryParams) => Promise<BinaryInfo | null>;
 export {};
 //# sourceMappingURL=getBinary.d.ts.map

package/lib/api/firmware/getBinary.js

@@ -6,7 +6,7 @@ const parseFirmwareHeaders_1 = require("./parseFirmwareHeaders");
 const constants_1 = require("../../constants");
 const assets_1 = require("../../utils/assets");
 const MIN_FIRMWARE_SIZE_BYTES = 200;
-const getBinary = async ({ baseUrl, path, version, }) => {
+const getBinary = async ({ baseUrl, path, release, }) => {
     const sanitizedBaseUrl = (0, utils_1.removeTrailingSlashes)(baseUrl);
     const url = `${sanitizedBaseUrl}/${path}`;
     const binaryArrayBuffer = (await (0, assets_1.httpRequest)(url, 'binary'));
@@ -18,7 +18,7 @@ const getBinary = async ({ baseUrl, path, version, }) => {
     return {
         binary: binaryArrayBuffer,
         binaryVersion,
-        releaseVersion: version,
+        release,
     };
 };
 exports.getBinary = getBinary;

package/lib/api/firmware/uploadFirmware.js

@@ -45,6 +45,11 @@ const uploadFirmware = async ({ typedCall, postMessage, device, firmwareUploadRe
         const length = payload.byteLength;
         let progress = 0;
         let response = await typedCall('FirmwareErase', ['FirmwareRequest', 'Success'], { length });
+        postMessage((0, events_1.createUiMessage)(events_1.UI.FIRMWARE_PROGRESS, {
+            device: device.toMessageObject(),
+            operation: 'start-flashing',
+            progress,
+        }));
         while (response.type !== 'Success') {
             const start = response.message.offset;
             const end = response.message.offset + response.message.length;

package/lib/api/monero/api/index.d.ts

@@ -0,0 +1,5 @@
+export { default as moneroGetAddress } from './moneroGetAddress';
+export { default as moneroGetWatchKey } from './moneroGetWatchKey';
+export { default as moneroKeyImageSync } from './moneroKeyImageSync';
+export { default as moneroSignTransaction } from './moneroSignTransaction';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.moneroSignTransaction = exports.moneroKeyImageSync = exports.moneroGetWatchKey = exports.moneroGetAddress = void 0;
+const tslib_1 = require("tslib");
+var moneroGetAddress_1 = require("./moneroGetAddress");
+Object.defineProperty(exports, "moneroGetAddress", { enumerable: true, get: function () { return tslib_1.__importDefault(moneroGetAddress_1).default; } });
+var moneroGetWatchKey_1 = require("./moneroGetWatchKey");
+Object.defineProperty(exports, "moneroGetWatchKey", { enumerable: true, get: function () { return tslib_1.__importDefault(moneroGetWatchKey_1).default; } });
+var moneroKeyImageSync_1 = require("./moneroKeyImageSync");
+Object.defineProperty(exports, "moneroKeyImageSync", { enumerable: true, get: function () { return tslib_1.__importDefault(moneroKeyImageSync_1).default; } });
+var moneroSignTransaction_1 = require("./moneroSignTransaction");
+Object.defineProperty(exports, "moneroSignTransaction", { enumerable: true, get: function () { return tslib_1.__importDefault(moneroSignTransaction_1).default; } });
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,27 @@
+import { PROTO } from '../../../constants';
+import { AbstractMethod } from '../../../core/AbstractMethod';
+import { Address } from '../../../types/params';
+type Params = PROTO.MoneroGetAddress & {
+    address?: string;
+};
+export default class MoneroGetAddress extends AbstractMethod<'moneroGetAddress', Params[]> {
+    hasBundle?: boolean;
+    progress: number;
+    init(): void;
+    get info(): string;
+    getButtonRequestData(code: string): {
+        type: "address";
+        serializedPath: string;
+        address: string;
+    } | undefined;
+    get confirmation(): {
+        view: "export-address";
+        label: string;
+    };
+    _call({ address_n, show_display, network_type, account, minor, payment_id, chunkify, }: Params): Promise<{
+        address: string;
+    }>;
+    run(): Promise<Address | Address[]>;
+}
+export {};
+//# sourceMappingURL=moneroGetAddress.d.ts.map

package/lib/api/monero/api/moneroGetAddress.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const constants_1 = require("../../../constants");
+const AbstractMethod_1 = require("../../../core/AbstractMethod");
+const coinInfo_1 = require("../../../data/coinInfo");
+const pathUtils_1 = require("../../../utils/pathUtils");
+const paramsValidator_1 = require("../../common/paramsValidator");
+class MoneroGetAddress extends AbstractMethod_1.AbstractMethod {
+    hasBundle;
+    progress = 0;
+    init() {
+        this.noBackupConfirmationMode = 'always';
+        this.requiredPermissions = ['read'];
+        this.requiredDeviceCapabilities = ['Capability_Monero'];
+        this.firmwareRange = (0, paramsValidator_1.getFirmwareRange)(this.name, (0, coinInfo_1.getMiscNetwork)('Monero'), this.firmwareRange);
+        this.hasBundle = !!this.payload.bundle;
+        const payload = !this.payload.bundle
+            ? { ...this.payload, bundle: [this.payload] }
+            : this.payload;
+        const bundle = payload.bundle.map(batch => {
+            const path = (0, pathUtils_1.validatePath)(batch.path, 3);
+            const allHardened = path.every(component => (component & pathUtils_1.HD_HARDENED) !== 0);
+            if (!allHardened) {
+                throw constants_1.ERRORS.TypedError('Method_InvalidParameter', `Monero requires all path components to be hardened. Use m/44'/128'/0' format.`);
+            }
+            return {
+                address_n: path,
+                address: batch.address,
+                show_display: typeof batch.showOnTrezor === 'boolean' ? batch.showOnTrezor : true,
+                network_type: batch.networkType || constants_1.PROTO.MoneroNetworkType.MAINNET,
+                account: batch.account,
+                minor: batch.minor,
+                payment_id: batch.paymentId,
+                chunkify: typeof batch.chunkify === 'boolean' ? batch.chunkify : false,
+            };
+        });
+        this.params = bundle;
+        const useEventListener = payload.useEventListener &&
+            this.params.length === 1 &&
+            typeof this.params[0].address === 'string' &&
+            this.params[0].show_display;
+        this.useUi = !useEventListener;
+    }
+    get info() {
+        return 'Export Monero address';
+    }
+    getButtonRequestData(code) {
+        if (code === 'ButtonRequest_Address') {
+            const { address_n, address } = this.params[this.progress];
+            return {
+                type: 'address',
+                serializedPath: (0, pathUtils_1.getSerializedPath)(address_n),
+                address: address || 'not-set',
+            };
+        }
+    }
+    get confirmation() {
+        return {
+            view: 'export-address',
+            label: this.info,
+        };
+    }
+    async _call({ address_n, show_display, network_type, account, minor, payment_id, chunkify, }) {
+        const cmd = this.device.getCommands();
+        const response = await cmd.typedCall('MoneroGetAddress', 'MoneroAddress', {
+            address_n,
+            show_display,
+            network_type,
+            account,
+            minor,
+            payment_id,
+            chunkify,
+        });
+        const addressHex = response.message.address;
+        const addressBytes = Buffer.from(addressHex, 'hex');
+        const address = addressBytes.toString('utf8');
+        return {
+            address,
+        };
+    }
+    async run() {
+        const responses = [];
+        for (let i = 0; i < this.params.length; i++) {
+            const response = await this._call(this.params[i]);
+            responses.push({
+                address: response.address,
+                path: this.params[i].address_n,
+                serializedPath: (0, pathUtils_1.getSerializedPath)(this.params[i].address_n),
+            });
+            this.progress++;
+        }
+        return this.hasBundle ? responses : responses[0];
+    }
+}
+exports.default = MoneroGetAddress;
+//# sourceMappingURL=moneroGetAddress.js.map

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

@@ -0,0 +1,13 @@
+import { PROTO } from '../../../constants';
+import { AbstractMethod } from '../../../core/AbstractMethod';
+import type { MoneroWatchKey } from '../../../types/api/monero';
+type Params = PROTO.MoneroGetWatchKey & {
+    address?: string;
+};
+export default class MoneroGetWatchKeyMethod extends AbstractMethod<'moneroGetWatchKey', Params> {
+    init(): void;
+    get info(): string;
+    run(): Promise<MoneroWatchKey>;
+}
+export {};
+//# sourceMappingURL=moneroGetWatchKey.d.ts.map

package/lib/api/monero/api/moneroGetWatchKey.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const constants_1 = require("../../../constants");
+const AbstractMethod_1 = require("../../../core/AbstractMethod");
+const coinInfo_1 = require("../../../data/coinInfo");
+const pathUtils_1 = require("../../../utils/pathUtils");
+const paramsValidator_1 = require("../../common/paramsValidator");
+class MoneroGetWatchKeyMethod extends AbstractMethod_1.AbstractMethod {
+    init() {
+        this.requiredPermissions = ['read'];
+        this.requiredDeviceCapabilities = ['Capability_Monero'];
+        this.firmwareRange = (0, paramsValidator_1.getFirmwareRange)(this.name, (0, coinInfo_1.getMiscNetwork)('Monero'), this.firmwareRange);
+        const { payload } = this;
+        const path = (0, pathUtils_1.validatePath)(payload.path, 3);
+        const allHardened = path.every(component => (component & pathUtils_1.HD_HARDENED) !== 0);
+        if (!allHardened) {
+            throw constants_1.ERRORS.TypedError('Method_InvalidParameter', `Monero requires all path components to be hardened. Use m/44'/128'/0' format.`);
+        }
+        this.params = {
+            address_n: path,
+            network_type: payload.networkType || constants_1.PROTO.MoneroNetworkType.MAINNET,
+        };
+    }
+    get info() {
+        return 'Export Monero watch-only credentials';
+    }
+    async run() {
+        const cmd = this.device.getCommands();
+        const response = await cmd.typedCall('MoneroGetWatchKey', 'MoneroWatchKey', {
+            address_n: this.params.address_n,
+            network_type: this.params.network_type,
+        });
+        const addressHex = response.message.address;
+        const addressBytes = Buffer.from(addressHex, 'hex');
+        const address = addressBytes.toString('utf8');
+        return {
+            watch_key: response.message.watch_key,
+            address,
+        };
+    }
+}
+exports.default = MoneroGetWatchKeyMethod;
+//# sourceMappingURL=moneroGetWatchKey.js.map

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

@@ -0,0 +1,16 @@
+import { PROTO } from '../../../constants';
+import { AbstractMethod } from '../../../core/AbstractMethod';
+import type { MoneroKeyImageSyncResult } from '../../../types/api/monero';
+type Params = {
+    address_n: number[];
+    network_type: PROTO.MoneroNetworkType;
+    subs: PROTO.MoneroSubAddressIndicesList[];
+    tdis: PROTO.MoneroTransferDetails[];
+};
+export default class MoneroKeyImageSyncMethod extends AbstractMethod<'moneroKeyImageSync', Params> {
+    init(): void;
+    get info(): string;
+    run(): Promise<MoneroKeyImageSyncResult>;
+}
+export {};
+//# sourceMappingURL=moneroKeyImageSync.d.ts.map

package/lib/api/monero/api/moneroKeyImageSync.js

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const sha3_1 = require("@noble/hashes/sha3");
+const utils_1 = require("@noble/hashes/utils");
+const constants_1 = require("../../../constants");
+const AbstractMethod_1 = require("../../../core/AbstractMethod");
+const coinInfo_1 = require("../../../data/coinInfo");
+const pathUtils_1 = require("../../../utils/pathUtils");
+const paramsValidator_1 = require("../../common/paramsValidator");
+function encodeVarint(n) {
+    const bytes = [];
+    while (n >= 0x80) {
+        bytes.push((n & 0x7f) | 0x80);
+        n >>= 7;
+    }
+    bytes.push(n & 0x7f);
+    return new Uint8Array(bytes);
+}
+class MoneroKeyImageSyncMethod extends AbstractMethod_1.AbstractMethod {
+    init() {
+        this.requiredPermissions = ['read'];
+        this.requiredDeviceCapabilities = ['Capability_Monero'];
+        this.firmwareRange = (0, paramsValidator_1.getFirmwareRange)(this.name, (0, coinInfo_1.getMiscNetwork)('Monero'), this.firmwareRange);
+        const { payload } = this;
+        const path = (0, pathUtils_1.validatePath)(payload.path, 3);
+        const allHardened = path.every(component => (component & pathUtils_1.HD_HARDENED) !== 0);
+        if (!allHardened) {
+            throw constants_1.ERRORS.TypedError('Method_InvalidParameter', `Monero requires all path components to be hardened. Use m/44'/128'/0' format.`);
+        }
+        if (!payload.tdis || payload.tdis.length === 0) {
+            throw constants_1.ERRORS.TypedError('Method_InvalidParameter', 'tdis (transfer details) array is required and cannot be empty');
+        }
+        const tdis = payload.tdis.map((tdi, index) => {
+            if (tdi.out_key.length !== 64) {
+                throw constants_1.ERRORS.TypedError('Method_InvalidParameter', `Invalid out_key length at index ${index}: expected 64 hex characters, got ${tdi.out_key.length}`);
+            }
+            if (tdi.tx_pub_key.length !== 64) {
+                throw constants_1.ERRORS.TypedError('Method_InvalidParameter', `Invalid tx_pub_key length at index ${index}: expected 64 hex characters, got ${tdi.tx_pub_key.length}`);
+            }
+            let additionalKeys = [];
+            const addlKeys = tdi.additional_tx_pub_keys;
+            if (addlKeys) {
+                if (Array.isArray(addlKeys)) {
+                    additionalKeys = addlKeys;
+                }
+                else if (typeof addlKeys === 'string') {
+                    const trimmed = addlKeys.trim();
+                    if (trimmed) {
+                        additionalKeys = trimmed.split(',').map((k) => k.trim());
+                    }
+                }
+            }
+            additionalKeys.forEach((key, keyIndex) => {
+                if (key && key.length !== 64) {
+                    throw constants_1.ERRORS.TypedError('Method_InvalidParameter', `Invalid additional_tx_pub_keys[${keyIndex}] length at tdi index ${index}: expected 64 hex characters, got ${key.length}`);
+                }
+            });
+            return {
+                out_key: (0, utils_1.hexToBytes)(tdi.out_key),
+                tx_pub_key: (0, utils_1.hexToBytes)(tdi.tx_pub_key),
+                additional_tx_pub_keys: additionalKeys.map(k => (0, utils_1.hexToBytes)(k)),
+                internal_output_index: tdi.internal_output_index,
+                sub_addr_major: tdi.sub_addr_major,
+                sub_addr_minor: tdi.sub_addr_minor,
+            };
+        });
+        this.params = {
+            address_n: path,
+            network_type: payload.networkType || constants_1.PROTO.MoneroNetworkType.MAINNET,
+            subs: payload.subs || [],
+            tdis,
+        };
+    }
+    get info() {
+        return 'Export Monero key images for spent output tracking';
+    }
+    async run() {
+        const cmd = this.device.getCommands();
+        const tdHashes = [];
+        for (const tdi of this.params.tdis) {
+            const kck = sha3_1.keccak_256.create();
+            kck.update(tdi.out_key);
+            kck.update(tdi.tx_pub_key);
+            if (tdi.additional_tx_pub_keys && tdi.additional_tx_pub_keys.length > 0) {
+                for (const addKey of tdi.additional_tx_pub_keys) {
+                    kck.update(addKey);
+                }
+            }
+            const indexVarint = encodeVarint(tdi.internal_output_index);
+            kck.update(indexVarint);
+            tdHashes.push(kck.digest());
+        }
+        const finalKck = sha3_1.keccak_256.create();
+        for (const hash of tdHashes) {
+            finalKck.update(hash);
+        }
+        const hashBytes = finalKck.digest();
+        const numOutputs = this.params.tdis.length;
+        await cmd.typedCall('MoneroKeyImageExportInitRequest', 'MoneroKeyImageExportInitAck', {
+            num: numOutputs,
+            hash: hashBytes,
+            address_n: this.params.address_n,
+            network_type: this.params.network_type,
+            subs: this.params.subs,
+        });
+        const allKeyImages = [];
+        const stepResponse = await cmd.typedCall('MoneroKeyImageSyncStepRequest', 'MoneroKeyImageSyncStepAck', {
+            tdis: this.params.tdis,
+        });
+        allKeyImages.push(...stepResponse.message.kis);
+        const finalResponse = await cmd.typedCall('MoneroKeyImageSyncFinalRequest', 'MoneroKeyImageSyncFinalAck', {});
+        const encKey = finalResponse.message.enc_key;
+        if (!encKey) {
+            throw constants_1.ERRORS.TypedError('Runtime', 'Device did not return encryption key for key images');
+        }
+        const keyImages = allKeyImages.map(ki => ({
+            iv: ki.iv || '',
+            key_image: ki.blob || '',
+        }));
+        return {
+            key_images: keyImages,
+            signature: encKey,
+        };
+    }
+}
+exports.default = MoneroKeyImageSyncMethod;
+//# sourceMappingURL=moneroKeyImageSync.js.map

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

@@ -0,0 +1,16 @@
+import { PROTO } from '../../../constants';
+import { AbstractMethod, MethodReturnType } from '../../../core/AbstractMethod';
+type Params = {
+    address_n: number[];
+    network_type: PROTO.MoneroNetworkType;
+    tsx_data: PROTO.MoneroTransactionData;
+    inputs: PROTO.MoneroTransactionSourceEntry[];
+};
+export default class MoneroSignTransactionMethod extends AbstractMethod<'moneroSignTransaction', Params> {
+    private state;
+    init(): void;
+    get info(): string;
+    run(): Promise<MethodReturnType<typeof this.name>>;
+}
+export {};
+//# sourceMappingURL=moneroSignTransaction.d.ts.map