@trezor/connect 9.0.2 → 9.0.4

package/README.md

@@ -1,6 +1,6 @@
 # @trezor/connect
 
-API version 9.0.2
+API version 9.0.4
 
 [![Build Status](https://github.com/trezor/trezor-suite/actions/workflows/connect-test.yml/badge.svg)](https://github.com/trezor/trezor-suite/actions/workflows/connect-test.yml)
 [![NPM](https://img.shields.io/npm/v/@trezor/connect.svg)](https://www.npmjs.org/package/@trezor/connect)
@@ -8,7 +8,7 @@ API version 9.0.2
 
 Trezor Connect is a platform for easy integration of Trezor into 3rd party services, as well as into Trezor Suite. It provides an API with functionality to access public keys, sign transactions and authenticate users.
 
-This package is intended to be used in node.js environment. If you wan't to build a web application please refer to [@trezor/connect-web package](../connect-web/README.md).
+This package is intended to be used in node.js environment. If you wan't to build a web application please refer to [@trezor/connect-web package](https://github.com/trezor/trezor-suite/blob/develop/packages/connect-web/README.md).
 
 ## Installation
 
@@ -32,7 +32,7 @@ ES6
 import TrezorConnect from '@trezor/connect';
 ```
 
-For more instructions [refer to this document](../../docs/packages/connect/index.md)
+For more instructions [refer to this document](https://github.com/trezor/trezor-suite/blob/develop/docs/packages/connect/index.md)
 
 ## Version 9 (stable)
 
@@ -61,11 +61,11 @@ For deployment process of trezor-connect v8 refer to [trezor/connect repository]
 
 Interactive API explorer is available on https://connect.trezor.io/9/#/
 
-Documentation is available [docs/packages/connect](../../docs/packages/connect/index.md)
+Documentation is available [docs/packages/connect](https://github.com/trezor/trezor-suite/blob/develop/docs/packages/connect/index.md)
 
 ## Examples
 
-A collection of examples on how to implement @trezor/connect in various environments is available in [packages/connect-examples](../connect-examples/README.md)
+A collection of examples on how to implement @trezor/connect in various environments is available in [packages/connect-examples](https://github.com/trezor/trezor-suite/tree/develop/packages/connect-examples)
 
 ## Tests
 

package/lib/api/authorizeCoinJoin.js

@@ -16,11 +16,13 @@ class AuthorizeCoinJoin extends AbstractMethod_1.AbstractMethod {
             { name: 'coin', type: 'string' },
             { name: 'scriptType', type: 'string' },
             { name: 'amountUnit', type: 'uint' },
+            { name: 'preauthorized', type: 'boolean' },
         ]);
         const address_n = (0, pathUtils_1.validatePath)(payload.path, 3);
         const script_type = payload.scriptType || (0, pathUtils_1.getScriptType)(address_n);
         const coinInfo = (0, coinInfo_1.getBitcoinNetwork)(payload.coin || address_n);
         this.firmwareRange = (0, paramsValidator_1.getFirmwareRange)(this.name, coinInfo, this.firmwareRange);
+        this.preauthorized = payload.preauthorized;
         this.params = {
             coordinator: payload.coordinator,
             max_rounds: payload.maxRounds,
@@ -34,8 +36,10 @@ class AuthorizeCoinJoin extends AbstractMethod_1.AbstractMethod {
     }
     async run() {
         const cmd = this.device.getCommands();
-        if (!this.device.features.experimental_features) {
-            await cmd.typedCall('ApplySettings', 'Success', { experimental_features: true });
+        if (this.preauthorized) {
+            if (await cmd.preauthorize(false)) {
+                return { message: 'Success' };
+            }
         }
         const response = await cmd.typedCall('AuthorizeCoinJoin', 'Success', this.params);
         return response.message;

package/lib/api/bitcoin/TransactionComposer.js

@@ -28,11 +28,12 @@ class TransactionComposer {
             if (!u.required && new bignumber_js_1.default(u.amount).lte(this.coinInfo.dustLimit))
                 return [];
             const addressPath = (0, pathUtils_1.getHDPath)(u.path);
+            const [chain, index] = addressPath.slice(addressPath.length - 2);
             return {
                 index: u.vout,
                 transactionHash: u.txid,
                 value: u.amount,
-                addressPath: [addressPath[3], addressPath[4]],
+                addressPath: [chain, index],
                 height: u.blockHeight,
                 tsize: 0,
                 vsize: 0,

package/lib/api/bitcoin/enhanceSignTx.js

@@ -15,7 +15,7 @@ const enhanceSignTx = (options, coinInfo) => {
             options.version_group_id = 0x26a7270a;
         }
         if (typeof options.branch_id !== 'number') {
-            const backend = (0, BlockchainLink_1.findBackend)(coinInfo.name);
+            const backend = (0, BlockchainLink_1.findBackend)(coinInfo.shortcut);
             if (backend && ((_a = backend.serverInfo) === null || _a === void 0 ? void 0 : _a.consensusBranchId)) {
                 options.branch_id = backend.serverInfo.consensusBranchId;
             }

package/lib/api/bitcoin/inputs.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.inputToTrezor = exports.enhanceTrezorInputs = exports.validateTrezorInputs = void 0;
-const bufferUtils_1 = require("../../utils/bufferUtils");
+const utils_1 = require("@trezor/utils");
 const pathUtils_1 = require("../../utils/pathUtils");
 const hdnodeUtils_1 = require("../../utils/hdnodeUtils");
 const paramsValidator_1 = require("../common/paramsValidator");
@@ -17,6 +17,7 @@ const validateTrezorInputs = (inputs, coinInfo) => inputs
         { name: 'script_type', type: 'string' },
         { name: 'sequence', type: 'number' },
         { name: 'multisig', type: 'object' },
+        { name: 'coinjoin_flags', type: 'number' },
     ]);
     if (input.script_type === 'EXTERNAL') {
         (0, paramsValidator_1.validateParams)(input, [
@@ -50,7 +51,7 @@ const inputToTrezor = (input, sequence) => {
     return {
         address_n,
         prev_index: input.index,
-        prev_hash: (0, bufferUtils_1.reverseBuffer)(input.hash).toString('hex'),
+        prev_hash: utils_1.bufferUtils.reverseBuffer(input.hash).toString('hex'),
         script_type: (0, pathUtils_1.getScriptType)(address_n),
         amount: input.amount,
         sequence,

package/lib/api/bitcoin/outputs.js

@@ -22,10 +22,8 @@ const validateTrezorOutputs = (outputs, coinInfo) => {
             Object.prototype.hasOwnProperty.call(output, 'address')) {
             throw constants_1.ERRORS.TypedError('Method_InvalidParameter', 'Cannot use address and address_n in one output');
         }
-        if (output.address_n) {
-            const scriptType = (0, pathUtils_1.getOutputScriptType)(output.address_n);
-            if (output.script_type !== scriptType)
-                throw constants_1.ERRORS.TypedError('Method_InvalidParameter', `Output change script_type should be set to ${scriptType}`);
+        if (output.address_n && !output.script_type) {
+            output.script_type = (0, pathUtils_1.getOutputScriptType)(output.address_n);
         }
         if ('address' in output &&
             typeof output.address === 'string' &&

package/lib/api/bitcoin/refTx.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.validateReferencedTransactions = exports.transformReferencedTransactions = exports.transformOrigTransactions = exports.getOrigTransactions = exports.getReferencedTransactions = exports.requireReferencedTransactions = void 0;
 const utxo_lib_1 = require("@trezor/utxo-lib");
-const bufferUtils_1 = require("../../utils/bufferUtils");
+const utils_1 = require("@trezor/utils");
 const pathUtils_1 = require("../../utils/pathUtils");
 const paramsValidator_1 = require("../common/paramsValidator");
 const errors_1 = require("../../constants/errors");
@@ -72,7 +72,7 @@ const transformOrigTransactions = (txs, coinInfo, addresses) => txs.flatMap(raw
         const address_n = (0, pathUtils_1.getHDPath)((inputAddress === null || inputAddress === void 0 ? void 0 : inputAddress.path) || '');
         return {
             address_n,
-            prev_hash: (0, bufferUtils_1.reverseBuffer)(input.hash).toString('hex'),
+            prev_hash: utils_1.bufferUtils.reverseBuffer(input.hash).toString('hex'),
             prev_index: input.index,
             script_sig: input.script.toString('hex'),
             sequence: input.sequence,
@@ -139,7 +139,7 @@ const transformReferencedTransactions = (txs, coinInfo) => txs.flatMap(raw => {
     const inputsMap = (input) => ({
         prev_index: input.index,
         sequence: input.sequence,
-        prev_hash: (0, bufferUtils_1.reverseBuffer)(input.hash).toString('hex'),
+        prev_hash: utils_1.bufferUtils.reverseBuffer(input.hash).toString('hex'),
         script_sig: input.script.toString('hex'),
     });
     const binOutputsMap = (output) => ({

package/lib/api/bitcoin/signtxVerify.d.ts

@@ -1,8 +1,8 @@
 import { PROTO } from '../../constants';
 import type { BitcoinNetworkInfo } from '../../types';
-import type { HDNodeResponse } from '../../types/api/getPublicKey';
-declare type GetHDNode = (path: number[], coinInfo?: BitcoinNetworkInfo, validation?: boolean) => Promise<HDNodeResponse>;
-export declare const verifyTx: (getHDNode: GetHDNode, inputs: PROTO.TxInputType[], outputs: PROTO.TxOutputType[], serializedTx: string, coinInfo: BitcoinNetworkInfo) => Promise<import("packages/utxo-lib/lib/transaction/base").TransactionBase<undefined> | import("packages/utxo-lib/lib/transaction/base").TransactionBase<import("packages/utxo-lib/lib/transaction/dash").DashSpecific> | import("packages/utxo-lib/lib/transaction/base").TransactionBase<import("packages/utxo-lib/lib/transaction/zcash").ZcashSpecific>>;
+import type { DeviceCommands } from '../../device/DeviceCommands';
+declare type GetHDNode = DeviceCommands['getHDNode'];
+export declare const verifyTx: (getHDNode: GetHDNode, inputs: PROTO.TxInputType[], outputs: PROTO.TxOutputType[], serializedTx: string, coinInfo: BitcoinNetworkInfo, unlockPath?: PROTO.UnlockPath) => Promise<import("packages/utxo-lib/lib/transaction/base").TransactionBase<undefined> | import("packages/utxo-lib/lib/transaction/base").TransactionBase<import("packages/utxo-lib/lib/transaction/dash").DashSpecific> | import("packages/utxo-lib/lib/transaction/base").TransactionBase<import("packages/utxo-lib/lib/transaction/zcash").ZcashSpecific>>;
 export declare const verifyTicketTx: (getHDNode: GetHDNode, inputs: PROTO.TxInputType[], outputs: PROTO.TxOutputType[], serializedTx: string, coinInfo: BitcoinNetworkInfo) => Promise<void>;
 export {};
 //# sourceMappingURL=signtxVerify.d.ts.map

package/lib/api/bitcoin/signtxVerify.js

@@ -3,17 +3,16 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.verifyTicketTx = exports.verifyTx = void 0;
 const utxo_lib_1 = require("@trezor/utxo-lib");
 const constants_1 = require("../../constants");
-const pathUtils_1 = require("../../utils/pathUtils");
-const derivePubKeyHash = async (address_n, getHDNode, coinInfo) => {
+const derivePubKeyHash = async (address_n, getHDNode, coinInfo, unlockPath) => {
     if (address_n.length === 5) {
-        const response = await getHDNode(address_n.slice(0, 4), coinInfo);
+        const response = await getHDNode({ address_n: address_n.slice(0, 4) }, { coinInfo, unlockPath });
         const node = utxo_lib_1.bip32.fromBase58(response.xpub, coinInfo.network);
         return node.derive(address_n[address_n.length - 1]);
     }
-    const response = await getHDNode(address_n, coinInfo);
+    const response = await getHDNode({ address_n }, { coinInfo, unlockPath });
     return utxo_lib_1.bip32.fromBase58(response.xpub, coinInfo.network);
 };
-const deriveOutputScript = async (getHDNode, output, coinInfo) => {
+const deriveOutputScript = async (getHDNode, output, coinInfo, unlockPath) => {
     if ('multisig' in output)
         return;
     if ('op_return_data' in output) {
@@ -26,32 +25,34 @@ const deriveOutputScript = async (getHDNode, output, coinInfo) => {
     if (!output.address_n) {
         throw constants_1.ERRORS.TypedError('Runtime', 'deriveOutputScript: Neither address or address_n is set');
     }
-    const scriptType = (0, pathUtils_1.getOutputScriptType)(output.address_n);
-    const node = await derivePubKeyHash(output.address_n, getHDNode, coinInfo);
+    const node = await derivePubKeyHash(output.address_n, getHDNode, coinInfo, unlockPath);
     const payment = { hash: node.identifier, network: coinInfo.network };
-    if (scriptType === 'PAYTOADDRESS') {
+    if (output.script_type === 'PAYTOADDRESS') {
         return utxo_lib_1.payments.p2pkh(payment).output;
     }
-    if (scriptType === 'PAYTOSCRIPTHASH') {
+    if (output.script_type === 'PAYTOSCRIPTHASH') {
         return utxo_lib_1.payments.p2sh(payment).output;
     }
-    if (scriptType === 'PAYTOP2SHWITNESS') {
+    if (output.script_type === 'PAYTOP2SHWITNESS') {
         return utxo_lib_1.payments.p2sh({
             redeem: utxo_lib_1.payments.p2wpkh(payment),
         }).output;
     }
-    if (scriptType === 'PAYTOWITNESS') {
+    if (output.script_type === 'PAYTOWITNESS') {
         return utxo_lib_1.payments.p2wpkh(payment).output;
     }
-    if (scriptType === 'PAYTOTAPROOT') {
+    if (output.script_type === 'PAYTOTAPROOT') {
         return utxo_lib_1.payments.p2tr({
             pubkey: node.publicKey,
             network: coinInfo.network,
         }).output;
     }
-    throw constants_1.ERRORS.TypedError('Runtime', `deriveOutputScript: Unknown script type ${scriptType}`);
+    if (output.script_type === 'PAYTOMULTISIG') {
+        throw constants_1.ERRORS.TypedError('Runtime', `deriveOutputScript: script_type PAYTOMULTISIG not expected without multisig defined`);
+    }
+    throw constants_1.ERRORS.TypedError('Runtime', `deriveOutputScript: Unknown script type ${output.script_type}`);
 };
-const verifyTx = async (getHDNode, inputs, outputs, serializedTx, coinInfo) => {
+const verifyTx = async (getHDNode, inputs, outputs, serializedTx, coinInfo, unlockPath) => {
     const bitcoinTx = utxo_lib_1.Transaction.fromHex(serializedTx, { network: coinInfo.network });
     if (inputs.length !== bitcoinTx.ins.length) {
         throw constants_1.ERRORS.TypedError('Runtime', 'verifyTx: Signed transaction inputs invalid length');
@@ -67,7 +68,7 @@ const verifyTx = async (getHDNode, inputs, outputs, serializedTx, coinInfo) => {
                 throw constants_1.ERRORS.TypedError('Runtime', `verifyTx: Wrong output amount at output ${i}. Requested: ${amount}, signed: ${bitcoinTx.outs[i].value}`);
             }
         }
-        const scriptA = await deriveOutputScript(getHDNode, outputs[i], coinInfo);
+        const scriptA = await deriveOutputScript(getHDNode, outputs[i], coinInfo, unlockPath);
         if (scriptA && scriptA.compare(scriptB) !== 0) {
             throw constants_1.ERRORS.TypedError('Runtime', `verifyTx: Output ${i} scripts differ`);
         }

package/lib/api/blockchainDisconnect.js

@@ -23,7 +23,7 @@ class BlockchainDisconnect extends AbstractMethod_1.AbstractMethod {
         };
     }
     run() {
-        const backend = (0, BlockchainLink_1.findBackend)(this.params.coinInfo.name);
+        const backend = (0, BlockchainLink_1.findBackend)(this.params.coinInfo.shortcut);
         if (backend) {
             backend.disconnect();
         }

package/lib/api/blockchainSetCustomBackend.js

@@ -26,7 +26,7 @@ class BlockchainSetCustomBackend extends AbstractMethod_1.AbstractMethod {
         };
     }
     async run() {
-        const current = (0, BlockchainLink_1.findBackend)(this.params.coinInfo.name);
+        const current = (0, BlockchainLink_1.findBackend)(this.params.coinInfo.shortcut);
         if (current) {
             current.disconnect();
             await (0, BlockchainLink_1.initBlockchain)(this.params.coinInfo, this.postMessage);

package/lib/api/cardano/cardanoAuxiliaryData.d.ts

@@ -1,5 +1,5 @@
 import type { Device } from '../../device/Device';
-import type { PROTO } from '../../constants';
+import { PROTO } from '../../constants';
 import type { CardanoAuxiliaryData } from '../../types/api/cardano';
 export declare const transformAuxiliaryData: (auxiliaryData: CardanoAuxiliaryData) => PROTO.CardanoTxAuxiliaryData;
 export declare const modifyAuxiliaryDataForBackwardsCompatibility: (device: Device, auxiliary_data: PROTO.CardanoTxAuxiliaryData) => PROTO.CardanoTxAuxiliaryData;

package/lib/api/cardano/cardanoAuxiliaryData.js

@@ -4,18 +4,40 @@ exports.modifyAuxiliaryDataForBackwardsCompatibility = exports.transformAuxiliar
 const cardanoAddressParameters_1 = require("./cardanoAddressParameters");
 const paramsValidator_1 = require("../common/paramsValidator");
 const pathUtils_1 = require("../../utils/pathUtils");
-const transformCatalystRegistrationParameters = (catalystRegistrationParameters) => {
-    (0, paramsValidator_1.validateParams)(catalystRegistrationParameters, [
+const constants_1 = require("../../constants");
+const MAX_DELEGATION_COUNT = 32;
+const transformDelegation = (delegation) => {
+    (0, paramsValidator_1.validateParams)(delegation, [
         { name: 'votingPublicKey', type: 'string', required: true },
+        { name: 'weight', type: 'uint', required: true },
+    ]);
+    return {
+        voting_public_key: delegation.votingPublicKey,
+        weight: delegation.weight,
+    };
+};
+const transformGovernanceRegistrationParameters = (governanceRegistrationParameters) => {
+    (0, paramsValidator_1.validateParams)(governanceRegistrationParameters, [
+        { name: 'votingPublicKey', type: 'string' },
         { name: 'stakingPath', required: true },
         { name: 'nonce', type: 'uint', required: true },
+        { name: 'format', type: 'number' },
+        { name: 'delegations', type: 'array', allowEmpty: true },
+        { name: 'votingPurpose', type: 'uint' },
     ]);
-    (0, cardanoAddressParameters_1.validateAddressParameters)(catalystRegistrationParameters.rewardAddressParameters);
+    (0, cardanoAddressParameters_1.validateAddressParameters)(governanceRegistrationParameters.rewardAddressParameters);
+    const { delegations } = governanceRegistrationParameters;
+    if (delegations && delegations.length > MAX_DELEGATION_COUNT) {
+        throw constants_1.ERRORS.TypedError('Method_InvalidParameter', `At most ${MAX_DELEGATION_COUNT} delegations are allowed in a governance registration`);
+    }
     return {
-        voting_public_key: catalystRegistrationParameters.votingPublicKey,
-        staking_path: (0, pathUtils_1.validatePath)(catalystRegistrationParameters.stakingPath, 3),
-        reward_address_parameters: (0, cardanoAddressParameters_1.addressParametersToProto)(catalystRegistrationParameters.rewardAddressParameters),
-        nonce: catalystRegistrationParameters.nonce,
+        voting_public_key: governanceRegistrationParameters.votingPublicKey,
+        staking_path: (0, pathUtils_1.validatePath)(governanceRegistrationParameters.stakingPath, 3),
+        reward_address_parameters: (0, cardanoAddressParameters_1.addressParametersToProto)(governanceRegistrationParameters.rewardAddressParameters),
+        nonce: governanceRegistrationParameters.nonce,
+        format: governanceRegistrationParameters.format,
+        delegations: delegations === null || delegations === void 0 ? void 0 : delegations.map(transformDelegation),
+        voting_purpose: governanceRegistrationParameters.votingPurpose,
     };
 };
 const transformAuxiliaryData = (auxiliaryData) => {
@@ -25,24 +47,24 @@ const transformAuxiliaryData = (auxiliaryData) => {
             type: 'string',
         },
     ]);
-    let catalystRegistrationParameters;
-    if (auxiliaryData.catalystRegistrationParameters) {
-        catalystRegistrationParameters = transformCatalystRegistrationParameters(auxiliaryData.catalystRegistrationParameters);
+    let governanceRegistrationParameters;
+    if (auxiliaryData.governanceRegistrationParameters) {
+        governanceRegistrationParameters = transformGovernanceRegistrationParameters(auxiliaryData.governanceRegistrationParameters);
     }
     return {
         hash: auxiliaryData.hash,
-        catalyst_registration_parameters: catalystRegistrationParameters,
+        governance_registration_parameters: governanceRegistrationParameters,
     };
 };
 exports.transformAuxiliaryData = transformAuxiliaryData;
 const modifyAuxiliaryDataForBackwardsCompatibility = (device, auxiliary_data) => {
-    const { catalyst_registration_parameters } = auxiliary_data;
-    if (catalyst_registration_parameters) {
-        catalyst_registration_parameters.reward_address_parameters =
-            (0, cardanoAddressParameters_1.modifyAddressParametersForBackwardsCompatibility)(device, catalyst_registration_parameters.reward_address_parameters);
+    const { governance_registration_parameters } = auxiliary_data;
+    if (governance_registration_parameters) {
+        governance_registration_parameters.reward_address_parameters =
+            (0, cardanoAddressParameters_1.modifyAddressParametersForBackwardsCompatibility)(device, governance_registration_parameters.reward_address_parameters);
         return {
             ...auxiliary_data,
-            catalyst_registration_parameters,
+            governance_registration_parameters,
         };
     }
     return auxiliary_data;

package/lib/api/cardanoSignTransaction.d.ts

@@ -15,6 +15,7 @@ declare const CardanoSignTransactionFeatures: Readonly<{
     Plutus: string[];
     KeyHashStakeCredential: string[];
     Babbage: string[];
+    GovernanceRegistrationCIP36: string[];
 }>;
 export declare type CardanoSignTransactionParams = {
     signingMode: PROTO.CardanoTxSigningMode;

package/lib/api/cardanoSignTransaction.js

@@ -21,6 +21,7 @@ const CardanoSignTransactionFeatures = Object.freeze({
     Plutus: ['0', '2.4.4'],
     KeyHashStakeCredential: ['0', '2.4.4'],
     Babbage: ['0', '2.5.2'],
+    GovernanceRegistrationCIP36: ['0', '2.5.3'],
 });
 class CardanoSignTransaction extends AbstractMethod_1.AbstractMethod {
     init() {
@@ -34,6 +35,11 @@ class CardanoSignTransaction extends AbstractMethod_1.AbstractMethod {
         if (payload.auxiliaryData && payload.auxiliaryData.blob) {
             throw constants_1.ERRORS.TypedError('Method_InvalidParameter', 'Auxiliary data can now only be sent as a hash.');
         }
+        if (payload.auxiliaryData && payload.auxiliaryData.catalystRegistrationParameters) {
+            console.warn('Please use governanceRegistrationParameters instead of catalystRegistrationParameters.');
+            payload.auxiliaryData.governanceRegistrationParameters =
+                payload.auxiliaryData.catalystRegistrationParameters;
+        }
         (0, paramsValidator_1.validateParams)(payload, [
             { name: 'signingMode', type: 'number', required: true },
             { name: 'inputs', type: 'array', required: true },
@@ -148,6 +154,7 @@ class CardanoSignTransaction extends AbstractMethod_1.AbstractMethod {
         }
     }
     _ensureFirmwareSupportsParams() {
+        var _a;
         const { params } = this;
         this._ensureFeatureIsSupported('TransactionStreaming');
         params.certificatesWithPoolOwnersAndRelays.forEach(({ certificate }) => {
@@ -193,6 +200,18 @@ class CardanoSignTransaction extends AbstractMethod_1.AbstractMethod {
             params.referenceInputs.length > 0) {
             this._ensureFeatureIsSupported('Babbage');
         }
+        if (params.requiredSigners.length > 0 &&
+            params.signingMode !== constants_1.PROTO.CardanoTxSigningMode.PLUTUS_TRANSACTION) {
+            this._ensureFeatureIsSupported('Babbage');
+        }
+        if ((_a = params.auxiliaryData) === null || _a === void 0 ? void 0 : _a.governance_registration_parameters) {
+            const { format, delegations, voting_purpose } = params.auxiliaryData.governance_registration_parameters;
+            if (format === constants_1.PROTO.CardanoGovernanceRegistrationFormat.CIP36 ||
+                (delegations === null || delegations === void 0 ? void 0 : delegations.length) ||
+                voting_purpose != null) {
+                this._ensureFeatureIsSupported('GovernanceRegistrationCIP36');
+            }
+        }
     }
     async _sign_tx() {
         const typedCall = this.device.getCommands().typedCall.bind(this.device.getCommands());
@@ -242,8 +261,8 @@ class CardanoSignTransaction extends AbstractMethod_1.AbstractMethod {
         }
         let auxiliaryDataSupplement;
         if (this.params.auxiliaryData) {
-            const { catalyst_registration_parameters } = this.params.auxiliaryData;
-            if (catalyst_registration_parameters) {
+            const { governance_registration_parameters } = this.params.auxiliaryData;
+            if (governance_registration_parameters) {
                 this.params.auxiliaryData = (0, cardanoAuxiliaryData_1.modifyAuxiliaryDataForBackwardsCompatibility)(this.device, this.params.auxiliaryData);
             }
             const { message } = await typedCall('CardanoTxAuxiliaryData', 'CardanoTxAuxiliaryDataSupplement', this.params.auxiliaryData);
@@ -252,7 +271,8 @@ class CardanoSignTransaction extends AbstractMethod_1.AbstractMethod {
                 auxiliaryDataSupplement = {
                     type: auxiliaryDataType,
                     auxiliaryDataHash: message.auxiliary_data_hash,
-                    catalystSignature: message.catalyst_signature,
+                    governanceSignature: message.governance_signature,
+                    catalystSignature: message.governance_signature,
                 };
             }
             await typedCall('CardanoTxHostAck', 'CardanoTxItemAck');

package/lib/api/getAddress.d.ts

@@ -4,6 +4,7 @@ import type { BitcoinNetworkInfo } from '../types';
 declare type Params = PROTO.GetAddress & {
     address?: string;
     coinInfo: BitcoinNetworkInfo;
+    unlockPath?: PROTO.UnlockPath;
 };
 export default class GetAddress extends AbstractMethod<'getAddress', Params[]> {
     hasBundle?: boolean;
@@ -17,7 +18,7 @@ export default class GetAddress extends AbstractMethod<'getAddress', Params[]> {
     } | undefined;
     confirmation(): Promise<boolean>;
     noBackupConfirmation(): Promise<boolean>;
-    _call({ address_n, show_display, multisig, script_type, coinInfo }: Params): Promise<{
+    _call({ address_n, show_display, multisig, script_type, coinInfo, unlockPath }: Params): Promise<{
         path: number[];
         serializedPath: string;
         address: string;

package/lib/api/getAddress.js

@@ -29,7 +29,14 @@ class GetAddress extends AbstractMethod_1.AbstractMethod {
                 { name: 'showOnTrezor', type: 'boolean' },
                 { name: 'multisig', type: 'object' },
                 { name: 'scriptType', type: 'string' },
+                { name: 'unlockPath', type: 'object' },
             ]);
+            if (batch.unlockPath) {
+                (0, paramsValidator_1.validateParams)(batch.unlockPath, [
+                    { name: 'address_n', required: true, type: 'array' },
+                    { name: 'mac', required: true, type: 'string' },
+                ]);
+            }
             const path = (0, pathUtils_1.validatePath)(batch.path, 1);
             let coinInfo;
             if (batch.coin) {
@@ -55,6 +62,7 @@ class GetAddress extends AbstractMethod_1.AbstractMethod {
                 multisig: batch.multisig,
                 script_type: batch.scriptType,
                 coinInfo,
+                unlockPath: batch.unlockPath,
             };
         });
         const useEventListener = payload.useEventListener &&
@@ -108,8 +116,11 @@ class GetAddress extends AbstractMethod_1.AbstractMethod {
         const uiResp = await uiPromise.promise;
         return uiResp.payload;
     }
-    _call({ address_n, show_display, multisig, script_type, coinInfo }) {
+    async _call({ address_n, show_display, multisig, script_type, coinInfo, unlockPath }) {
         const cmd = this.device.getCommands();
+        if (unlockPath) {
+            await cmd.unlockPath(unlockPath);
+        }
         return cmd.getAddress({
             address_n,
             show_display,

package/lib/api/getOwnershipProof.d.ts

@@ -1,14 +1,10 @@
 import { AbstractMethod } from '../core/AbstractMethod';
 import { PROTO } from '../constants';
-interface Params extends PROTO.GetOwnershipProof {
-    preauthorized?: boolean;
-}
-export default class GetOwnershipProof extends AbstractMethod<'getOwnershipProof', Params[]> {
+export default class GetOwnershipProof extends AbstractMethod<'getOwnershipProof', PROTO.GetOwnershipProof[]> {
     hasBundle?: boolean;
     confirmed?: boolean;
     init(): void;
     confirmation(): Promise<boolean>;
     run(): Promise<import("../types/api/getOwnershipProof").OwnershipProof | import("../types/api/getOwnershipProof").OwnershipProof[]>;
 }
-export {};
 //# sourceMappingURL=getOwnershipProof.d.ts.map

package/lib/api/getOwnershipProof.js

@@ -29,6 +29,9 @@ class GetOwnershipProof extends AbstractMethod_1.AbstractMethod {
             const coinInfo = (0, coinInfo_1.getBitcoinNetwork)(batch.coin || address_n);
             const script_type = batch.scriptType || (0, pathUtils_1.getScriptType)(address_n);
             this.firmwareRange = (0, paramsValidator_1.getFirmwareRange)(this.name, coinInfo, this.firmwareRange);
+            if (batch.preauthorized) {
+                this.preauthorized = batch.preauthorized;
+            }
             return {
                 address_n,
                 coin_name: coinInfo ? coinInfo.name : undefined,
@@ -37,7 +40,6 @@ class GetOwnershipProof extends AbstractMethod_1.AbstractMethod {
                 user_confirmation: batch.userConfirmation,
                 ownership_ids: batch.ownershipIds,
                 commitment_data: batch.commitmentData,
-                preauthorized: batch.preauthorized,
             };
         });
     }
@@ -63,8 +65,8 @@ class GetOwnershipProof extends AbstractMethod_1.AbstractMethod {
         const cmd = this.device.getCommands();
         for (let i = 0; i < this.params.length; i++) {
             const batch = this.params[i];
-            if (batch.preauthorized) {
-                await cmd.typedCall('DoPreauthorized', 'PreauthorizedRequest', {});
+            if (this.preauthorized) {
+                await cmd.preauthorize(true);
             }
             const { message } = await cmd.typedCall('GetOwnershipProof', 'OwnershipProof', batch);
             responses.push({

package/lib/api/getPublicKey.d.ts

@@ -3,6 +3,7 @@ import type { BitcoinNetworkInfo } from '../types';
 import type { PROTO } from '../constants';
 declare type Params = PROTO.GetPublicKey & {
     coinInfo?: BitcoinNetworkInfo;
+    unlockPath?: PROTO.UnlockPath;
 };
 export default class GetPublicKey extends AbstractMethod<'getPublicKey', Params[]> {
     hasBundle?: boolean;

package/lib/api/getPublicKey.js

@@ -21,25 +21,40 @@ class GetPublicKey extends AbstractMethod_1.AbstractMethod {
                 { name: 'coin', type: 'string' },
                 { name: 'crossChain', type: 'boolean' },
                 { name: 'showOnTrezor', type: 'boolean' },
+                { name: 'scriptType', type: ['string', 'number'] },
+                { name: 'ignoreXpubMagic', type: 'boolean' },
+                { name: 'ecdsaCurveName', type: 'boolean' },
+                { name: 'unlockPath', type: 'object' },
             ]);
+            if (batch.unlockPath) {
+                (0, paramsValidator_1.validateParams)(batch.unlockPath, [
+                    { name: 'address_n', required: true, type: 'array' },
+                    { name: 'mac', required: true, type: 'string' },
+                ]);
+            }
             let coinInfo;
             if (batch.coin) {
                 coinInfo = (0, coinInfo_1.getBitcoinNetwork)(batch.coin);
             }
-            const path = (0, pathUtils_1.validatePath)(batch.path, coinInfo ? 3 : 0);
+            const address_n = (0, pathUtils_1.validatePath)(batch.path, coinInfo ? 3 : 0);
             if (coinInfo && !batch.crossChain) {
-                (0, paramsValidator_1.validateCoinPath)(path, coinInfo);
+                (0, paramsValidator_1.validateCoinPath)(address_n, coinInfo);
             }
             else if (!coinInfo) {
-                coinInfo = (0, coinInfo_1.getBitcoinNetwork)(path);
+                coinInfo = (0, coinInfo_1.getBitcoinNetwork)(address_n);
             }
             if (coinInfo) {
                 this.firmwareRange = (0, paramsValidator_1.getFirmwareRange)(this.name, coinInfo, this.firmwareRange);
             }
             return {
-                address_n: path,
+                address_n,
+                coin_name: coinInfo === null || coinInfo === void 0 ? void 0 : coinInfo.name,
+                show_display: batch.showOnTrezor,
+                script_type: batch.scriptType,
+                ignore_xpub_magic: batch.ignoreXpubMagic,
+                ecdsa_curve_name: batch.ecdsaCurveName,
                 coinInfo,
-                show_display: typeof batch.showOnTrezor === 'boolean' ? batch.showOnTrezor : false,
+                unlockPath: batch.unlockPath,
             };
         });
     }
@@ -67,8 +82,8 @@ class GetPublicKey extends AbstractMethod_1.AbstractMethod {
         const responses = [];
         const cmd = this.device.getCommands();
         for (let i = 0; i < this.params.length; i++) {
-            const batch = this.params[i];
-            const response = await cmd.getHDNode(batch.address_n, batch.coinInfo, true, batch.show_display);
+            const { coinInfo, unlockPath, ...batch } = this.params[i];
+            const response = await cmd.getHDNode(batch, { coinInfo, unlockPath });
             responses.push(response);
             if (this.hasBundle) {
                 this.postMessage((0, events_1.createUiMessage)(events_1.UI.BUNDLE_PROGRESS, {

package/lib/api/index.d.ts

@@ -51,6 +51,7 @@ export { default as requestLogin } from './requestLogin';
 export { default as resetDevice } from './resetDevice';
 export { default as rippleGetAddress } from './rippleGetAddress';
 export { default as rippleSignTransaction } from './rippleSignTransaction';
+export { default as setBusy } from './setBusy';
 export { default as setProxy } from './setProxy';
 export { default as signMessage } from './signMessage';
 export { default as signTransaction } from './signTransaction';
@@ -59,6 +60,7 @@ export { default as stellarSignTransaction } from './stellarSignTransaction';
 export { default as tezosGetAddress } from './tezosGetAddress';
 export { default as tezosGetPublicKey } from './tezosGetPublicKey';
 export { default as tezosSignTransaction } from './tezosSignTransaction';
+export { default as unlockPath } from './unlockPath';
 export { default as verifyMessage } from './verifyMessage';
 export { default as wipeDevice } from './wipeDevice';
 export { default as checkFirmwareAuthenticity } from './checkFirmwareAuthenticity';